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

 *

 * Copyright (C) 2022 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

*  isvce_downscaler.c

*

* @brief

*  Contains downscaler functions required by the SVC encoder

*

* @author

*  ittiam

*

* @par List of Functions:

*  - isvce_get_downscaler_data_size()

*  - isvce_get_downscaler_padding_dims()

*  - isvce_get_downscaler_normalized_filtered_pixel()

*  - isvce_horizontal_downscale_and_transpose()

*  - isvce_process_downscaler()

*  - isvce_initialize_downscaler()

*

* @remarks

*  None

*

*******************************************************************************

*/

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

/* File Includes                                                             */

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

/* system include files */

#include <stdio.h>

#include <stdlib.h>

#include "ih264_typedefs.h"

#include "ih264_macros.h"

#include "isvc_macros.h"

#include "ih264_platform_macros.h"

#include "iv2.h"

#include "isvc_defs.h"

#include "isvce_defs.h"

#include "isvc_structs.h"

#include "isvc_structs.h"

#include "isvce_downscaler.h"

#include "isvce_downscaler_private_defs.h"

/**

******************************************************************************

* @brief  lanczos filter coefficients for 2x downscaling

* @remarks Though the length of the filter is 8, the

* same coefficients

* are replicated so that 2 rows can be processed at one

* go in SIMD

******************************************************************************

*/

static WORD8 gai1_lanczos_coefficients_2x[NUM_SCALER_FILTER_PHASES][NUM_SCALER_FILTER_TAPS * 2] = {

    {-7, 0, 39, 64, 39, 0, -7, 0, -7, 0, 39, 64, 39, 0, -7, 0},

    {-6, 0, 33, 62, 41, 4, -6, 0, -6, 0, 33, 62, 41, 4, -6, 0},

    {-5, -1, 29, 57, 45, 9, -5, -1, -5, -1, 29, 57, 45, 9, -5, -1},

    {-4, -2, 23, 55, 48, 14, -4, -2, -4, -2, 23, 55, 48, 14, -4, -2},

    {-3, -3, 18, 52, 52, 18, -3, -3, -3, -3, 18, 52, 52, 18, -3, -3},

    {-2, -4, 13, 49, 54, 24, -2, -4, -2, -4, 13, 49, 54, 24, -2, -4},

    {-1, -5, 9, 44, 58, 29, -1, -5, -1, -5, 9, 44, 58, 29, -1, -5},

    {0, -6, 3, 42, 61, 34, 0, -6, 0, -6, 3, 42, 61, 34, 0, -6}};

/**

******************************************************************************

* @brief  lanczos filter coefficients for 1.5x downscaling

* @remarks Though the length of the filter is 8, the same coefficients

* are replicated so that 2 rows can be processed at one go in SIMD.

******************************************************************************

*/

static WORD8 gai1_lanczos_coefficients_3by2x[NUM_SCALER_FILTER_PHASES][NUM_SCALER_FILTER_TAPS * 2] =

    {{0, -11, 32, 86, 32, -11, 0, 0, 0, -11, 32, 86, 32, -11, 0, 0},

     {0, -10, 26, 79, 39, -5, 0, 0, 0, -10, 26, 79, 39, -5, 0, 0},

     {0, -8, 21, 72, 46, 0, -2, 0, 0, -8, 21, 72, 46, 0, -2, 0},

     {0, -6, 15, 66, 52, 3, -3, 0, 0, -6, 15, 66, 52, 3, -3, 0},

     {0, -6, 10, 60, 60, 10, -6, 0, 0, -6, 10, 60, 60, 10, -6, 0},

     {0, -3, 3, 52, 66, 15, -6, 0, 0, -3, 3, 52, 66, 15, -6, 0},

     {0, -2, 0, 46, 72, 21, -8, 0, 0, -2, 0, 46, 72, 21, -8, 0},

     {0, 0, -5, 39, 79, 26, -10, 0, 0, 0, -5, 39, 79, 26, -10, 0}};

