/******************************************************************************
|
*
|
* 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_utils.c
|
*
|
* @brief
|
* This file contains the definitions of the core processing of the de
|
* interlacer.
|
*
|
* @author
|
* Ittiam
|
*
|
* @par List of Functions:
|
* ideint_weave_pic()
|
* init_bob_indices()
|
* ideint_weave_blk()
|
* ideint_spatial_filter()
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
/*****************************************************************************/
|
/* File Includes */
|
/*****************************************************************************/
|
/* System include files */
|
#include <stdio.h>
|
#include <stdint.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <assert.h>
|
|
|
/* User include files */
|
#include "icv_datatypes.h"
|
#include "icv_macros.h"
|
#include "icv_platform_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_utils.h"
|
#include "ideint_cac.h"
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Weaves two fields to produce a frame
|
*
|
* @par Description
|
* Weaves two fields to produce a frame
|
*
|
* @param[in] ps_src_top
|
* Top field source
|
*
|
* @param[in] ps_src_bot
|
* Bottom field source
|
*
|
* @param[in] ps_dst_frm
|
* Destination frame
|
*
|
* @returns
|
* 0 on Success
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
WORD32 ideint_weave_pic(icv_pic_t *ps_src_top,
|
icv_pic_t *ps_src_bot,
|
icv_pic_t *ps_dst_frm,
|
WORD32 start_row,
|
WORD32 num_rows)
|
{
|
UWORD8 *pu1_src, *pu1_dst;
|
WORD32 i, j, num_comp;
|
icv_pic_t *ps_src_fld;
|
WORD32 fld;
|
icv_pic_t *ps_src_flds[2];
|
|
num_comp = 3;
|
ps_src_flds[0] = ps_src_top;
|
ps_src_flds[1] = ps_src_bot;
|
|
for(fld = 0; fld < 2; fld++)
|
{
|
ps_src_fld = ps_src_flds[fld];
|
for(i = 0; i < num_comp; i++)
|
{
|
WORD32 src_strd;
|
WORD32 dst_strd;
|
WORD32 comp_row_start, comp_row_end;
|
comp_row_start = start_row;
|
comp_row_end = comp_row_start + num_rows;
|
if(i)
|
{
|
comp_row_start >>= 1;
|
comp_row_end >>= 1;
|
}
|
|
comp_row_end = MIN(comp_row_end, ps_dst_frm->ai4_ht[i]);
|
|
pu1_src = ps_src_fld->apu1_buf[i];
|
pu1_dst = ps_dst_frm->apu1_buf[i];
|
|
src_strd = ps_src_fld->ai4_strd[i];
|
dst_strd = ps_dst_frm->ai4_strd[i];
|
|
/* If source field is bottom, increment destination */
|
pu1_dst += fld * dst_strd;
|
|
/* In case input and output are pointing to same buffer, then no need to copy */
|
if((pu1_src != pu1_dst) || ((2 * dst_strd) != src_strd))
|
{
|
pu1_dst += ps_dst_frm->ai4_strd[i] * comp_row_start;
|
pu1_src += ps_src_fld->ai4_strd[i] * comp_row_start / 2;
|
|
for(j = comp_row_start; j < comp_row_end; j += 2)
|
{
|
memcpy(pu1_dst, pu1_src, ps_dst_frm->ai4_wd[i]);
|
pu1_dst += ps_dst_frm->ai4_strd[i] * 2;
|
pu1_src += ps_src_fld->ai4_strd[i];
|
}
|
}
|
}
|
}
|
return 0;
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Weaves a 8x8 block
|
*
|
* @par Description
|
* Weaves a 8x8 block from two fields
|
*
|
* @param[in] pu1_top
|
* Top field source
|
*
|
* @param[in] pu1_bot
|
* Bottom field source
|
*
|
* @param[in] pu1_dst
|
* Destination
|
*
|
* @param[in] dst_strd
|
* Destination stride
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @returns
|
* 0 on success
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
WORD32 ideint_weave_blk(UWORD8 *pu1_top,
|
UWORD8 *pu1_bot,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 src_strd,
|
WORD32 wd,
|
WORD32 ht)
|
{
|
WORD32 j;
|
|
for(j = 0; j < ht; j += 2)
|
{
|
memcpy(pu1_dst, pu1_top, wd);
|
pu1_dst += dst_strd;
|
pu1_top += src_strd;
|
|
memcpy(pu1_dst, pu1_bot, wd);
|
pu1_dst += dst_strd;
|
pu1_bot += src_strd;
|
}
|
return 0;
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Copy a boundary block and pad
|
*
|
* @par Description
|
* Copies a block on one of the boundaries and pads
|
*
|
* @param[in] pu1_top
|
* Top field source
|
*
|
* @param[in] pu1_bot
|
* Bottom field source
|
*
|
* @param[in] pu1_pad
|
* Padded destination
|
*
|
* @param[in] cur_strd
|
* Stride for pu1_top and pu1_bot
|
*
|
* @param[in] row
|
* Current block's row
|
*
|
* @param[in] col
|
* Current block's column
|
*
|
* @param[in] num_blks_y
|
* Number of blocks in Y direction
|
*
|
* @param[in] num_blks_x
|
* Number of blocks in X direction
|
|
* @returns
|
* None
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
void ideint_pad_blk(UWORD8 *pu1_top,
|
UWORD8 *pu1_bot,
|
UWORD8 *pu1_pad,
|
WORD32 cur_strd,
|
WORD32 row,
|
WORD32 col,
|
WORD32 num_blks_y,
|
WORD32 num_blks_x,
|
WORD32 blk_wd,
|
WORD32 blk_ht)
|
{
|
WORD32 i;
|
WORD32 num_cols, num_rows;
|
UWORD8 *pu1_dst;
|
UWORD8 *pu1_src_top;
|
UWORD8 *pu1_src_bot;
|
|
num_rows = blk_ht + 4;
|
num_cols = blk_wd + 4;
|
|
pu1_src_top = pu1_top - cur_strd - 2;
|
pu1_src_bot = pu1_bot - cur_strd - 2;
|
pu1_dst = pu1_pad;
|
|
if(0 == col)
|
{
|
num_cols -= 2;
|
pu1_dst += 2;
|
pu1_src_top += 2;
|
pu1_src_bot += 2;
|
}
|
|
if(0 == row)
|
{
|
num_rows -= 2;
|
pu1_dst += 2 * (BLK_WD + 4);
|
pu1_src_top += cur_strd;
|
pu1_src_bot += cur_strd;
|
}
|
|
if((num_blks_x - 1) == col)
|
num_cols -= 2;
|
|
if((num_blks_y - 1) == row)
|
num_rows -= 2;
|
|
for(i = 0; i < num_rows; i += 2)
|
{
|
memcpy(pu1_dst, pu1_src_top, num_cols);
|
pu1_dst += (BLK_WD + 4);
|
|
memcpy(pu1_dst, pu1_src_bot, num_cols);
|
pu1_dst += (BLK_WD + 4);
|
|
pu1_src_top += cur_strd;
|
pu1_src_bot += cur_strd;
|
}
|
|
|
/* Pad Left */
|
if(0 == col)
|
{
|
for(i = 0; i < (BLK_HT + 4); i++)
|
{
|
WORD32 ofst = i * (BLK_WD + 4) + 2;
|
pu1_pad[ofst - 1] = pu1_pad[ofst];
|
pu1_pad[ofst - 2] = pu1_pad[ofst];
|
}
|
}
|
|
/* Pad right */
|
if((num_blks_x - 1) == col)
|
{
|
for(i = 0; i < (BLK_HT + 4); i++)
|
{
|
WORD32 ofst = i * (BLK_WD + 4) + 2 + blk_wd - 1;
|
WORD32 size = (BLK_WD - blk_wd) + 2;
|
/* Padding on right should include padding for boundary
|
* blocks when width is non-multiple of 8
|
*/
|
memset(&pu1_pad[ofst + 1], pu1_pad[ofst], size);
|
}
|
}
|
|
/* Pad Top */
|
if(0 == row)
|
{
|
WORD32 src_ofst = 2 * (BLK_WD + 4);
|
WORD32 dst_ofst = 0;
|
memcpy(pu1_pad + dst_ofst, pu1_pad + src_ofst, (BLK_WD + 4));
|
src_ofst += (BLK_WD + 4);
|
dst_ofst += (BLK_WD + 4);
|
memcpy(pu1_pad + dst_ofst, pu1_pad + src_ofst, (BLK_WD + 4));
|
}
|
|
/* Pad Bottom */
|
if((num_blks_y - 1) == row)
|
{
|
WORD32 src_ofst = (0 + blk_ht) * (BLK_WD + 4);
|
WORD32 dst_ofst = (1 + blk_ht) * (BLK_WD + 4);
|
WORD32 size = (BLK_HT - blk_ht) + 2;
|
|
/* Padding on bottom should include padding for boundary
|
* blocks when height is non-multiple of 8
|
*/
|
for(i = 0; i < size; i++)
|
{
|
memcpy(pu1_pad + dst_ofst, pu1_pad + src_ofst, (BLK_WD + 4));
|
dst_ofst += (BLK_WD + 4);
|
}
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Performs spatial edge adaptive filtering
|
*
|
* @par Description
|
* Performs spatial edge adaptive filtering by detecting edge direction
|
*
|
* @param[in] pu1_src
|
* Source buffer
|
*
|
* @param[in] pu1_out
|
* Destination buffer
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] out_strd
|
* Destination stride
|
|
* @returns
|
* None
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
void ideint_spatial_filter(UWORD8 *pu1_src,
|
UWORD8 *pu1_out,
|
WORD32 src_strd,
|
WORD32 out_strd)
|
{
|
WORD32 i;
|
WORD32 j;
|
WORD32 k;
|
|
/*********************************************************************/
|
/* This loop is for the two halves inside the 8x4 block. */
|
/*********************************************************************/
|
for(k = 0; k < 2; k++)
|
{
|
WORD32 adiff[3] = {0, 0, 0};
|
WORD32 shift;
|
WORD32 dir_45_le_90, dir_45_le_135, dir_135_le_90;
|
UWORD8 *pu1_row_1, *pu1_row_2, *pu1_dst;
|
|
/*****************************************************************/
|
/* Direction detection */
|
/*****************************************************************/
|
pu1_row_1 = pu1_src;
|
pu1_row_2 = pu1_src + src_strd;
|
|
/*****************************************************************/
|
/* Calculating the difference along each of the 3 directions. */
|
/*****************************************************************/
|
for(j = 0; j < SUB_BLK_HT; j ++)
|
{
|
for(i = 0; i < SUB_BLK_WD; i++)
|
{
|
adiff[0] += ABS_DIF(pu1_row_1[i], pu1_row_2[i]); /* 90 */
|
|
adiff[1] += ABS_DIF(pu1_row_1[i - 1], pu1_row_2[i + 1]); /* 135 */
|
|
adiff[2] += ABS_DIF(pu1_row_1[i + 1], pu1_row_2[i - 1]); /* 45 */
|
}
|
pu1_row_1 += src_strd;
|
pu1_row_2 += src_strd;
|
}
|
|
/*****************************************************************/
|
/* Applying bias, to make the diff comparision more robust. */
|
/*****************************************************************/
|
adiff[0] *= EDGE_BIAS_0;
|
adiff[1] *= EDGE_BIAS_1;
|
adiff[2] *= EDGE_BIAS_1;
|
|
/*****************************************************************/
|
/* comapring the diffs */
|
/*****************************************************************/
|
dir_45_le_90 = (adiff[2] <= adiff[0]);
|
dir_45_le_135 = (adiff[2] <= adiff[1]);
|
dir_135_le_90 = (adiff[1] <= adiff[0]);
|
|
/*****************************************************************/
|
/* Direction selection. */
|
/*****************************************************************/
|
shift = 0;
|
if(1 == dir_45_le_135)
|
{
|
if(1 == dir_45_le_90)
|
shift = 1;
|
}
|
else
|
{
|
if(1 == dir_135_le_90)
|
shift = -1;
|
}
|
|
/*****************************************************************/
|
/* Directional interpolation */
|
/*****************************************************************/
|
pu1_row_1 = pu1_src + shift;
|
pu1_row_2 = pu1_src + src_strd - shift;
|
pu1_dst = pu1_out;
|
|
for(j = 0; j < SUB_BLK_HT; j++)
|
{
|
for(i = 0; i < SUB_BLK_WD; i++)
|
{
|
pu1_dst[i] = (UWORD8)AVG(pu1_row_1[i], pu1_row_2[i]);
|
}
|
pu1_row_1 += src_strd;
|
pu1_row_2 += src_strd;
|
pu1_dst += out_strd;
|
}
|
|
pu1_out += SUB_BLK_WD;
|
pu1_src += SUB_BLK_WD;
|
}
|
}
|
