/******************************************************************************

 *

 * 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_ssse3.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>

#include <immintrin.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 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_ssse3(UWORD8 *pu1_top,

                            UWORD8 *pu1_bot,

                            WORD32 top_strd,

                            WORD32 bot_strd)

{

    WORD32 ca;        /* combing artifact result                          */

    WORD32 i;

    WORD32 adj[2] = {0};

    WORD32 alt[2] = {0};

    WORD32 sum_1, sum_2, sum_3, sum_4;

    WORD32 sum_diff, diff_sum;

    __m128i top[4];

    __m128i bot[4];

    __m128i sum_t[4];

    __m128i sum_b[4];

    __m128i zero;

    zero = _mm_setzero_si128();

    for(i = 0; i < 4; i++)

    {

        /* Load top */

        top[i] = (__m128i)_mm_loadl_epi64((__m128i *) (pu1_top));

        pu1_top += top_strd;

        /* Load bottom */

        bot[i] = (__m128i)_mm_loadl_epi64((__m128i *) (pu1_bot));

        pu1_bot += bot_strd;

        /* Unpack */

        top[i] = _mm_unpacklo_epi8(top[i], zero);

        bot[i] = _mm_unpacklo_epi8(bot[i], zero);

        /* Compute row sums */

        sum_t[i]  = _mm_sad_epu8(top[i], zero);

        sum_b[i]  = _mm_sad_epu8(bot[i], zero);

    }

    /* Compute row based alt and adj */

    for(i = 0; i < 4; i += 2)

    {

        sum_1 = _mm_cvtsi128_si32(sum_t[i + 0]);

        sum_2 = _mm_cvtsi128_si32(sum_b[i + 0]);

        sum_diff = ABS_DIF(sum_1, sum_2);

        if(sum_diff >= RSUM_CSUM_THRESH)

            adj[0] += sum_diff;

        sum_3 = _mm_cvtsi128_si32(sum_t[i + 1]);

        sum_4 = _mm_cvtsi128_si32(sum_b[i + 1]);

        sum_diff = ABS_DIF(sum_3, sum_4);

        if(sum_diff >= RSUM_CSUM_THRESH)

            adj[0] += sum_diff;

        alt[0] += ABS_DIF(sum_1, sum_3);

        alt[0] += ABS_DIF(sum_2, sum_4);

        sum_1 = _mm_cvtsi128_si32(_mm_srli_si128(sum_t[i + 0], 8));

        sum_2 = _mm_cvtsi128_si32(_mm_srli_si128(sum_b[i + 0], 8));

        sum_diff = ABS_DIF(sum_1, sum_2);

        if(sum_diff >= RSUM_CSUM_THRESH)

            adj[1] += sum_diff;

        sum_3 = _mm_cvtsi128_si32(_mm_srli_si128(sum_t[i + 1], 8));

        sum_4 = _mm_cvtsi128_si32(_mm_srli_si128(sum_b[i + 1], 8));

        sum_diff = ABS_DIF(sum_3, sum_4);

        if(sum_diff >= RSUM_CSUM_THRESH)

            adj[1] += sum_diff;

        alt[1] += ABS_DIF(sum_1, sum_3);

        alt[1] += ABS_DIF(sum_2, sum_4);

    }

    /* Compute column based adj */

    {

        __m128i avg1, avg2;

        __m128i top_avg, bot_avg;

        __m128i min, max, diff, thresh;

        __m128i mask;

        avg1 = _mm_avg_epu8(top[0], top[1]);

        avg2 = _mm_avg_epu8(top[2], top[3]);

        top_avg = _mm_avg_epu8(avg1, avg2);

        avg1 = _mm_avg_epu8(bot[0], bot[1]);

        avg2 = _mm_avg_epu8(bot[2], bot[3]);

        bot_avg = _mm_avg_epu8(avg1, avg2);

        min = _mm_min_epu8(top_avg, bot_avg);

        max = _mm_max_epu8(top_avg, bot_avg);

        diff = _mm_sub_epi16(max, min);

        thresh = _mm_set1_epi16((RSUM_CSUM_THRESH >> 2) - 1);

        mask = _mm_cmpgt_epi16(diff, thresh);

        diff = _mm_and_si128(diff, mask);

        diff_sum = _mm_extract_epi16(diff, 0);

        diff_sum += _mm_extract_epi16(diff, 1);

        diff_sum += _mm_extract_epi16(diff, 2);

        diff_sum += _mm_extract_epi16(diff, 3);

        adj[0] += diff_sum << 2;

        diff_sum = _mm_extract_epi16(diff, 4);

        diff_sum += _mm_extract_epi16(diff, 5);

        diff_sum += _mm_extract_epi16(diff, 6);

        diff_sum += _mm_extract_epi16(diff, 7);

        adj[1] += diff_sum << 2;

    }

    /* Compute column based alt */

    {

        __m128i avg1, avg2;

        __m128i even_avg, odd_avg, diff;

        avg1 = _mm_avg_epu8(top[0], bot[0]);

        avg2 = _mm_avg_epu8(top[2], bot[2]);

        even_avg = _mm_avg_epu8(avg1, avg2);

        avg1 = _mm_avg_epu8(top[1], bot[1]);

        avg2 = _mm_avg_epu8(top[3], bot[3]);

        odd_avg = _mm_avg_epu8(avg1, avg2);

        diff = _mm_sad_epu8(even_avg, odd_avg);

        diff_sum = _mm_cvtsi128_si32(diff);

        alt[0] += diff_sum << 2;

        diff_sum = _mm_cvtsi128_si32(_mm_srli_si128(diff, 8));

        alt[1] += diff_sum << 2;

    }

    alt[0] += (alt[0] >> SAD_BIAS_MULT_SHIFT) + (SAD_BIAS_ADDITIVE >> 1);

    alt[1] += (alt[1] >> SAD_BIAS_MULT_SHIFT) + (SAD_BIAS_ADDITIVE >> 1);

    ca    = (alt[0] < adj[0]);

    ca   |= (alt[1] < adj[1]);

    return ca;

}