/**

*******************************************************************************

*

* @brief

*   gets the memory size required for downscaler

*

* @par Description:

*   returns the memory required by the downscaler context and state structs

*   for allocation.

*

* @returns

*

* @remarks

*

*

*******************************************************************************

*/

UWORD32 isvce_get_downscaler_data_size(UWORD8 u1_num_spatial_layers, DOUBLE d_scaling_factor,

                                       UWORD32 u4_width, UWORD32 u4_height)

{

    UWORD32 u4_size = 0;

    if(u1_num_spatial_layers > 1)

    {

        u4_size += sizeof(downscaler_state_t);

        u4_size +=

            (u4_height + NUM_SCALER_FILTER_TAPS * 2) * ((UWORD32) (u4_width / d_scaling_factor));

    }

    return u4_size;

}

/**

*******************************************************************************

*

* @brief

*   gets the padding size required for filtering

*

* @par Description:

*   gets the padding size required for filtering

*

* @returns

*

* @remarks

*

*

*******************************************************************************

*/

void isvce_get_downscaler_padding_dims(padding_dims_t *ps_pad_dims)

{

    ps_pad_dims->u1_left_pad_size = ALIGN8(NUM_SCALER_FILTER_TAPS / 2);

    ps_pad_dims->u1_right_pad_size = ALIGN8(NUM_SCALER_FILTER_TAPS / 2);

    ps_pad_dims->u1_top_pad_size = NUM_SCALER_FILTER_TAPS / 2;

    ps_pad_dims->u1_bottom_pad_size = NUM_SCALER_FILTER_TAPS / 2;

}

/**

*******************************************************************************

*

* @brief

*   processes downscaler

*

* @par Description:

*   calls the function for padding and scaling

*

* @param[in] ps_scaler

*  pointer to downdownscaler context

*

* @param[in] ps_src_buf_props

*  pointer to source buffer props struct

*

* @param[in] u4_blk_wd

*  width of the block to be processed

*

* @param[in] u4_blk_ht

*  height of the block to be processed

*

* @returns

*

* @remarks

*

*

*******************************************************************************

*/

void isvce_process_downscaler(downscaler_ctxt_t *ps_scaler, yuv_buf_props_t *ps_src_buf_props,

                              yuv_buf_props_t *ps_dst_buf_props, UWORD32 u4_blk_wd,

                              UWORD32 u4_blk_ht)

{

    buffer_container_t s_src_buf;

    buffer_container_t s_dst_buf;

    UWORD32 u4_scaled_block_size_x, u4_scaled_block_size_y;

    downscaler_state_t *ps_scaler_state = (downscaler_state_t *) ps_scaler->pv_scaler_state;

    ASSERT(ps_src_buf_props->e_color_format == IV_YUV_420SP_UV);

    u4_scaled_block_size_x = (UWORD32) (u4_blk_wd / ps_scaler->d_scaling_factor);

    u4_scaled_block_size_y = (UWORD32) (u4_blk_ht / ps_scaler->d_scaling_factor);

    /* luma */

    s_src_buf = ps_src_buf_props->as_component_bufs[Y];

    s_src_buf.pv_data = ((UWORD8 *) s_src_buf.pv_data) - (NUM_SCALER_FILTER_TAPS / 2) -

                        (NUM_SCALER_FILTER_TAPS / 2) * s_src_buf.i4_data_stride;

    s_dst_buf.pv_data = ps_scaler_state->pv_scratch_buf;

    s_dst_buf.i4_data_stride = u4_blk_ht + NUM_SCALER_FILTER_TAPS;

    ps_scaler_state->pf_downscaler(ps_scaler, &s_src_buf, &s_dst_buf, ps_scaler_state->pai1_filters,

                                   u4_scaled_block_size_x, u4_blk_ht + NUM_SCALER_FILTER_TAPS, 0);

    s_src_buf = s_dst_buf;

    s_dst_buf = ps_dst_buf_props->as_component_bufs[Y];

    ps_scaler_state->pf_downscaler(ps_scaler, &s_src_buf, &s_dst_buf, ps_scaler_state->pai1_filters,

                                   u4_scaled_block_size_y, u4_scaled_block_size_x, 0);

    /* chroma */

    u4_blk_ht /= 2;

    u4_scaled_block_size_y /= 2;

    s_src_buf = ps_src_buf_props->as_component_bufs[U];

    s_src_buf.pv_data = ((UWORD8 *) s_src_buf.pv_data) - NUM_SCALER_FILTER_TAPS -

                        (NUM_SCALER_FILTER_TAPS / 2) * s_src_buf.i4_data_stride;

    s_dst_buf.pv_data = ps_scaler_state->pv_scratch_buf;

    s_dst_buf.i4_data_stride = u4_blk_ht + NUM_SCALER_FILTER_TAPS;

    ps_scaler_state->pf_downscaler(ps_scaler, &s_src_buf, &s_dst_buf, ps_scaler_state->pai1_filters,

                                   u4_scaled_block_size_x, u4_blk_ht + NUM_SCALER_FILTER_TAPS, 1);

    s_src_buf = s_dst_buf;

    s_dst_buf = ps_dst_buf_props->as_component_bufs[U];

    ps_scaler_state->pf_downscaler(ps_scaler, &s_src_buf, &s_dst_buf, ps_scaler_state->pai1_filters,

                                   u4_scaled_block_size_y, u4_scaled_block_size_x, 0);

}

