| /****************************************************************************** |
| * |
| * 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; |
| } |
| } |
| |
