/******************************************************************************
|
*
|
* 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_api.c
|
*
|
* @brief
|
* This file contains the definitions of the core processing of the de-
|
* interlacer.
|
*
|
* @author
|
* Ittiam
|
*
|
* @par List of Functions:
|
*
|
* @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"
|
#include "ideint_debug.h"
|
#include "ideint_function_selector.h"
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Return deinterlacer context size
|
*
|
* @par Description
|
* Return deinterlacer context size, application will allocate this memory
|
* and send it as context to process call
|
*
|
* @param[in] None
|
*
|
* @returns
|
* Size of deinterlacer context
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
WORD32 ideint_ctxt_size(void)
|
{
|
return sizeof(ctxt_t);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Deinterlace given fields and produce a frame
|
*
|
* @par Description
|
* Deinterlacer function that deinterlaces given fields and produces a frame
|
*
|
* @param[in] pv_ctxt
|
* Deinterlacer context returned by ideint_create()
|
*
|
* @param[in] ps_prv_fld
|
* Previous field (can be null, in which case spatial filtering is done
|
* unconditionally)
|
*
|
* @param[in] ps_cur_fld
|
* Current field
|
*
|
* @param[in] ps_nxt_fld
|
* Next field
|
*
|
* @param[in] ps_out_frm
|
* Output frame
|
*
|
* @param[in] ps_params
|
* Parameters
|
*
|
* @param[in] start_row
|
* Start row
|
*
|
* @param[in] num_rows
|
* Number of rows to be processed
|
*
|
* @returns
|
* IDEINT_ERROR_T
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
IDEINT_ERROR_T ideint_process(void *pv_ctxt,
|
icv_pic_t *ps_prv_fld,
|
icv_pic_t *ps_cur_fld,
|
icv_pic_t *ps_nxt_fld,
|
icv_pic_t *ps_out_frm,
|
ideint_params_t *ps_params,
|
WORD32 start_row,
|
WORD32 num_rows)
|
{
|
ctxt_t *ps_ctxt;
|
WORD32 num_blks_x, num_blks_y;
|
WORD32 num_comp;
|
WORD32 i, row, col;
|
WORD32 rows_remaining;
|
|
if(NULL == pv_ctxt)
|
return IDEINT_INVALID_CTXT;
|
|
ps_ctxt = (ctxt_t *)pv_ctxt;
|
|
/* Copy the parameters */
|
if(ps_params)
|
{
|
ps_ctxt->s_params = *ps_params;
|
}
|
else
|
{
|
/* Use default params if ps_params is NULL */
|
ps_ctxt->s_params.i4_cur_fld_top = 1;
|
ps_ctxt->s_params.e_mode = IDEINT_MODE_SPATIAL;
|
ps_ctxt->s_params.e_arch = ideint_default_arch();
|
ps_ctxt->s_params.e_soc = ICV_SOC_GENERIC;
|
ps_ctxt->s_params.i4_disable_weave = 0;
|
ps_ctxt->s_params.pf_aligned_alloc = NULL;
|
ps_ctxt->s_params.pf_aligned_free = NULL;
|
}
|
|
/* Start row has to be multiple of 8 */
|
if(start_row & 0x7)
|
{
|
return IDEINT_START_ROW_UNALIGNED;
|
}
|
|
/* Initialize variances */
|
ps_ctxt->ai4_vrnc_avg_fb[0] = VAR_AVG_LUMA;
|
ps_ctxt->ai4_vrnc_avg_fb[1] = VAR_AVG_CHROMA;
|
ps_ctxt->ai4_vrnc_avg_fb[2] = VAR_AVG_CHROMA;
|
|
ideint_init_function_ptr(ps_ctxt);
|
|
rows_remaining = ps_out_frm->ai4_ht[0] - start_row;
|
num_rows = MIN(num_rows,
|
rows_remaining);
|
|
IDEINT_CORRUPT_PIC(ps_out_frm, 0xCD);
|
|
//Weave two fields to get a frame
|
if(IDEINT_MODE_WEAVE == ps_ctxt->s_params.e_mode)
|
{
|
if(0 == ps_ctxt->s_params.i4_disable_weave)
|
{
|
if(ps_ctxt->s_params.i4_cur_fld_top)
|
ideint_weave_pic(ps_cur_fld, ps_nxt_fld, ps_out_frm,
|
start_row,
|
num_rows);
|
else
|
ideint_weave_pic(ps_nxt_fld, ps_cur_fld, ps_out_frm,
|
start_row,
|
num_rows);
|
}
|
return IDEINT_ERROR_NONE;
|
}
|
|
num_comp = 3;
|
|
for(i = 0; i < num_comp; i++)
|
{
|
UWORD8 *pu1_prv = NULL, *pu1_out;
|
UWORD8 *pu1_top, *pu1_bot, *pu1_dst;
|
WORD32 cur_strd, out_strd, dst_strd;
|
|
WORD32 st_thresh;
|
WORD32 vrnc_avg_st;
|
WORD32 disable_cac_sad;
|
WORD32 comp_row_start, comp_row_end;
|
num_blks_x = ALIGN8(ps_out_frm->ai4_wd[i]) >> 3;
|
num_blks_y = ALIGN8(ps_out_frm->ai4_ht[i]) >> 3;
|
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_out_frm->ai4_ht[i]);
|
|
comp_row_start = ALIGN8(comp_row_start) >> 3;
|
comp_row_end = ALIGN8(comp_row_end) >> 3;
|
st_thresh = ST_THRESH;
|
vrnc_avg_st = VAR_AVG_LUMA;
|
|
if(i)
|
{
|
st_thresh = ST_THRESH >> 1;
|
vrnc_avg_st = VAR_AVG_CHROMA;
|
}
|
|
out_strd = ps_out_frm->ai4_strd[i];
|
if(ps_ctxt->s_params.i4_cur_fld_top)
|
{
|
cur_strd = ps_cur_fld->ai4_strd[i];
|
}
|
else
|
{
|
cur_strd = ps_nxt_fld->ai4_strd[i];
|
}
|
|
|
disable_cac_sad = 0;
|
/* If previous field is not provided, then change to SPATIAL mode */
|
if(ps_prv_fld->apu1_buf[i] == NULL)
|
{
|
disable_cac_sad = 1;
|
}
|
for(row = comp_row_start; row < comp_row_end; row++)
|
{
|
pu1_out = ps_out_frm->apu1_buf[i];
|
pu1_out += (ps_out_frm->ai4_strd[i] * row << 3);
|
|
if(0 == disable_cac_sad)
|
{
|
pu1_prv = ps_prv_fld->apu1_buf[i];
|
pu1_prv += (ps_prv_fld->ai4_strd[i] * row << 2);
|
}
|
|
if(ps_ctxt->s_params.i4_cur_fld_top)
|
{
|
pu1_top = ps_cur_fld->apu1_buf[i];
|
pu1_bot = ps_nxt_fld->apu1_buf[i];
|
}
|
else
|
{
|
pu1_top = ps_nxt_fld->apu1_buf[i];
|
pu1_bot = ps_cur_fld->apu1_buf[i];
|
}
|
pu1_top += (cur_strd * row << 2);
|
pu1_bot += (cur_strd * row << 2);
|
|
for(col = 0; col < num_blks_x; col++)
|
{
|
WORD32 cac, sad, vrnc;
|
WORD32 th_num, th_den;
|
UWORD8 au1_dst[BLK_WD * BLK_HT];
|
WORD32 blk_wd, blk_ht;
|
WORD32 input_boundary;
|
cac = 0;
|
sad = 0;
|
th_den = 0;
|
th_num = st_thresh;
|
vrnc = 0;
|
|
disable_cac_sad = 0;
|
/* If previous field is not provided, then change to SPATIAL mode */
|
if(ps_prv_fld->apu1_buf[i] == NULL)
|
{
|
disable_cac_sad = 1;
|
}
|
/* For boundary blocks when input dimensions are not multiple of 8,
|
* then change to spatial mode */
|
input_boundary = 0;
|
|
blk_wd = BLK_WD;
|
blk_ht = BLK_HT;
|
|
if((((num_blks_x - 1) == col) && (ps_out_frm->ai4_wd[i] & 0x7)) ||
|
(((num_blks_y - 1) == row) && (ps_out_frm->ai4_ht[i] & 0x7)))
|
{
|
disable_cac_sad = 1;
|
input_boundary = 1;
|
|
if(((num_blks_x - 1) == col) && (ps_out_frm->ai4_wd[i] & 0x7))
|
blk_wd = (ps_out_frm->ai4_wd[i] & 0x7);
|
|
if(((num_blks_y - 1) == row) && (ps_out_frm->ai4_ht[i] & 0x7))
|
blk_ht = (ps_out_frm->ai4_ht[i] & 0x7);
|
|
}
|
|
if(0 == disable_cac_sad)
|
{
|
/* Compute SAD */
|
PROFILE_DISABLE_SAD
|
sad = ps_ctxt->pf_sad_8x4(pu1_prv, pu1_bot, cur_strd,
|
cur_strd,
|
BLK_WD,
|
BLK_HT >> 1);
|
/* Compute Variance */
|
PROFILE_DISABLE_VARIANCE
|
vrnc = ps_ctxt->pf_variance_8x4(pu1_top, cur_strd, BLK_WD,
|
BLK_HT >> 1);
|
|
th_num = st_thresh;
|
|
th_num *= vrnc_avg_st +
|
((MOD_IDX_ST_NUM * vrnc) >> MOD_IDX_ST_SHIFT);
|
|
th_den = vrnc +
|
((MOD_IDX_ST_NUM * vrnc_avg_st) >> MOD_IDX_ST_SHIFT);
|
|
if((sad * th_den) <= th_num)
|
{
|
/* Calculate Combing Artifact if SAD test fails */
|
PROFILE_DISABLE_CAC
|
cac = ps_ctxt->pf_cac_8x8(pu1_top, pu1_bot, cur_strd, cur_strd);
|
}
|
}
|
|
pu1_dst = pu1_out;
|
dst_strd = out_strd;
|
|
/* In case boundary blocks are not complete (dimensions non-multiple of 8)
|
* Use intermediate buffer as destination and copy required pixels to output
|
* buffer later
|
*/
|
if(input_boundary)
|
{
|
pu1_dst = au1_dst;
|
dst_strd = BLK_WD;
|
ideint_weave_blk(pu1_top, pu1_bot, pu1_dst, dst_strd,
|
cur_strd, blk_wd, blk_ht);
|
}
|
|
/* Weave the two fields unconditionally */
|
if(0 == ps_ctxt->s_params.i4_disable_weave)
|
{
|
ideint_weave_blk(pu1_top, pu1_bot, pu1_dst, dst_strd,
|
cur_strd, blk_wd, blk_ht);
|
}
|
|
if(disable_cac_sad || cac || (sad * th_den > th_num))
|
{
|
/* Pad the input fields in an intermediate buffer if required */
|
if((0 == row) || (0 == col) ||
|
((num_blks_x - 1) == col) || ((num_blks_y - 1) == row))
|
{
|
UWORD8 *pu1_dst_top;
|
UWORD8 au1_pad[(BLK_HT + 4) * (BLK_WD + 4)];
|
|
ideint_pad_blk(pu1_top, pu1_bot, au1_pad, cur_strd, row,
|
col, num_blks_y, num_blks_x, blk_wd, blk_ht);
|
|
pu1_dst_top = au1_pad + 2 * (BLK_WD + 4) + 2;
|
|
PROFILE_DISABLE_SPATIAL
|
ps_ctxt->pf_spatial_filter(pu1_dst_top, pu1_dst + dst_strd,
|
(BLK_WD + 4) * 2,
|
dst_strd * 2);
|
}
|
else
|
{
|
PROFILE_DISABLE_SPATIAL
|
ps_ctxt->pf_spatial_filter(pu1_top, pu1_dst + dst_strd,
|
cur_strd, dst_strd * 2);
|
|
}
|
}
|
|
/* copy required pixels to output buffer for boundary blocks
|
* when dimensions are not multiple of 8
|
*/
|
if(input_boundary)
|
{
|
WORD32 j;
|
|
for(j = 0; j < blk_ht; j++)
|
{
|
memcpy(pu1_out + j * out_strd, au1_dst + j * BLK_WD, blk_wd);
|
}
|
}
|
if(NULL != pu1_prv)
|
{
|
pu1_prv += 8;
|
}
|
pu1_top += 8;
|
pu1_bot += 8;
|
pu1_out += 8;
|
}
|
}
|
}
|
return IDEINT_ERROR_NONE;
|
}
|