/**

*******************************************************************************

*

* @brief

*   normalized dot product computer for downscaler

*

* @par Description:

*   Given the downscaler filter coefficients, source buffer, the function

*   calculates the dot product between them, adds an offset and normalizes it

*

* @param[in] ps_scaler

*  pointer to src buf

*

* @param[in] pi1_filter

*  pointer to filter coefficients

*

* @returns

*

* @remarks

*

*******************************************************************************

*/

static UWORD8 isvce_get_downscaler_normalized_filtered_pixel(UWORD8 *pu1_src, WORD8 *pi1_filter)

{

    WORD32 i;

    WORD32 i4_norm_dot_product;

    UWORD8 u1_out_pixel;

    WORD32 i4_dot_product_sum = 0;

    WORD32 i4_rounding_offset = 1 << (FILTER_COEFF_Q - 1);

    WORD32 i4_normalizing_factor = 1 << FILTER_COEFF_Q;

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

    {

        i4_dot_product_sum += (pu1_src[i] * pi1_filter[i]);

    }

    i4_norm_dot_product = ((i4_dot_product_sum + i4_rounding_offset) / i4_normalizing_factor);

    u1_out_pixel = (UWORD8) CLIP_U8(i4_norm_dot_product);

    return u1_out_pixel;

}

/**

*******************************************************************************

*

* @brief

*   horizontal scaler function

*

* @par Description:

*   Does horizontal scaling for the given block

*

* @param[in] ps_scaler

*  pointer to downscaler context

*

* @param[in] ps_src

*  pointer to source buffer container

*

* @param[in] ps_dst

*  pointer to destination buffer container

*

* @param[in] pai1_filters

*  pointer to array of downscaler filters

*

* @param[in] u4_blk_wd

*  width of the block after horizontal scaling (output block width)

*

* @param[in] u4_blk_ht

*  height of the current block (input block height)

*

* @param[in] u1_is_chroma

*  flag suggesting whether the buffer is luma or chroma

*

*

* @returns

*

* @remarks

*  The same function is used for vertical scaling too as

*  the horizontally scaled input in stored in transpose fashion.

*

*******************************************************************************

*/

static void isvce_horizontal_downscale_and_transpose(

    downscaler_ctxt_t *ps_scaler, buffer_container_t *ps_src, buffer_container_t *ps_dst,

    FILTER_COEFF_ARRAY pai1_filters, UWORD32 u4_blk_wd, UWORD32 u4_blk_ht, UWORD8 u1_is_chroma)

