xref: /frameworks/av/libvideoeditor/vss/video_filters/src/M4VIFI_ResizeRGB888toRGB888.c

/*
 * Copyright (C) 2011 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.
 */
/**
 ******************************************************************************
 * @file     M4VIFI_ResizeYUV420toYUV420.c
 * @brief    Contain video library function
 * @note     This file has a Resize filter function
 *           -# Generic resizing of YUV420 (Planar) image
 ******************************************************************************
*/

/* Prototypes of functions, and type definitions */
#include    "M4VIFI_FiltersAPI.h"
/* Macro definitions */
#include    "M4VIFI_Defines.h"
/* Clip table declaration */
#include    "M4VIFI_Clip.h"

/**
 ***********************************************************************************************
 * M4VIFI_UInt8 M4VIFI_ResizeBilinearRGB888toRGB888(void *pUserData, M4VIFI_ImagePlane *pPlaneIn,
 *                                                                  M4VIFI_ImagePlane *pPlaneOut)
 * @brief   Resizes YUV420 Planar plane.
 * @note    Basic structure of the function
 *          Loop on each row (step 2)
 *              Loop on each column (step 2)
 *                  Get four Y samples and 1 U & V sample
 *                  Resize the Y with corresponing U and V samples
 *                  Place the YUV in the ouput plane
 *              end loop column
 *          end loop row
 *          For resizing bilinear interpolation linearly interpolates along
 *          each row, and then uses that result in a linear interpolation down each column.
 *          Each estimated pixel in the output image is a weighted
 *          combination of its four neighbours. The ratio of compression
 *          or dilatation is estimated using input and output sizes.
 * @param   pUserData: (IN) User Data
 * @param   pPlaneIn: (IN) Pointer to YUV420 (Planar) plane buffer
 * @param   pPlaneOut: (OUT) Pointer to YUV420 (Planar) plane
 * @return  M4VIFI_OK: there is no error
 * @return  M4VIFI_ILLEGAL_FRAME_HEIGHT: Error in height
 * @return  M4VIFI_ILLEGAL_FRAME_WIDTH:  Error in width
 ***********************************************************************************************
*/
M4VIFI_UInt8    M4VIFI_ResizeBilinearRGB888toRGB888(void *pUserData,
                                                                M4VIFI_ImagePlane *pPlaneIn,
                                                                M4VIFI_ImagePlane *pPlaneOut)
{
    M4VIFI_UInt8    *pu8_data_in;
    M4VIFI_UInt8    *pu8_data_out;
    M4VIFI_UInt32   u32_width_in, u32_width_out, u32_height_in, u32_height_out;
    M4VIFI_UInt32   u32_stride_in, u32_stride_out;
    M4VIFI_UInt32   u32_x_inc, u32_y_inc;
    M4VIFI_UInt32   u32_x_accum, u32_y_accum, u32_x_accum_start;
    M4VIFI_UInt32   u32_width, u32_height;
    M4VIFI_UInt32   u32_y_frac;
    M4VIFI_UInt32   u32_x_frac;
    M4VIFI_UInt32   u32_Rtemp_value,u32_Gtemp_value,u32_Btemp_value;
    M4VIFI_UInt8    *pu8_src_top;
    M4VIFI_UInt8    *pu8_src_bottom;
    M4VIFI_UInt32    i32_b00, i32_g00, i32_r00;
    M4VIFI_UInt32    i32_b01, i32_g01, i32_r01;
    M4VIFI_UInt32    i32_b02, i32_g02, i32_r02;
    M4VIFI_UInt32    i32_b03, i32_g03, i32_r03;

    /* Check for the YUV width and height are even */
    if ((IS_EVEN(pPlaneIn->u_height) == FALSE)    ||
        (IS_EVEN(pPlaneOut->u_height) == FALSE))
    {
        return M4VIFI_ILLEGAL_FRAME_HEIGHT;
    }

    if ((IS_EVEN(pPlaneIn->u_width) == FALSE) ||
        (IS_EVEN(pPlaneOut->u_width) == FALSE))
    {
        return M4VIFI_ILLEGAL_FRAME_WIDTH;
    }


        /* Set the working pointers at the beginning of the input/output data field */
        pu8_data_in     = (M4VIFI_UInt8*)(pPlaneIn->pac_data + pPlaneIn->u_topleft);
        pu8_data_out    = (M4VIFI_UInt8*)(pPlaneOut->pac_data + pPlaneOut->u_topleft);

        /* Get the memory jump corresponding to a row jump */
        u32_stride_in   = pPlaneIn->u_stride;
        u32_stride_out  = pPlaneOut->u_stride;

        /* Set the bounds of the active image */
        u32_width_in    = pPlaneIn->u_width;
        u32_height_in   = pPlaneIn->u_height;

        u32_width_out   = pPlaneOut->u_width;
        u32_height_out  = pPlaneOut->u_height;

        /* Compute horizontal ratio between src and destination width.*/
        if (u32_width_out >= u32_width_in)
        {
            u32_x_inc   = ((u32_width_in-1) * MAX_SHORT) / (u32_width_out-1);
        }
        else
        {
            u32_x_inc   = (u32_width_in * MAX_SHORT) / (u32_width_out);
        }

        /* Compute vertical ratio between src and destination height.*/
        if (u32_height_out >= u32_height_in)
        {
            u32_y_inc   = ((u32_height_in - 1) * MAX_SHORT) / (u32_height_out-1);
        }
        else
        {
            u32_y_inc = (u32_height_in * MAX_SHORT) / (u32_height_out);
        }

        /*
        Calculate initial accumulator value : u32_y_accum_start.
        u32_y_accum_start is coded on 15 bits, and represents a value between 0 and 0.5
        */
        if (u32_y_inc >= MAX_SHORT)
        {
            /*
                Keep the fractionnal part, assimung that integer  part is coded
                on the 16 high bits and the fractionnal on the 15 low bits
            */
            u32_y_accum = u32_y_inc & 0xffff;

            if (!u32_y_accum)
            {
                u32_y_accum = MAX_SHORT;
            }

            u32_y_accum >>= 1;
        }
        else
        {
            u32_y_accum = 0;
        }


        /*
            Calculate initial accumulator value : u32_x_accum_start.
            u32_x_accum_start is coded on 15 bits, and represents a value between 0 and 0.5
        */
        if (u32_x_inc >= MAX_SHORT)
        {
            u32_x_accum_start = u32_x_inc & 0xffff;

            if (!u32_x_accum_start)
            {
                u32_x_accum_start = MAX_SHORT;
            }

            u32_x_accum_start >>= 1;
        }
        else
        {
            u32_x_accum_start = 0;
        }

        u32_height = u32_height_out;

        /*
        Bilinear interpolation linearly interpolates along each row, and then uses that
        result in a linear interpolation donw each column. Each estimated pixel in the
        output image is a weighted combination of its four neighbours according to the formula:
        F(p',q')=f(p,q)R(-a)R(b)+f(p,q-1)R(-a)R(b-1)+f(p+1,q)R(1-a)R(b)+f(p+&,q+1)R(1-a)R(b-1)
        with  R(x) = / x+1  -1 =< x =< 0 \ 1-x  0 =< x =< 1 and a (resp. b)weighting coefficient
        is the distance from the nearest neighbor in the p (resp. q) direction
        */

        do { /* Scan all the row */

            /* Vertical weight factor */
            u32_y_frac = (u32_y_accum>>12)&15;

            /* Reinit accumulator */
            u32_x_accum = u32_x_accum_start;

            u32_width = u32_width_out;

            do { /* Scan along each row */
                pu8_src_top = pu8_data_in + (u32_x_accum >> 16)*3;
                pu8_src_bottom = pu8_src_top + (u32_stride_in);
                u32_x_frac = (u32_x_accum >> 12)&15; /* Horizontal weight factor */

                if ((u32_width == 1) && (u32_width_in == u32_width_out)) {
                    /*
                       When input height is equal to output height and input width
                       equal to output width, replicate the corner pixels for
                       interpolation
                    */
                    if ((u32_height == 1) && (u32_height_in == u32_height_out)) {
                        GET_RGB24(i32_b00,i32_g00,i32_r00,pu8_src_top,0);
                        GET_RGB24(i32_b01,i32_g01,i32_r01,pu8_src_top,0);
                        GET_RGB24(i32_b02,i32_g02,i32_r02,pu8_src_top,0);
                        GET_RGB24(i32_b03,i32_g03,i32_r03,pu8_src_top,0);
                    }
                    /*
                       When input height is not equal to output height and
                       input width equal to output width, replicate the
                       column for interpolation
                    */
                    else {
                        GET_RGB24(i32_b00,i32_g00,i32_r00,pu8_src_top,0);
                        GET_RGB24(i32_b01,i32_g01,i32_r01,pu8_src_top,0);
                        GET_RGB24(i32_b02,i32_g02,i32_r02,pu8_src_bottom,0);
                        GET_RGB24(i32_b03,i32_g03,i32_r03,pu8_src_bottom,0);
                    }
                } else {
                    /*
                       When input height is equal to output height and
                       input width not equal to output width, replicate the
                       row for interpolation
                    */
                    if ((u32_height == 1) && (u32_height_in == u32_height_out)) {
                        GET_RGB24(i32_b00,i32_g00,i32_r00,pu8_src_top,0);
                        GET_RGB24(i32_b01,i32_g01,i32_r01,pu8_src_top,3);
                        GET_RGB24(i32_b02,i32_g02,i32_r02,pu8_src_top,0);
                        GET_RGB24(i32_b03,i32_g03,i32_r03,pu8_src_top,3);
                    } else {
                        GET_RGB24(i32_b00,i32_g00,i32_r00,pu8_src_top,0);
                        GET_RGB24(i32_b01,i32_g01,i32_r01,pu8_src_top,3);
                        GET_RGB24(i32_b02,i32_g02,i32_r02,pu8_src_bottom,0);
                        GET_RGB24(i32_b03,i32_g03,i32_r03,pu8_src_bottom,3);
                    }
                }
                u32_Rtemp_value = (M4VIFI_UInt8)(((i32_r00*(16-u32_x_frac) +
                                 i32_r01*u32_x_frac)*(16-u32_y_frac) +
                                (i32_r02*(16-u32_x_frac) +
                                 i32_r03*u32_x_frac)*u32_y_frac )>>8);

                u32_Gtemp_value = (M4VIFI_UInt8)(((i32_g00*(16-u32_x_frac) +
                                 i32_g01*u32_x_frac)*(16-u32_y_frac) +
                                (i32_g02*(16-u32_x_frac) +
                                 i32_g03*u32_x_frac)*u32_y_frac )>>8);

                u32_Btemp_value =  (M4VIFI_UInt8)(((i32_b00*(16-u32_x_frac) +
                                 i32_b01*u32_x_frac)*(16-u32_y_frac) +
                                (i32_b02*(16-u32_x_frac) +
                                 i32_b03*u32_x_frac)*u32_y_frac )>>8);

                *pu8_data_out++ = u32_Btemp_value ;
                *pu8_data_out++ = u32_Gtemp_value ;
                *pu8_data_out++ = u32_Rtemp_value ;

                /* Update horizontal accumulator */
                u32_x_accum += u32_x_inc;

            } while(--u32_width);

            //pu16_data_out = pu16_data_out + (u32_stride_out>>1) - (u32_width_out);

            /* Update vertical accumulator */
            u32_y_accum += u32_y_inc;
            if (u32_y_accum>>16)
            {
                pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * (u32_stride_in) ;
                u32_y_accum &= 0xffff;
            }
        } while(--u32_height);

    return M4VIFI_OK;
}
/* End of file M4VIFI_ResizeRGB565toRGB565.c */