/******************************************************************************
*
* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
*
* 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
*  ihevc_deblk_edge_filter.c
*
* @brief
*  Contains function definitions for deblocking filters
*
* @author
*  Srinivas T
*
* @par List of Functions:
*   - ihevc_deblk_luma_vert()
*   - ihevc_deblk_luma_horz()
*   - ihevc_deblk_chroma_vert()
*   - ihevc_deblk_chroma_horz()
*   - ihevc_hbd_deblk_luma_vert()
*   - ihevc_hbd_deblk_luma_horz()
*   - ihevc_hbd_deblk_chroma_vert()
*   - ihevc_hbd_deblk_chroma_horz()
* @remarks
*  None
*
*******************************************************************************
*/
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "ihevc_typedefs.h"
#include "ihevc_macros.h"
#include "ihevc_platform_macros.h"
#include "ihevc_func_selector.h"
#include "ihevc_deblk.h"
#include "ihevc_deblk_tables.h"
#include "ihevc_debug.h"


/**
*******************************************************************************
*
* @brief
*       Decision process and filtering for the luma block vertical edge.
*
* @par Description:
*     The decision process for the luma block vertical edge is  carried out and
*     an appropriate filter is applied. The  boundary filter strength, bs should
*     be greater than 0.  The pcm flags and the transquant bypass flags should
*     be  taken care of by the calling function.
*
* @param[in] pu1_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_deblk_luma_vert(UWORD8 *pu1_src,
                           WORD32 src_strd,
                           WORD32 bs,
                           WORD32 quant_param_p,
                           WORD32 quant_param_q,
                           WORD32 beta_offset_div2,
                           WORD32 tc_offset_div2,
                           WORD32 filter_flag_p,
                           WORD32 filter_flag_q)
{
    WORD32 qp_luma, beta_indx, tc_indx;
    WORD32 beta, tc;
    WORD32 dp0, dp3, dq0, dq3, d0, d3, dp, dq, d;
    WORD32 d_sam0, d_sam3;
    WORD32 de, dep, deq;
    WORD32 row;
    WORD32 tmp_p0, tmp_p1, tmp_p2, tmp_q0, tmp_q1, tmp_q2;
    WORD32 delta, delta_p, delta_q;

    ASSERT((bs > 0) && (bs <= 3));
    ASSERT(filter_flag_p || filter_flag_q);

    qp_luma = (quant_param_p + quant_param_q + 1) >> 1;
    beta_indx = CLIP3(qp_luma + (beta_offset_div2 << 1), 0, 51);

    /* BS based on implementation can take value 3 if it is intra/inter egde          */
    /* based on BS, tc index is calcuated by adding 2 * ( bs - 1) to QP and tc_offset */
    /* for BS = 1 adding factor is (0*2), BS = 2 or 3 adding factor is (1*2)          */
    /* the above desired functionallity is achieved by doing (2*(bs>>1))              */

    tc_indx = CLIP3(qp_luma + (2 * (bs >> 1)) + (tc_offset_div2 << 1), 0, 53);

    beta = gai4_ihevc_beta_table[beta_indx];
    tc = gai4_ihevc_tc_table[tc_indx];
    if(0 == tc)
    {
        return;
    }

    dq0 = ABS(pu1_src[2] - 2 * pu1_src[1] + pu1_src[0]);
    dq3 = ABS(pu1_src[3 * src_strd + 2] - 2 * pu1_src[3 * src_strd + 1]
                    + pu1_src[3 * src_strd + 0]);
    dp0 = ABS(pu1_src[-3] - 2 * pu1_src[-2] + pu1_src[-1]);
    dp3 = ABS(pu1_src[3 * src_strd - 3] - 2 * pu1_src[3 * src_strd - 2]
                    + pu1_src[3 * src_strd - 1]);

    d0 = dp0 + dq0;
    d3 = dp3 + dq3;

    dp = dp0 + dp3;
    dq = dq0 + dq3;

    d = d0 + d3;

    de = 0;
    dep = 0;
    deq = 0;

    if(d < beta)
    {
        d_sam0 = 0;
        if((2 * d0 < (beta >> 2))
                        && (ABS(pu1_src[3] - pu1_src[0]) + ABS(pu1_src[-1] - pu1_src[-4])
                                        < (beta >> 3))
                        && ABS(pu1_src[0] - pu1_src[-1]) < ((5 * tc + 1) >> 1))
        {
            d_sam0 = 1;
        }

        pu1_src += 3 * src_strd;
        d_sam3 = 0;
        if((2 * d3 < (beta >> 2))
                        && (ABS(pu1_src[3] - pu1_src[0]) + ABS(pu1_src[-1] - pu1_src[-4])
                                        < (beta >> 3))
                        && ABS(pu1_src[0] - pu1_src[-1]) < ((5 * tc + 1) >> 1))
        {
            d_sam3 = 1;
        }
        pu1_src -= 3 * src_strd;

        de = (d_sam0 == 1 && d_sam3 == 1) ? 2 : 1;
        dep = (dp < (beta + (beta >> 1)) >> 3) ? 1 : 0;
        deq = (dq < (beta + (beta >> 1)) >> 3) ? 1 : 0;
        if(tc <= 1)
        {
            dep = 0;
            deq = 0;
        }
    }

    if(de != 0)
    {
        for(row = 0; row < 4; row++)
        {
            tmp_p0 = pu1_src[-1];
            tmp_p1 = pu1_src[-2];
            tmp_p2 = pu1_src[-3];

            tmp_q0 = pu1_src[0];
            tmp_q1 = pu1_src[1];
            tmp_q2 = pu1_src[2];

            if(de == 2)
            {
                tmp_q0 = CLIP3((pu1_src[2] + 2 * pu1_src[1] +
                                2 * pu1_src[0] + 2 * pu1_src[-1] +
                                pu1_src[-2] + 4) >> 3,
                                pu1_src[0] - 2 * tc,
                                pu1_src[0] + 2 * tc);

                tmp_q1 = CLIP3((pu1_src[2] + pu1_src[1] + pu1_src[0] +
                                pu1_src[-1] + 2) >> 2,
                                pu1_src[1] - 2 * tc,
                                pu1_src[1] + 2 * tc);

                tmp_q2 = CLIP3((2 * pu1_src[3] + 3 * pu1_src[2] +
                                pu1_src[1] + pu1_src[0] +
                                pu1_src[-1] + 4) >> 3,
                                pu1_src[2] - 2 * tc,
                                pu1_src[2] + 2 * tc);

                tmp_p0 = CLIP3((pu1_src[1] + 2 * pu1_src[0] +
                                2 * pu1_src[-1] + 2 * pu1_src[-2] +
                                pu1_src[-3] + 4) >> 3,
                                pu1_src[-1] - 2 * tc,
                                pu1_src[-1] + 2 * tc);

                tmp_p1 = CLIP3((pu1_src[0] + pu1_src[-1] +
                                pu1_src[-2] + pu1_src[-3] + 2) >> 2,
                                pu1_src[-2] - 2 * tc,
                                pu1_src[-2] + 2 * tc);

                tmp_p2 = CLIP3((pu1_src[0] + pu1_src[-1] +
                                pu1_src[-2] + 3 * pu1_src[-3] +
                                2 * pu1_src[-4] + 4) >> 3,
                                pu1_src[-3] - 2 * tc,
                                pu1_src[-3] + 2 * tc);
            }
            else
            {
                delta = (9 * (pu1_src[0] - pu1_src[-1]) -
                                3 * (pu1_src[1] - pu1_src[-2]) + 8) >> 4;
                if(ABS(delta) < 10 * tc)
                {
                    delta = CLIP3(delta, -tc, tc);

                    tmp_p0 = CLIP_U8(pu1_src[-1] + delta);
                    tmp_q0 = CLIP_U8(pu1_src[0] - delta);

                    if(dep == 1)
                    {
                        delta_p = CLIP3((((pu1_src[-3] + pu1_src[-1] + 1) >> 1)
                                        - pu1_src[-2] + delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_p1 = CLIP_U8(pu1_src[-2] + delta_p);
                    }

                    if(deq == 1)
                    {
                        delta_q = CLIP3((((pu1_src[2] + pu1_src[0] + 1) >> 1)
                                        - pu1_src[1] - delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_q1 = CLIP_U8(pu1_src[1] + delta_q);
                    }
                }
            }

            if(filter_flag_p != 0)
            {
                pu1_src[-3] = tmp_p2;
                pu1_src[-2] = tmp_p1;
                pu1_src[-1] = tmp_p0;
            }

            if(filter_flag_q != 0)
            {
                pu1_src[0] = tmp_q0;
                pu1_src[1] = tmp_q1;
                pu1_src[2] = tmp_q2;
            }

            pu1_src += src_strd;
        }
    }

}


/**
*******************************************************************************
*
* @brief
*       Decision process and filtering for the luma block vertical edge for high bit depth.
*
* @par Description:
*     The decision process for the luma block vertical edge is  carried out and
*     an appropriate filter is applied. The  boundary filter strength, bs should
*     be greater than 0.  The pcm flags and the transquant bypass flags should
*     be  taken care of by the calling function.
*
* @param[in] pu2_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_hbd_deblk_luma_vert(UWORD16 *pu2_src,
                               WORD32 src_strd,
                               WORD32 bs,
                               WORD32 quant_param_p,
                               WORD32 quant_param_q,
                               WORD32 beta_offset_div2,
                               WORD32 tc_offset_div2,
                               WORD32 filter_flag_p,
                               WORD32 filter_flag_q,
                               UWORD8 bit_depth)
{
    WORD32 qp_luma, beta_indx, tc_indx;
    WORD32 beta, tc;
    WORD32 dp0, dp3, dq0, dq3, d0, d3, dp, dq, d;
    WORD32 d_sam0, d_sam3;
    WORD32 de, dep, deq;
    WORD32 row;
    WORD32 tmp_p0, tmp_p1, tmp_p2, tmp_q0, tmp_q1, tmp_q2;
    WORD32 delta, delta_p, delta_q;

    ASSERT((bs > 0) && (bs <= 3));
    ASSERT(filter_flag_p || filter_flag_q);

    qp_luma = (quant_param_p + quant_param_q + 1) >> 1;
    beta_indx = CLIP3(qp_luma + (beta_offset_div2 << 1), 0, 51);

    /* BS based on implementation can take value 3 if it is intra/inter egde          */
    /* based on BS, tc index is calcuated by adding 2 * ( bs - 1) to QP and tc_offset */
    /* for BS = 1 adding factor is (0*2), BS = 2 or 3 adding factor is (1*2)          */
    /* the above desired functionallity is achieved by doing (2*(bs>>1))              */

    tc_indx = CLIP3(qp_luma + (2 * (bs >> 1)) + (tc_offset_div2 << 1), 0, 53);

    beta = gai4_ihevc_beta_table[beta_indx] * (1 << (bit_depth - 8));
    tc = gai4_ihevc_tc_table[tc_indx] * (1 << (bit_depth - 8));
    if(0 == tc)
    {
        return;
    }

    dq0 = ABS(pu2_src[2] - 2 * pu2_src[1] + pu2_src[0]);
    dq3 = ABS(pu2_src[3 * src_strd + 2] - 2 * pu2_src[3 * src_strd + 1]
                    + pu2_src[3 * src_strd + 0]);
    dp0 = ABS(pu2_src[-3] - 2 * pu2_src[-2] + pu2_src[-1]);
    dp3 = ABS(pu2_src[3 * src_strd - 3] - 2 * pu2_src[3 * src_strd - 2]
                    + pu2_src[3 * src_strd - 1]);

    d0 = dp0 + dq0;
    d3 = dp3 + dq3;

    dp = dp0 + dp3;
    dq = dq0 + dq3;

    d = d0 + d3;

    de = 0;
    dep = 0;
    deq = 0;

    if(d < beta)
    {
        d_sam0 = 0;
        if((2 * d0 < (beta >> 2))
                        && (ABS(pu2_src[3] - pu2_src[0]) + ABS(pu2_src[-1] - pu2_src[-4])
                                        < (beta >> 3))
                        && ABS(pu2_src[0] - pu2_src[-1]) < ((5 * tc + 1) >> 1))
        {
            d_sam0 = 1;
        }

        pu2_src += 3 * src_strd;
        d_sam3 = 0;
        if((2 * d3 < (beta >> 2))
                        && (ABS(pu2_src[3] - pu2_src[0]) + ABS(pu2_src[-1] - pu2_src[-4])
                                        < (beta >> 3))
                        && ABS(pu2_src[0] - pu2_src[-1]) < ((5 * tc + 1) >> 1))
        {
            d_sam3 = 1;
        }
        pu2_src -= 3 * src_strd;

        de = (d_sam0 == 1 && d_sam3 == 1) ? 2 : 1;
        dep = (dp < (beta + (beta >> 1)) >> 3) ? 1 : 0;
        deq = (dq < (beta + (beta >> 1)) >> 3) ? 1 : 0;
        if(tc <= 1)
        {
            dep = 0;
            deq = 0;
        }
    }

    if(de != 0)
    {
        for(row = 0; row < 4; row++)
        {
            tmp_p0 = pu2_src[-1];
            tmp_p1 = pu2_src[-2];
            tmp_p2 = pu2_src[-3];

            tmp_q0 = pu2_src[0];
            tmp_q1 = pu2_src[1];
            tmp_q2 = pu2_src[2];

            if(de == 2)
            {
                tmp_q0 = CLIP3((pu2_src[2] + 2 * pu2_src[1] +
                                2 * pu2_src[0] + 2 * pu2_src[-1] +
                                pu2_src[-2] + 4) >> 3,
                                pu2_src[0] - 2 * tc,
                                pu2_src[0] + 2 * tc);

                tmp_q1 = CLIP3((pu2_src[2] + pu2_src[1] + pu2_src[0] +
                                pu2_src[-1] + 2) >> 2,
                                pu2_src[1] - 2 * tc,
                                pu2_src[1] + 2 * tc);

                tmp_q2 = CLIP3((2 * pu2_src[3] + 3 * pu2_src[2] +
                                pu2_src[1] + pu2_src[0] +
                                pu2_src[-1] + 4) >> 3,
                                pu2_src[2] - 2 * tc,
                                pu2_src[2] + 2 * tc);

                tmp_p0 = CLIP3((pu2_src[1] + 2 * pu2_src[0] +
                                2 * pu2_src[-1] + 2 * pu2_src[-2] +
                                pu2_src[-3] + 4) >> 3,
                                pu2_src[-1] - 2 * tc,
                                pu2_src[-1] + 2 * tc);

                tmp_p1 = CLIP3((pu2_src[0] + pu2_src[-1] +
                                pu2_src[-2] + pu2_src[-3] + 2) >> 2,
                                pu2_src[-2] - 2 * tc,
                                pu2_src[-2] + 2 * tc);

                tmp_p2 = CLIP3((pu2_src[0] + pu2_src[-1] +
                                pu2_src[-2] + 3 * pu2_src[-3] +
                                2 * pu2_src[-4] + 4) >> 3,
                                pu2_src[-3] - 2 * tc,
                                pu2_src[-3] + 2 * tc);
            }
            else
            {
                delta = (9 * (pu2_src[0] - pu2_src[-1]) -
                                3 * (pu2_src[1] - pu2_src[-2]) + 8) >> 4;
                if(ABS(delta) < 10 * tc)
                {
                    delta = CLIP3(delta, -tc, tc);

                    tmp_p0 = CLIP3(pu2_src[-1] + delta, 0, ((1 << bit_depth) - 1));
                    tmp_q0 = CLIP3(pu2_src[0] - delta, 0, ((1 << bit_depth) - 1));
                    if(dep == 1)
                    {
                        delta_p = CLIP3((((pu2_src[-3] + pu2_src[-1] + 1) >> 1)
                                        - pu2_src[-2] + delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_p1 = CLIP3(pu2_src[-2] + delta_p, 0, ((1 << bit_depth) - 1));
                    }

                    if(deq == 1)
                    {
                        delta_q = CLIP3((((pu2_src[2] + pu2_src[0] + 1) >> 1)
                                        - pu2_src[1] - delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_q1 = CLIP3(pu2_src[1] + delta_q, 0, ((1 << bit_depth) - 1));
                    }
                }
            }

            if(filter_flag_p != 0)
            {
                pu2_src[-3] = tmp_p2;
                pu2_src[-2] = tmp_p1;
                pu2_src[-1] = tmp_p0;
            }

            if(filter_flag_q != 0)
            {
                pu2_src[0] = tmp_q0;
                pu2_src[1] = tmp_q1;
                pu2_src[2] = tmp_q2;
            }

            pu2_src += src_strd;
        }
    }

}


/**
*******************************************************************************
*
* @brief
*
*     Decision process and filtering for the luma block horizontal edge
*
* @par Description:
*     The decision process for the luma block horizontal edge  is carried out
*    and an appropriate filter is applied. The  boundary filter strength, bs
*    should be greater than 0.  The pcm flags and the transquant bypass flags
*    should be  taken care of by the calling function.
*
* @param[in] pu1_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_deblk_luma_horz(UWORD8 *pu1_src,
                           WORD32 src_strd,
                           WORD32 bs,
                           WORD32 quant_param_p,
                           WORD32 quant_param_q,
                           WORD32 beta_offset_div2,
                           WORD32 tc_offset_div2,
                           WORD32 filter_flag_p,
                           WORD32 filter_flag_q)
{
    WORD32 qp_luma, beta_indx, tc_indx;
    WORD32 beta, tc;
    WORD32 dp0, dp3, dq0, dq3, d0, d3, dp, dq, d;
    WORD32 d_sam0, d_sam3;
    WORD32 de, dep, deq;
    WORD32 col;
    WORD32 tmp_p0, tmp_p1, tmp_p2, tmp_q0, tmp_q1, tmp_q2;
    WORD32 delta, delta_p, delta_q;

    ASSERT((bs > 0));
    ASSERT(filter_flag_p || filter_flag_q);

    qp_luma = (quant_param_p + quant_param_q + 1) >> 1;
    beta_indx = CLIP3(qp_luma + (beta_offset_div2 << 1), 0, 51);

    /* BS based on implementation can take value 3 if it is intra/inter egde          */
    /* based on BS, tc index is calcuated by adding 2 * ( bs - 1) to QP and tc_offset */
    /* for BS = 1 adding factor is (0*2), BS = 2 or 3 adding factor is (1*2)          */
    /* the above desired functionallity is achieved by doing (2*(bs>>1))              */

    tc_indx = CLIP3(qp_luma + 2 * (bs >> 1) + (tc_offset_div2 << 1), 0, 53);

    beta = gai4_ihevc_beta_table[beta_indx];
    tc = gai4_ihevc_tc_table[tc_indx];
    if(0 == tc)
    {
        return;
    }

    dq0 = ABS(pu1_src[2 * src_strd] - 2 * pu1_src[1 * src_strd] +
                    pu1_src[0 * src_strd]);

    dq3 = ABS(pu1_src[3 + 2 * src_strd] - 2 * pu1_src[3 + 1 * src_strd] +
                    pu1_src[3 + 0 * src_strd]);

    dp0 = ABS(pu1_src[-3 * src_strd] - 2 * pu1_src[-2 * src_strd] +
                    pu1_src[-1 * src_strd]);

    dp3 = ABS(pu1_src[3 - 3 * src_strd] - 2 * pu1_src[3 - 2 * src_strd] +
                    pu1_src[3 - 1 * src_strd]);

    d0 = dp0 + dq0;
    d3 = dp3 + dq3;

    dp = dp0 + dp3;
    dq = dq0 + dq3;

    d = d0 + d3;

    de = 0;
    dep = 0;
    deq = 0;

    if(d < beta)
    {
        d_sam0 = 0;
        if((2 * d0 < (beta >> 2))
                        && (ABS(pu1_src[3 * src_strd] - pu1_src[0 * src_strd]) +
                                        ABS(pu1_src[-1 * src_strd] - pu1_src[-4 * src_strd])
                                        < (beta >> 3))
                        && ABS(pu1_src[0 * src_strd] - pu1_src[-1 * src_strd])
                        < ((5 * tc + 1) >> 1))
        {
            d_sam0 = 1;
        }

        pu1_src += 3;
        d_sam3 = 0;
        if((2 * d3 < (beta >> 2))
                        && (ABS(pu1_src[3 * src_strd] - pu1_src[0 * src_strd]) +
                                        ABS(pu1_src[-1 * src_strd] - pu1_src[-4 * src_strd])
                                        < (beta >> 3))
                        && ABS(pu1_src[0 * src_strd] - pu1_src[-1 * src_strd])
                        < ((5 * tc + 1) >> 1))
        {
            d_sam3 = 1;
        }
        pu1_src -= 3;

        de = (d_sam0 == 1 && d_sam3 == 1) ? 2 : 1;
        dep = (dp < ((beta + (beta >> 1)) >> 3)) ? 1 : 0;
        deq = (dq < ((beta + (beta >> 1)) >> 3)) ? 1 : 0;
        if(tc <= 1)
        {
            dep = 0;
            deq = 0;
        }
    }

    if(de != 0)
    {
        for(col = 0; col < 4; col++)
        {
            tmp_p0 = pu1_src[-1 * src_strd];
            tmp_p1 = pu1_src[-2 * src_strd];
            tmp_p2 = pu1_src[-3 * src_strd];

            tmp_q0 = pu1_src[0 * src_strd];
            tmp_q1 = pu1_src[1 * src_strd];
            tmp_q2 = pu1_src[2 * src_strd];
            if(de == 2)
            {
                tmp_q0 = CLIP3((pu1_src[2 * src_strd] +
                                2 * pu1_src[1 * src_strd] +
                                2 * pu1_src[0 * src_strd] +
                                2 * pu1_src[-1 * src_strd] +
                                pu1_src[-2 * src_strd] + 4) >> 3,
                                pu1_src[0 * src_strd] - 2 * tc,
                                pu1_src[0 * src_strd] + 2 * tc);

                tmp_q1 = CLIP3((pu1_src[2 * src_strd] +
                                pu1_src[1 * src_strd] +
                                pu1_src[0 * src_strd] +
                                pu1_src[-1 * src_strd] + 2) >> 2,
                                pu1_src[1 * src_strd] - 2 * tc,
                                pu1_src[1 * src_strd] + 2 * tc);

                tmp_q2 = CLIP3((2 * pu1_src[3 * src_strd] +
                                3 * pu1_src[2 * src_strd] +
                                pu1_src[1 * src_strd] +
                                pu1_src[0 * src_strd] +
                                pu1_src[-1 * src_strd] + 4) >> 3,
                                pu1_src[2 * src_strd] - 2 * tc,
                                pu1_src[2 * src_strd] + 2 * tc);

                tmp_p0 = CLIP3((pu1_src[1 * src_strd] +
                                2 * pu1_src[0 * src_strd] +
                                2 * pu1_src[-1 * src_strd] +
                                2 * pu1_src[-2 * src_strd] +
                                pu1_src[-3 * src_strd] + 4) >> 3,
                                pu1_src[-1 * src_strd] - 2 * tc,
                                pu1_src[-1 * src_strd] + 2 * tc);

                tmp_p1 = CLIP3((pu1_src[0 * src_strd] +
                                pu1_src[-1 * src_strd] +
                                pu1_src[-2 * src_strd] +
                                pu1_src[-3 * src_strd] + 2) >> 2,
                                pu1_src[-2 * src_strd] - 2 * tc,
                                pu1_src[-2 * src_strd] + 2 * tc);

                tmp_p2 = CLIP3((pu1_src[0 * src_strd] +
                                pu1_src[-1 * src_strd] +
                                pu1_src[-2 * src_strd] +
                                3 * pu1_src[-3 * src_strd] +
                                2 * pu1_src[-4 * src_strd] + 4) >> 3,
                                pu1_src[-3 * src_strd] - 2 * tc,
                                pu1_src[-3 * src_strd] + 2 * tc);
            }
            else
            {
                delta = (9 * (pu1_src[0 * src_strd] - pu1_src[-1 * src_strd]) -
                                3 * (pu1_src[1 * src_strd] - pu1_src[-2 * src_strd]) +
                                8) >> 4;
                if(ABS(delta) < 10 * tc)
                {
                    delta = CLIP3(delta, -tc, tc);

                    tmp_p0 = CLIP_U8(pu1_src[-1 * src_strd] + delta);
                    tmp_q0 = CLIP_U8(pu1_src[0 * src_strd] - delta);

                    if(dep == 1)
                    {
                        delta_p = CLIP3((((pu1_src[-3 * src_strd] +
                                        pu1_src[-1 * src_strd] + 1) >> 1) -
                                        pu1_src[-2 * src_strd] + delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_p1 = CLIP_U8(pu1_src[-2 * src_strd] + delta_p);
                    }

                    if(deq == 1)
                    {
                        delta_q = CLIP3((((pu1_src[2 * src_strd] +
                                        pu1_src[0 * src_strd] + 1) >> 1) -
                                        pu1_src[1 * src_strd] - delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_q1 = CLIP_U8(pu1_src[1 * src_strd] + delta_q);
                    }
                }
            }

            if(filter_flag_p != 0)
            {
                pu1_src[-3 * src_strd] = tmp_p2;
                pu1_src[-2 * src_strd] = tmp_p1;
                pu1_src[-1 * src_strd] = tmp_p0;
            }

            if(filter_flag_q != 0)
            {
                pu1_src[0 * src_strd] = tmp_q0;
                pu1_src[1 * src_strd] = tmp_q1;
                pu1_src[2 * src_strd] = tmp_q2;
            }

            pu1_src += 1;
        }
    }

}


/**
*******************************************************************************
*
* @brief
*
*     Decision process and filtering for the luma block horizontal edge for high bit depth
*
* @par Description:
*     The decision process for the luma block horizontal edge  is carried out
*    and an appropriate filter is applied. The  boundary filter strength, bs
*    should be greater than 0.  The pcm flags and the transquant bypass flags
*    should be  taken care of by the calling function.
*
* @param[in] pu1_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_hbd_deblk_luma_horz(UWORD16 *pu2_src,
                               WORD32 src_strd,
                               WORD32 bs,
                               WORD32 quant_param_p,
                               WORD32 quant_param_q,
                               WORD32 beta_offset_div2,
                               WORD32 tc_offset_div2,
                               WORD32 filter_flag_p,
                               WORD32 filter_flag_q,
                               UWORD8 bit_depth)
{
    WORD32 qp_luma, beta_indx, tc_indx;
    WORD32 beta, tc;
    WORD32 dp0, dp3, dq0, dq3, d0, d3, dp, dq, d;
    WORD32 d_sam0, d_sam3;
    WORD32 de, dep, deq;
    WORD32 col;
    WORD32 tmp_p0, tmp_p1, tmp_p2, tmp_q0, tmp_q1, tmp_q2;
    WORD32 delta, delta_p, delta_q;

    ASSERT((bs > 0));
    ASSERT(filter_flag_p || filter_flag_q);

    qp_luma = (quant_param_p + quant_param_q + 1) >> 1;
    beta_indx = CLIP3(qp_luma + (beta_offset_div2 << 1), 0, 51);

    /* BS based on implementation can take value 3 if it is intra/inter egde          */
    /* based on BS, tc index is calcuated by adding 2 * ( bs - 1) to QP and tc_offset */
    /* for BS = 1 adding factor is (0*2), BS = 2 or 3 adding factor is (1*2)          */
    /* the above desired functionallity is achieved by doing (2*(bs>>1))              */

    tc_indx = CLIP3(qp_luma + 2 * (bs >> 1) + (tc_offset_div2 << 1), 0, 53);

    beta = gai4_ihevc_beta_table[beta_indx] * (1 << (bit_depth - 8));
    tc = gai4_ihevc_tc_table[tc_indx] * (1 << (bit_depth - 8));
    if(0 == tc)
    {
        return;
    }

    dq0 = ABS(pu2_src[2 * src_strd] - 2 * pu2_src[1 * src_strd] +
                    pu2_src[0 * src_strd]);

    dq3 = ABS(pu2_src[3 + 2 * src_strd] - 2 * pu2_src[3 + 1 * src_strd] +
                    pu2_src[3 + 0 * src_strd]);

    dp0 = ABS(pu2_src[-3 * src_strd] - 2 * pu2_src[-2 * src_strd] +
                    pu2_src[-1 * src_strd]);

    dp3 = ABS(pu2_src[3 - 3 * src_strd] - 2 * pu2_src[3 - 2 * src_strd] +
                    pu2_src[3 - 1 * src_strd]);

    d0 = dp0 + dq0;
    d3 = dp3 + dq3;

    dp = dp0 + dp3;
    dq = dq0 + dq3;

    d = d0 + d3;

    de = 0;
    dep = 0;
    deq = 0;

    if(d < beta)
    {
        d_sam0 = 0;
        if((2 * d0 < (beta >> 2))
                        && (ABS(pu2_src[3 * src_strd] - pu2_src[0 * src_strd]) +
                                        ABS(pu2_src[-1 * src_strd] - pu2_src[-4 * src_strd])
                                        < (beta >> 3))
                        && ABS(pu2_src[0 * src_strd] - pu2_src[-1 * src_strd])
                        < ((5 * tc + 1) >> 1))
        {
            d_sam0 = 1;
        }

        pu2_src += 3;
        d_sam3 = 0;
        if((2 * d3 < (beta >> 2))
                        && (ABS(pu2_src[3 * src_strd] - pu2_src[0 * src_strd]) +
                                        ABS(pu2_src[-1 * src_strd] - pu2_src[-4 * src_strd])
                                        < (beta >> 3))
                        && ABS(pu2_src[0 * src_strd] - pu2_src[-1 * src_strd])
                        < ((5 * tc + 1) >> 1))
        {
            d_sam3 = 1;
        }
        pu2_src -= 3;

        de = (d_sam0 == 1 && d_sam3 == 1) ? 2 : 1;
        dep = (dp < ((beta + (beta >> 1)) >> 3)) ? 1 : 0;
        deq = (dq < ((beta + (beta >> 1)) >> 3)) ? 1 : 0;
        if(tc <= 1)
        {
            dep = 0;
            deq = 0;
        }
    }

    if(de != 0)
    {
        for(col = 0; col < 4; col++)
        {
            tmp_p0 = pu2_src[-1 * src_strd];
            tmp_p1 = pu2_src[-2 * src_strd];
            tmp_p2 = pu2_src[-3 * src_strd];

            tmp_q0 = pu2_src[0 * src_strd];
            tmp_q1 = pu2_src[1 * src_strd];
            tmp_q2 = pu2_src[2 * src_strd];
            if(de == 2)
            {
                tmp_q0 = CLIP3((pu2_src[2 * src_strd] +
                                2 * pu2_src[1 * src_strd] +
                                2 * pu2_src[0 * src_strd] +
                                2 * pu2_src[-1 * src_strd] +
                                pu2_src[-2 * src_strd] + 4) >> 3,
                                pu2_src[0 * src_strd] - 2 * tc,
                                pu2_src[0 * src_strd] + 2 * tc);

                tmp_q1 = CLIP3((pu2_src[2 * src_strd] +
                                pu2_src[1 * src_strd] +
                                pu2_src[0 * src_strd] +
                                pu2_src[-1 * src_strd] + 2) >> 2,
                                pu2_src[1 * src_strd] - 2 * tc,
                                pu2_src[1 * src_strd] + 2 * tc);

                tmp_q2 = CLIP3((2 * pu2_src[3 * src_strd] +
                                3 * pu2_src[2 * src_strd] +
                                pu2_src[1 * src_strd] +
                                pu2_src[0 * src_strd] +
                                pu2_src[-1 * src_strd] + 4) >> 3,
                                pu2_src[2 * src_strd] - 2 * tc,
                                pu2_src[2 * src_strd] + 2 * tc);

                tmp_p0 = CLIP3((pu2_src[1 * src_strd] +
                                2 * pu2_src[0 * src_strd] +
                                2 * pu2_src[-1 * src_strd] +
                                2 * pu2_src[-2 * src_strd] +
                                pu2_src[-3 * src_strd] + 4) >> 3,
                                pu2_src[-1 * src_strd] - 2 * tc,
                                pu2_src[-1 * src_strd] + 2 * tc);

                tmp_p1 = CLIP3((pu2_src[0 * src_strd] +
                                pu2_src[-1 * src_strd] +
                                pu2_src[-2 * src_strd] +
                                pu2_src[-3 * src_strd] + 2) >> 2,
                                pu2_src[-2 * src_strd] - 2 * tc,
                                pu2_src[-2 * src_strd] + 2 * tc);

                tmp_p2 = CLIP3((pu2_src[0 * src_strd] +
                                pu2_src[-1 * src_strd] +
                                pu2_src[-2 * src_strd] +
                                3 * pu2_src[-3 * src_strd] +
                                2 * pu2_src[-4 * src_strd] + 4) >> 3,
                                pu2_src[-3 * src_strd] - 2 * tc,
                                pu2_src[-3 * src_strd] + 2 * tc);
            }
            else
            {
                delta = (9 * (pu2_src[0 * src_strd] - pu2_src[-1 * src_strd]) -
                                3 * (pu2_src[1 * src_strd] - pu2_src[-2 * src_strd]) +
                                8) >> 4;
                if(ABS(delta) < 10 * tc)
                {
                    delta = CLIP3(delta, -tc, tc);
                    tmp_p0 = CLIP3(pu2_src[-1 * src_strd] + delta, 0, ((1 << bit_depth) - 1));
                    tmp_q0 = CLIP3(pu2_src[0 * src_strd] - delta, 0, ((1 << bit_depth) - 1));
                    if(dep == 1)
                    {
                        delta_p = CLIP3((((pu2_src[-3 * src_strd] +
                                        pu2_src[-1 * src_strd] + 1) >> 1) -
                                        pu2_src[-2 * src_strd] + delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_p1 = CLIP3(pu2_src[-2 * src_strd] + delta_p, 0, ((1 << bit_depth) - 1));
                    }

                    if(deq == 1)
                    {
                        delta_q = CLIP3((((pu2_src[2 * src_strd] +
                                        pu2_src[0 * src_strd] + 1) >> 1) -
                                        pu2_src[1 * src_strd] - delta) >> 1,
                                        -(tc >> 1),
                                        (tc >> 1));
                        tmp_q1 = CLIP3(pu2_src[1 * src_strd] + delta_q, 0, ((1 << bit_depth) - 1));
                    }
                }
            }

            if(filter_flag_p != 0)
            {
                pu2_src[-3 * src_strd] = tmp_p2;
                pu2_src[-2 * src_strd] = tmp_p1;
                pu2_src[-1 * src_strd] = tmp_p0;
            }

            if(filter_flag_q != 0)
            {
                pu2_src[0 * src_strd] = tmp_q0;
                pu2_src[1 * src_strd] = tmp_q1;
                pu2_src[2 * src_strd] = tmp_q2;
            }

            pu2_src += 1;
        }
    }
}


/**
*******************************************************************************
*
* @brief
*     Filtering for the chroma block vertical edge.
*
* @par Description:
*     Filter for chroma vertical edge. The  boundary filter strength, bs
*    should be greater than 1.  The pcm flags and the transquant bypass flags
*    should be  taken care of by the calling function.
*
* @param[in] pu1_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_deblk_chroma_vert(UWORD8 *pu1_src,
                             WORD32 src_strd,
                             WORD32 quant_param_p,
                             WORD32 quant_param_q,
                             WORD32 qp_offset_u,
                             WORD32 qp_offset_v,
                             WORD32 tc_offset_div2,
                             WORD32 filter_flag_p,
                             WORD32 filter_flag_q)
{
    WORD32 qp_indx_u, qp_chroma_u;
    WORD32 qp_indx_v, qp_chroma_v;
    WORD32 tc_indx_u, tc_u;
    WORD32 tc_indx_v, tc_v;
    WORD32 delta_u, tmp_p0_u, tmp_q0_u;
    WORD32 delta_v, tmp_p0_v, tmp_q0_v;
    WORD32 row;

    ASSERT(filter_flag_p || filter_flag_q);

    /* chroma processing is done only if BS is 2             */
    /* this function is assumed to be called only if BS is 2 */
    qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_u = qp_indx_u < 0 ? qp_indx_u : (qp_indx_u > 57 ? qp_indx_u - 6 : gai4_ihevc_qp_table[qp_indx_u]);

    qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_v = qp_indx_v < 0 ? qp_indx_v : (qp_indx_v > 57 ? qp_indx_v - 6 : gai4_ihevc_qp_table[qp_indx_v]);

    tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_u = gai4_ihevc_tc_table[tc_indx_u];

    tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_v = gai4_ihevc_tc_table[tc_indx_v];

    if(0 == tc_u && 0 == tc_v)
    {
        return;
    }

    for(row = 0; row < 4; row++)
    {
        delta_u = CLIP3((((pu1_src[0] - pu1_src[-2]) << 2) +
                        pu1_src[-4] - pu1_src[2] + 4) >> 3,
                        -tc_u, tc_u);

        tmp_p0_u = CLIP_U8(pu1_src[-2] + delta_u);
        tmp_q0_u = CLIP_U8(pu1_src[0] - delta_u);

        delta_v = CLIP3((((pu1_src[1] - pu1_src[-1]) << 2) +
                        pu1_src[-3] - pu1_src[3] + 4) >> 3,
                        -tc_v, tc_v);

        tmp_p0_v = CLIP_U8(pu1_src[-1] + delta_v);
        tmp_q0_v = CLIP_U8(pu1_src[1] - delta_v);

        if(filter_flag_p != 0)
        {
            pu1_src[-2] = tmp_p0_u;
            pu1_src[-1] = tmp_p0_v;
        }

        if(filter_flag_q != 0)
        {
            pu1_src[0] = tmp_q0_u;
            pu1_src[1] = tmp_q0_v;
        }

        pu1_src += src_strd;
    }

}


/**
*******************************************************************************
*
* @brief
*     Filtering for the chroma block vertical edge.
*
* @par Description:
*     Filter for chroma vertical edge. The  boundary filter strength, bs
*    should be greater than 1.  The pcm flags and the transquant bypass flags
*    should be  taken care of by the calling function.
*
* @param[in] pu2_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_hbd_deblk_chroma_vert(UWORD16 *pu2_src,
                                 WORD32 src_strd,
                                 WORD32 quant_param_p,
                                 WORD32 quant_param_q,
                                 WORD32 qp_offset_u,
                                 WORD32 qp_offset_v,
                                 WORD32 tc_offset_div2,
                                 WORD32 filter_flag_p,
                                 WORD32 filter_flag_q,
                                 UWORD8 bit_depth)
{
    WORD32 qp_indx_u, qp_chroma_u;
    WORD32 qp_indx_v, qp_chroma_v;
    WORD32 tc_indx_u, tc_u;
    WORD32 tc_indx_v, tc_v;
    WORD32 delta_u, tmp_p0_u, tmp_q0_u;
    WORD32 delta_v, tmp_p0_v, tmp_q0_v;
    WORD32 row;

    ASSERT(filter_flag_p || filter_flag_q);

    /* chroma processing is done only if BS is 2             */
    /* this function is assumed to be called only if BS is 2 */
    qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_u = qp_indx_u < 0 ? qp_indx_u : (qp_indx_u > 57 ? qp_indx_u - 6 : gai4_ihevc_qp_table[qp_indx_u]);

    qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_v = qp_indx_v < 0 ? qp_indx_v : (qp_indx_v > 57 ? qp_indx_v - 6 : gai4_ihevc_qp_table[qp_indx_v]);

    tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_u = gai4_ihevc_tc_table[tc_indx_u] * (1 << (bit_depth - 8));

    tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_v = gai4_ihevc_tc_table[tc_indx_v] * (1 << (bit_depth - 8));

    if(0 == tc_u && 0 == tc_v)
    {
        return;
    }

    for(row = 0; row < 4; row++)
    {
        delta_u = CLIP3((((pu2_src[0] - pu2_src[-2]) << 2) +
                        pu2_src[-4] - pu2_src[2] + 4) >> 3,
                        -tc_u, tc_u);
        tmp_p0_u = CLIP3(pu2_src[-2] + delta_u, 0, ((1 << bit_depth) - 1));
        tmp_q0_u = CLIP3(pu2_src[0] - delta_u, 0, ((1 << bit_depth) - 1));

        delta_v = CLIP3((((pu2_src[1] - pu2_src[-1]) << 2) +
                        pu2_src[-3] - pu2_src[3] + 4) >> 3,
                        -tc_v, tc_v);
        tmp_p0_v = CLIP3(pu2_src[-1] + delta_v, 0, ((1 << bit_depth) - 1));
        tmp_q0_v = CLIP3(pu2_src[1] - delta_v, 0, ((1 << bit_depth) - 1));
        if(filter_flag_p != 0)
        {
            pu2_src[-2] = tmp_p0_u;
            pu2_src[-1] = tmp_p0_v;
        }

        if(filter_flag_q != 0)
        {
            pu2_src[0] = tmp_q0_u;
            pu2_src[1] = tmp_q0_v;
        }

        pu2_src += src_strd;
    }

}


/**
*******************************************************************************
*
* @brief
*   Filtering for the chroma block horizontal edge.
*
* @par Description:
*     Filter for chroma horizontal edge. The  boundary filter strength, bs
*    should be greater than 1.  The pcm flags and the transquant bypass flags
*    should be  taken care of by the calling function.
*
* @param[in] pu1_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_deblk_chroma_horz(UWORD8 *pu1_src,
                             WORD32 src_strd,
                             WORD32 quant_param_p,
                             WORD32 quant_param_q,
                             WORD32 qp_offset_u,
                             WORD32 qp_offset_v,
                             WORD32 tc_offset_div2,
                             WORD32 filter_flag_p,
                             WORD32 filter_flag_q)
{
    WORD32 qp_indx_u, qp_chroma_u;
    WORD32 qp_indx_v, qp_chroma_v;
    WORD32 tc_indx_u, tc_u;
    WORD32 tc_indx_v, tc_v;
    WORD32 tc;

    WORD32 delta, tmp_p0, tmp_q0;
    WORD32 col;

    ASSERT(filter_flag_p || filter_flag_q);

    /* chroma processing is done only if BS is 2             */
    /* this function is assumed to be called only if BS is 2 */
    qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_u = qp_indx_u < 0 ? qp_indx_u : (qp_indx_u > 57 ? qp_indx_u - 6 : gai4_ihevc_qp_table[qp_indx_u]);

    qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_v = qp_indx_v < 0 ? qp_indx_v : (qp_indx_v > 57 ? qp_indx_v - 6 : gai4_ihevc_qp_table[qp_indx_v]);

    tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_u = gai4_ihevc_tc_table[tc_indx_u];

    tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_v = gai4_ihevc_tc_table[tc_indx_v];

    if(0 == tc_u && 0 == tc_v)
    {
        return;
    }

    for(col = 0; col < 8; col++)
    {
        tc = (col & 1) ? tc_v : tc_u;
        delta = CLIP3((((pu1_src[0 * src_strd] -
                      pu1_src[-1 * src_strd]) << 2) +
                      pu1_src[-2 * src_strd] -
                      pu1_src[1 * src_strd] + 4) >> 3,
                      -tc, tc);

        tmp_p0 = CLIP_U8(pu1_src[-1 * src_strd] + delta);
        tmp_q0 = CLIP_U8(pu1_src[0 * src_strd] - delta);

        if(filter_flag_p != 0)
        {
            pu1_src[-1 * src_strd] = tmp_p0;
        }

        if(filter_flag_q != 0)
        {
            pu1_src[0 * src_strd] = tmp_q0;
        }

        pu1_src += 1;
    }

}


/**
*******************************************************************************
*
* @brief
*   Filtering for the chroma block horizontal edge.
*
* @par Description:
*     Filter for chroma horizontal edge. The  boundary filter strength, bs
*    should be greater than 1.  The pcm flags and the transquant bypass flags
*    should be  taken care of by the calling function.
*
* @param[in] pu2_src
*  Pointer to the src sample q(0,0)
*
* @param[in] src_strd
*  Source stride
*
* @param[in] bs
*  Boundary filter strength of q(0,0)
*
* @param[in] quant_param_p
*  quantization parameter of p block
*
* @param[in] quant_param_q
*  quantization parameter of p block
*
* @param[in] beta_offset_div2
*
*
* @param[in] tc_offset_div2
*
*
* @param[in] filter_flag_p
*  flag whether to filter the p block
*
* @param[in] filter_flag_q
*  flag whether to filter the q block
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_hbd_deblk_chroma_horz(UWORD16 *pu2_src,
                                 WORD32 src_strd,
                                 WORD32 quant_param_p,
                                 WORD32 quant_param_q,
                                 WORD32 qp_offset_u,
                                 WORD32 qp_offset_v,
                                 WORD32 tc_offset_div2,
                                 WORD32 filter_flag_p,
                                 WORD32 filter_flag_q,
                                 UWORD8 bit_depth)
{
    WORD32 qp_indx_u, qp_chroma_u;
    WORD32 qp_indx_v, qp_chroma_v;
    WORD32 tc_indx_u, tc_u;
    WORD32 tc_indx_v, tc_v;
    WORD32 tc;

    WORD32 delta, tmp_p0, tmp_q0;
    WORD32 col;

    ASSERT(filter_flag_p || filter_flag_q);

    /* chroma processing is done only if BS is 2             */
    /* this function is assumed to be called only if BS is 2 */
    qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_u = qp_indx_u < 0 ? qp_indx_u : (qp_indx_u > 57 ? qp_indx_u - 6 : gai4_ihevc_qp_table[qp_indx_u]);

    qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
    qp_chroma_v = qp_indx_v < 0 ? qp_indx_v : (qp_indx_v > 57 ? qp_indx_v - 6 : gai4_ihevc_qp_table[qp_indx_v]);

    tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_u = gai4_ihevc_tc_table[tc_indx_u] * (1 << (bit_depth - 8));

    tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
    tc_v = gai4_ihevc_tc_table[tc_indx_v] * (1 << (bit_depth - 8));

    if(0 == tc_u && 0 == tc_v)
    {
        return;
    }

    for(col = 0; col < 8; col++)
    {
        tc = (col & 1) ? tc_v : tc_u;
        delta = CLIP3((((pu2_src[0 * src_strd] -
                      pu2_src[-1 * src_strd]) << 2) +
                      pu2_src[-2 * src_strd] -
                      pu2_src[1 * src_strd] + 4) >> 3,
                      -tc, tc);
        tmp_p0 = CLIP3(pu2_src[-1 * src_strd] + delta, 0, ((1 << bit_depth) - 1));
        tmp_q0 = CLIP3(pu2_src[0 * src_strd] - delta, 0, ((1 << bit_depth) - 1));

        if(filter_flag_p != 0)
        {
            pu2_src[-1 * src_strd] = tmp_p0;
        }

        if(filter_flag_q != 0)
        {
            pu2_src[0 * src_strd] = tmp_q0;
        }

        pu2_src += 1;
    }

}