{

    WORD32 i, j, k;

    UWORD8 u1_phase;

    UWORD8 u1_filtered_out_pixel;

    UWORD8 *pu1_src_j, *pu1_dst_j;

    UWORD8 u1_filtered_out_u_pixel, u1_filtered_out_v_pixel;

    UWORD8 *pu1_in_pixel;

    UWORD8 *pu1_out_pixel;

    WORD8 *pi1_filter_grid;

    UWORD16 u2_full_pixel_inc;

    UWORD8 au1_temp_u_buff[NUM_SCALER_FILTER_TAPS];

    UWORD8 au1_temp_v_buff[NUM_SCALER_FILTER_TAPS];

    downscaler_state_t *ps_scaler_state = (downscaler_state_t *) ps_scaler->pv_scaler_state;

    UWORD32 u4_center_pixel_pos = ps_scaler_state->i4_init_offset;

    UWORD32 u4_src_horz_increments = ps_scaler_state->u4_horz_increment;

    UWORD8 *pu1_src = ps_src->pv_data;

    UWORD32 u4_in_stride = ps_src->i4_data_stride;

    UWORD8 *pu1_dst = ps_dst->pv_data;

    UWORD32 u4_out_stride = ps_dst->i4_data_stride;

    UWORD32 u4_center_pixel_pos_src = u4_center_pixel_pos;

    /* Offset the input so that the input pixel to be processed

    co-incides with the centre of filter (4th coefficient)*/

    pu1_src += (1 + u1_is_chroma);

    ASSERT((1 << DOWNSCALER_Q) == ps_scaler_state->u4_vert_increment);

    if(!u1_is_chroma)

    {

        for(j = 0; j < (WORD32) u4_blk_ht; j++)

        {

            pu1_src_j = pu1_src + (j * u4_in_stride);

            pu1_dst_j = pu1_dst + j;

            u4_center_pixel_pos = u4_center_pixel_pos_src;

            for(i = 0; i < (WORD32) u4_blk_wd; i++)

            {

                u1_phase = get_filter_phase(u4_center_pixel_pos);

                pi1_filter_grid = pai1_filters[u1_phase];

                /* Doing the Calculation for current Loop Count  */

                u2_full_pixel_inc = u4_center_pixel_pos >> DOWNSCALER_Q;

                pu1_in_pixel = pu1_src_j + (u2_full_pixel_inc << u1_is_chroma);

                pu1_out_pixel = pu1_dst_j + ((i << u1_is_chroma) * u4_out_stride);

                u1_filtered_out_pixel =

                    isvce_get_downscaler_normalized_filtered_pixel(pu1_in_pixel, pi1_filter_grid);

                *pu1_out_pixel = u1_filtered_out_pixel;

                /* Update the context for next Loop Count */

                u4_center_pixel_pos += u4_src_horz_increments;

            }

        }

    }

    else

    {

        for(j = 0; j < (WORD32) u4_blk_ht; j++)

        {

            pu1_src_j = pu1_src + (j * u4_in_stride);

            pu1_dst_j = pu1_dst + j;

            u4_center_pixel_pos = u4_center_pixel_pos_src;

            for(i = 0; i < (WORD32) u4_blk_wd; i++)

            {

                u1_phase = get_filter_phase(u4_center_pixel_pos);

                pi1_filter_grid = pai1_filters[u1_phase];

                /*Doing the Calculation for current Loop Count  */

                u2_full_pixel_inc = u4_center_pixel_pos >> DOWNSCALER_Q;

                pu1_in_pixel = pu1_src_j + (u2_full_pixel_inc << u1_is_chroma);

                pu1_out_pixel = pu1_dst_j + ((i << u1_is_chroma) * u4_out_stride);

                for(k = 0; k < NUM_SCALER_FILTER_TAPS; k++)

                {

                    au1_temp_u_buff[k] = *(pu1_in_pixel + (2 * k));

                    au1_temp_v_buff[k] = *(pu1_in_pixel + ((2 * k) + 1));

                }

                u1_filtered_out_u_pixel = isvce_get_downscaler_normalized_filtered_pixel(

                    au1_temp_u_buff, pi1_filter_grid);

                u1_filtered_out_v_pixel = isvce_get_downscaler_normalized_filtered_pixel(

                    au1_temp_v_buff, pi1_filter_grid);

                *pu1_out_pixel = u1_filtered_out_u_pixel;

                *(pu1_out_pixel + u4_out_stride) = u1_filtered_out_v_pixel;

                /* Update the context for next Loop Count */

                u4_center_pixel_pos += u4_src_horz_increments;

            }

        }

    }

}

