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