/******************************************************************************
*
* 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
* ideint_cac.c
*
* @brief
* This file include the definitions of the combing artifact check function
* of the de-interlacer and some variant of that.
*
* @author
* Ittiam
*
* @par List of Functions:
* cac_4x8()
* ideint_cac()
*
* @remarks
* In the de-interlacer workspace, cac is not a seperate assembly module as
* it comes along with the de_int_decision() function. But in C-Model, to
* keep the things cleaner, it was made to be a separate function during
* cac experiments long after the assembly was written by Mudit.
*
*******************************************************************************
*/
/*****************************************************************************/
/* File Includes */
/*****************************************************************************/
/* System include files */
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
/* User include files */
#include "icv_datatypes.h"
#include "icv_macros.h"
#include "icv.h"
#include "icv_variance.h"
#include "icv_sad.h"
#include "ideint.h"
#include "ideint_defs.h"
#include "ideint_structs.h"
#include "ideint_cac.h"
/**
*******************************************************************************
*
* @brief
* Combing artifact check function for 8x4 block
*
* @par Description
* Adjacent and alternate SADs are calculated by row based and column-based
* collapsing. The adjacent and alternate SADs are then compared with some
* biasing to get CAC
*
* @param[in] pu1_top
* Top field
*
* @param[in] pu1_bot
* Bottom field
*
* @param[in] top_strd
* Top field Stride
*
* @param[in] bot_strd
* Bottom field stride
*
* @param[in] pi4_adj_sad
* Pointer to return adjacent SAD
*
* @param[in] pi4_alt_sad
* Pointer to return alternate SAD
*
* @returns
* combing artifact flag (1 = detected, 0 = not detected)
*
* @remarks
*
*******************************************************************************
*/
static WORD32 cac_4x8(UWORD8 *pu1_top,
UWORD8 *pu1_bot,
WORD32 top_strd,
WORD32 bot_strd)
{
WORD32 ca;
WORD32 adj;
WORD32 alt;
UWORD8 *pu1_tmp_top;
UWORD8 *pu1_tmp_bot;
WORD32 i;
WORD32 j;
UWORD8 *pu1_top_0;
UWORD8 *pu1_top_1;
UWORD8 *pu1_top_2;
UWORD8 *pu1_top_3;
UWORD8 *pu1_bot_0;
UWORD8 *pu1_bot_1;
UWORD8 *pu1_bot_2;
UWORD8 *pu1_bot_3;
WORD32 rsum_csum_thresh;
WORD32 sad_bias_mult_shift;
WORD32 sad_bias_additive;
WORD32 diff_sum;
WORD32 top_row_end_incr;
WORD32 bot_row_end_incr;
ca = 0;
adj = 0;
alt = 0;
rsum_csum_thresh = RSUM_CSUM_THRESH;
sad_bias_additive = SAD_BIAS_ADDITIVE;
sad_bias_mult_shift = SAD_BIAS_MULT_SHIFT;
/*************************************************************************/
/* In the adjacent sad calculation by row-method, the absolute */
/* difference is taken between the adjacent rows. The pixels of the diff */
/* row, thus obtained, are then summed up. If this sum of absolute */
/* differace (sad) is greater than a threshold value, it is added to the */
/* adjcacent SAD value. */
/*************************************************************************/
/*************************************************************************/
/* Adj dif: Row based */
/*************************************************************************/
pu1_tmp_top = pu1_top;
pu1_tmp_bot = pu1_bot;
top_row_end_incr = top_strd - SUB_BLK_WD;
bot_row_end_incr = bot_strd - SUB_BLK_WD;
/*************************************************************************/
/* The outer-loop runs for BLK_HT/2 times, because one pixel */
/* is touched only once. */
/*************************************************************************/
for(j = 0; j < BLK_HT; j += 4)
{
WORD32 sum_1, sum_2, sum_3, sum_4;
WORD32 sum_diff;
/*********************************************************************/
/* Because the 8x4 is split into two halves of 4x4, the width of the */
/* block is now 4. */
/*********************************************************************/
sum_1 = 0;
sum_2 = 0;
for(i = 0; i < SUB_BLK_WD; i ++)
{
sum_1 += *pu1_tmp_top++;
sum_2 += *pu1_tmp_bot++;
}
sum_diff = ABS_DIF(sum_1, sum_2);
/*********************************************************************/
/* Thresholding. */
/*********************************************************************/
if(sum_diff >= rsum_csum_thresh)
adj += sum_diff;
pu1_tmp_top += top_row_end_incr;
pu1_tmp_bot += bot_row_end_incr;
sum_3 = 0;
sum_4 = 0;
for(i = 0; i < SUB_BLK_WD; i ++)
{
sum_3 += *pu1_tmp_top++;
sum_4 += *pu1_tmp_bot++;
}
sum_diff = ABS_DIF(sum_3, sum_4);
/*********************************************************************/
/* Thresholding. */
/*********************************************************************/
if(sum_diff >= rsum_csum_thresh)
adj += sum_diff;
pu1_tmp_top += top_row_end_incr;
pu1_tmp_bot += bot_row_end_incr;
/*************************************************************************/
/* Alt diff : Row based */
/*************************************************************************/
alt += ABS_DIF(sum_1, sum_3);
alt += ABS_DIF(sum_2, sum_4);
}
/*************************************************************************/
/* In the adjacent sad calculation by column-method, the rows of both */
/* the fields are averaged separately and then summed across the column. */
/* The difference of the two values, thus obtained, is added to the */
/* adjacent sad value, if it is beyond the threshold. */
/*************************************************************************/
pu1_top_0 = pu1_top;
pu1_top_1 = pu1_top_0 + top_strd;
pu1_top_2 = pu1_top_1 + top_strd;
pu1_top_3 = pu1_top_2 + top_strd;
pu1_bot_0 = pu1_bot;
pu1_bot_1 = pu1_bot_0 + bot_strd;
pu1_bot_2 = pu1_bot_1 + bot_strd;
pu1_bot_3 = pu1_bot_2 + bot_strd;
/*************************************************************************/
/* Adj dif: Col based */
/*************************************************************************/
diff_sum = 0;
/*************************************************************************/
/* As the DSP implementation of this modules is anyway going to assume */
/* the size of the block to the fixed (8x4 or two 4x4's), the height of */
/* block is also kept to be 8, to have a clean implementation. */
/*************************************************************************/
for(i = 0; i < SUB_BLK_WD; i ++)
{
WORD32 val_1;
WORD32 val_2;
WORD32 tmp_1, tmp_2;
WORD32 tmp_diff;
tmp_1 = AVG(pu1_top_0[i], pu1_top_1[i]);
tmp_2 = AVG(pu1_top_2[i], pu1_top_3[i]);
val_1 = AVG(tmp_1, tmp_2);
tmp_1 = AVG(pu1_bot_0[i], pu1_bot_1[i]);
tmp_2 = AVG(pu1_bot_2[i], pu1_bot_3[i]);
val_2 = AVG(tmp_1, tmp_2);
tmp_diff = ABS_DIF(val_1, val_2);
if(tmp_diff >= (rsum_csum_thresh >> 2))
diff_sum += tmp_diff;
}
adj += diff_sum << 2;
/*************************************************************************/
/* Alt diff : Col based */
/*************************************************************************/
diff_sum = 0;
for(i = 0; i < SUB_BLK_WD; i ++)
{
WORD32 val_1;
WORD32 val_2;
WORD32 tmp_1, tmp_2;
WORD32 tmp_diff;
tmp_1 = AVG(pu1_top_0[i], pu1_bot_0[i]);
tmp_2 = AVG(pu1_top_2[i], pu1_bot_2[i]);
val_1 = AVG(tmp_1, tmp_2);
tmp_1 = AVG(pu1_top_1[i], pu1_bot_1[i]);
tmp_2 = AVG(pu1_top_3[i], pu1_bot_3[i]);
val_2 = AVG(tmp_1, tmp_2);
tmp_diff = ABS_DIF(val_1, val_2);
diff_sum += tmp_diff;
}
/*************************************************************************/
/* because of the averaging used in place of summation, a factor of 4 is */
/* needed while adding the the diff_sum to the sad. */
/*************************************************************************/
alt += diff_sum << 2;
pu1_top += SUB_BLK_WD;
pu1_bot += SUB_BLK_WD;
alt += (alt >> sad_bias_mult_shift) + (sad_bias_additive >> 1);
ca = (alt < adj);
return ca;
}
/**
*******************************************************************************
*
* @brief
* Combing artifact check function for 8x8 block
*
* @par Description
* Determines CAC for 8x8 block by calling 8x4 CAC function
*
* @param[in] pu1_top
* Top field
*
* @param[in] pu1_bot
* Bottom field
*
* @param[in] top_strd
* Top field Stride
*
* @param[in] bot_strd
* Bottom field stride
*
* @returns
* combing artifact flag (1 = detected, 0 = not detected)
*
* @remarks
*
*******************************************************************************
*/
WORD32 ideint_cac_8x8(UWORD8 *pu1_top,
UWORD8 *pu1_bot,
WORD32 top_strd,
WORD32 bot_strd)
{
WORD32 ca; /* combing artifact result */
WORD32 k;
ca = 0;
/*************************************************************************/
/* This loop runs for the two halves of the 4x8 block. */
/*************************************************************************/
for(k = 0; k < 2; k ++)
{
ca |= cac_4x8(pu1_top, pu1_bot, top_strd, bot_strd);
pu1_top += SUB_BLK_WD;
pu1_bot += SUB_BLK_WD;
/* If Combing Artifact is detected, then return. Else continue to
* check the next half
*/
if(ca)
return ca;
}
return ca;
}