void isvce_downscaler_function_selector(downscaler_state_t *ps_scaler_state, IV_ARCH_T e_arch)

{

    switch(e_arch)

    {

#if defined(X86)

        case ARCH_X86_SSE42:

        {

            ps_scaler_state->pf_downscaler = isvce_horizontal_downscale_and_transpose_sse42;

            break;

        }

#elif defined(ARMV8)

        case ARCH_ARM_A53:

        case ARCH_ARM_A57:

        case ARCH_ARM_V8_NEON:

        {

            ps_scaler_state->pf_downscaler = isvce_horizontal_downscale_and_transpose_neon;

            break;

        }

#elif defined(ARM) && !defined(DISABLE_NEON)

        case ARCH_ARM_A9Q:

        case ARCH_ARM_A9A:

        case ARCH_ARM_A9:

        case ARCH_ARM_A7:

        case ARCH_ARM_A5:

        case ARCH_ARM_A15:

        {

            ps_scaler_state->pf_downscaler = isvce_horizontal_downscale_and_transpose_neon;

            break;

        }

#endif

        default:

        {

            ps_scaler_state->pf_downscaler = isvce_horizontal_downscale_and_transpose;

            break;

        }

    }

}

/**

*******************************************************************************

*

* @brief

*   initializes the downscaler context

*

* @par Description:

*   initializes the downscaler context for the given scaling factor

*   with padding size, filter size, etc.

*

* @param[in] ps_scaler

*   pointer downscaler context

*

* @param[in] ps_mem_rec

*   pointer to memory allocated to downscaler process

*

* @param[in] d_scaling_factor

*   scaling reatio of width/ height between two consecutive SVC layers

*

* @param[in] u1_num_spatial_layers

*   scaling reatio of width/ height between two consecutive SVC layers

*

* @param[in] u4_wd

*   width of the input

*

* @param[in] u4_ht

*   height of the input

*

* @param[in] e_arch

*   architecure type

*

* @returns

*

* @remarks

*  when ARM intrinsics are added, update should be done here

*

*******************************************************************************

*/

void isvce_initialize_downscaler(downscaler_ctxt_t *ps_scaler, iv_mem_rec_t *ps_mem_rec,

                                 DOUBLE d_scaling_factor, UWORD8 u1_num_spatial_layers,

                                 UWORD32 u4_in_width, UWORD32 u4_in_height, IV_ARCH_T e_arch)

{

    if(u1_num_spatial_layers > 1)

    {

        downscaler_state_t *ps_scaler_state;

        UWORD8 *pu1_buf = (UWORD8 *) ps_mem_rec->pv_base;

        ps_scaler_state = (downscaler_state_t *) pu1_buf;

        pu1_buf += sizeof(ps_scaler_state[0]);

        ps_scaler_state->pv_scratch_buf = pu1_buf;

        ps_scaler_state->u4_in_wd = u4_in_width;

        ps_scaler_state->u4_in_ht = u4_in_height;

        ps_scaler->pv_scaler_state = ps_scaler_state;

        ps_scaler->d_scaling_factor = d_scaling_factor;

        ps_scaler->u1_num_spatial_layers = u1_num_spatial_layers;

        isvce_downscaler_function_selector(ps_scaler_state, e_arch);

        ps_scaler_state->u4_horz_increment = (UWORD32) (d_scaling_factor * (1 << DOWNSCALER_Q));

        ps_scaler_state->u4_vert_increment = (1 << DOWNSCALER_Q);

        ps_scaler_state->i4_init_offset = 0;

        ps_scaler_state->pai1_filters = (d_scaling_factor == 2.0) ? gai1_lanczos_coefficients_2x

                                                                  : gai1_lanczos_coefficients_3by2x;

    }

}