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

*

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

*

* @brief

*  Contains definition for the ctb level deblk function

*

* @author

*  Srinivas T

*

* @par List of Functions:

*   - ihevc_deblk()

*

* @remarks

*  None

*

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

*/

#include <stdio.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "ihevc_typedefs.h"

#include "iv.h"

#include "ivd.h"

#include "ihevcd_cxa.h"

#include "ithread.h"

#include "ihevc_defs.h"

#include "ihevc_debug.h"

#include "ihevc_defs.h"

#include "ihevc_structs.h"

#include "ihevc_macros.h"

#include "ihevc_platform_macros.h"

#include "ihevc_cabac_tables.h"

#include "ihevc_error.h"

#include "ihevc_common_tables.h"

#include "ihevcd_trace.h"

#include "ihevcd_defs.h"

#include "ihevcd_function_selector.h"

#include "ihevcd_structs.h"

#include "ihevcd_error.h"

#include "ihevcd_nal.h"

#include "ihevcd_bitstream.h"

#include "ihevcd_job_queue.h"

#include "ihevcd_utils.h"

#include "ihevcd_debug.h"

#include "ihevc_deblk.h"

#include "ihevc_deblk_tables.h"

#include "ihevcd_profile.h"

/**

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

*

* @brief

*     Deblock CTB level function.

*

* @par Description:

*     For a given CTB, deblocking on both vertical and

*     horizontal edges is done. Both the luma and chroma

*     blocks are processed

*

* @param[in] ps_deblk

*  Pointer to the deblock context

*

* @returns

*

* @remarks

*  None

*

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

*/

void ihevcd_deblk_ctb(deblk_ctxt_t *ps_deblk,

                      WORD32 i4_is_last_ctb_x,

                      WORD32 i4_is_last_ctb_y)

{

    WORD32 ctb_size;

    WORD32 log2_ctb_size;

    UWORD32 u4_bs;

    WORD32 bs_tz; /*Leading zeros in boundary strength*/

    WORD32 qp_p, qp_q;

    WORD32 filter_p, filter_q;

    UWORD8 *pu1_src;

    WORD32 qp_strd;

    UWORD32 *pu4_vert_bs, *pu4_horz_bs;

    UWORD32 *pu4_ctb_vert_bs, *pu4_ctb_horz_bs;

    WORD32 bs_strd;

    WORD32 src_strd;

    UWORD8 *pu1_qp;

    UWORD16 *pu2_ctb_no_loop_filter_flag;

    UWORD16 au2_ctb_no_loop_filter_flag[9];

    WORD32 col, row;

    /* Flag to indicate if QP is constant in CTB

     * 0 - top_left, 1 - top, 2 - left, 3 - current */

    UWORD32 u4_qp_const_in_ctb[4] = { 0, 0, 0, 0 };

    WORD32 ctb_indx;

    WORD32  chroma_yuv420sp_vu = ps_deblk->is_chroma_yuv420sp_vu;

    sps_t *ps_sps;

    pps_t *ps_pps;

    codec_t *ps_codec;

    slice_header_t *ps_slice_hdr;

    PROFILE_DISABLE_DEBLK();

    ps_sps = ps_deblk->ps_sps;

    ps_pps = ps_deblk->ps_pps;

    ps_codec = ps_deblk->ps_codec;

    ps_slice_hdr = ps_deblk->ps_slice_hdr;

    log2_ctb_size = ps_sps->i1_log2_ctb_size;

    ctb_size = (1 << ps_sps->i1_log2_ctb_size);

    /* strides are in units of number of bytes */

    /* ctb_size * ctb_size / 8 / 16 is the number of bytes needed per CTB */

    bs_strd = (ps_sps->i2_pic_wd_in_ctb + 1) << (2 * log2_ctb_size - 7);

    pu4_vert_bs = (UWORD32 *)((UWORD8 *)ps_deblk->s_bs_ctxt.pu4_pic_vert_bs +

                    (ps_deblk->i4_ctb_x << (2 * log2_ctb_size - 7)) +

                    ps_deblk->i4_ctb_y * bs_strd);

    pu4_ctb_vert_bs = pu4_vert_bs;

    pu4_horz_bs = (UWORD32 *)((UWORD8 *)ps_deblk->s_bs_ctxt.pu4_pic_horz_bs +

                    (ps_deblk->i4_ctb_x << (2 * log2_ctb_size - 7)) +

                    ps_deblk->i4_ctb_y * bs_strd);

    pu4_ctb_horz_bs = pu4_horz_bs;

    qp_strd = ps_sps->i2_pic_wd_in_ctb << (log2_ctb_size - 3);

    pu1_qp = ps_deblk->s_bs_ctxt.pu1_pic_qp + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * qp_strd) << (log2_ctb_size - 3));

    pu2_ctb_no_loop_filter_flag = ps_deblk->au2_ctb_no_loop_filter_flag;

    ctb_indx = ps_deblk->i4_ctb_x + ps_sps->i2_pic_wd_in_ctb * ps_deblk->i4_ctb_y;

    if(i4_is_last_ctb_y)

    {

        pu4_vert_bs = (UWORD32 *)((UWORD8 *)pu4_vert_bs + bs_strd);

        pu4_ctb_vert_bs = pu4_vert_bs;

        /* ctb_size/8 is the number of edges per CTB

         * ctb_size/4 is the number of BS values needed per edge

         * divided by 8 for the number of bytes

         * 2 is the number of bits needed for each BS value */

        memset(pu4_vert_bs, 0, 1 << (2 * log2_ctb_size - 7));

        pu1_qp += (qp_strd << (log2_ctb_size - 3));

        pu2_ctb_no_loop_filter_flag += (ctb_size >> 3);

        ctb_indx += ps_sps->i2_pic_wd_in_ctb;

    }

    if(i4_is_last_ctb_x)

    {

        pu4_horz_bs = (UWORD32 *)((UWORD8 *)pu4_horz_bs + (1 << (2 * log2_ctb_size - 7)));

        pu4_ctb_horz_bs = pu4_horz_bs;

        memset(pu4_horz_bs, 0, 1 << (2 * log2_ctb_size - 7));

        pu1_qp += (ctb_size >> 3);

        for(row = 0; row < (ctb_size >> 3) + 1; row++)

            au2_ctb_no_loop_filter_flag[row] = ps_deblk->au2_ctb_no_loop_filter_flag[row] >> (ctb_size >> 3);

        pu2_ctb_no_loop_filter_flag = au2_ctb_no_loop_filter_flag;

        ctb_indx += 1;

    }

    u4_qp_const_in_ctb[3] = ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx) >> 3] & (1 << (ctb_indx & 7));

    if(ps_deblk->i4_ctb_x || i4_is_last_ctb_x)

    {

        u4_qp_const_in_ctb[2] = ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx - 1) >> 3] & (1 << ((ctb_indx - 1) & 7));

    }

    if((ps_deblk->i4_ctb_x || i4_is_last_ctb_x) && (ps_deblk->i4_ctb_y || i4_is_last_ctb_y))

    {

        u4_qp_const_in_ctb[0] =

                        ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx - ps_sps->i2_pic_wd_in_ctb - 1) >> 3] &

                        (1 << ((ctb_indx - ps_sps->i2_pic_wd_in_ctb - 1) & 7));

    }

    if(ps_deblk->i4_ctb_y || i4_is_last_ctb_y)

    {

        u4_qp_const_in_ctb[1] =

                        ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx - ps_sps->i2_pic_wd_in_ctb) >> 3] &

                        (1 << ((ctb_indx - ps_sps->i2_pic_wd_in_ctb) & 7));

    }

    src_strd = ps_codec->i4_strd;

    /* Luma Vertical Edge */

    if(0 == i4_is_last_ctb_x)

    {

        /* Top CTB's slice header */

        slice_header_t *ps_slice_hdr_top;

        {

            WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb;

            if(i4_is_last_ctb_y)

                cur_ctb_indx += ps_sps->i2_pic_wd_in_ctb;

            ps_slice_hdr_top = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - ps_sps->i2_pic_wd_in_ctb];

        }

        pu1_src = ps_deblk->pu1_cur_pic_luma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd) << (log2_ctb_size));

        pu1_src += i4_is_last_ctb_y ? ps_deblk->ps_codec->i4_strd << log2_ctb_size : 0;

        /** Deblocking is done on a shifted CTB -

         *  Vertical edge processing is done by shifting the CTB up by four pixels */

        pu1_src -= 4 * src_strd;

        for(col = 0; col < ctb_size / 8; col++)

        {

            WORD32 shift = 0;

            /*  downshift vert_bs by ctb_size/2 for each column

             *  shift = (col & ((MAX_CTB_SIZE >> log2_ctb_size) - 1)) << (log2_ctb_size - 1);

             *  which will reduce to the following assuming ctb size is one of 16, 32 and 64

             *  and deblocking is done on 8x8 grid

             */

            if(6 != log2_ctb_size)

                shift = (col & 1) << (log2_ctb_size - 1);

            /* BS for the column - Last row is excluded and the top row is included*/

            u4_bs = (pu4_vert_bs[0] >> shift) << 2;

            if(ps_deblk->i4_ctb_y || i4_is_last_ctb_y)

            {

                /* Picking the last BS of the previous CTB corresponding to the same column */

                UWORD32 *pu4_vert_bs_top = (UWORD32 *)((UWORD8 *)pu4_vert_bs - bs_strd);

                UWORD32 u4_top_bs = (*pu4_vert_bs_top) >> (shift + (1 << (log2_ctb_size - 1)) - 2);

                u4_bs |= u4_top_bs & 3;

            }

            for(row = 0; row < ctb_size / 4;)

            {

                WORD8 i1_beta_offset_div2 = ps_slice_hdr->i1_beta_offset_div2;

                WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2;

                /* Trailing zeros are computed and the corresponding rows are not processed */

                bs_tz = CTZ(u4_bs) >> 1;

                if(0 != bs_tz)

                {

                    u4_bs = u4_bs >> (bs_tz << 1);

                    if((row + bs_tz) >= (ctb_size / 4))

                        pu1_src += 4 * (ctb_size / 4 - row) * src_strd;

                    else

                        pu1_src += 4 * bs_tz  * src_strd;

                    row += bs_tz;

                    continue;

                }

                if(0 == row)

                {

                    i1_beta_offset_div2 = ps_slice_hdr_top->i1_beta_offset_div2;

                    i1_tc_offset_div2 = ps_slice_hdr_top->i1_tc_offset_div2;

                    if(0 == col)

                    {

                        qp_p = u4_qp_const_in_ctb[0] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] :

                                        pu1_qp[-qp_strd - 1];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[1] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd] :

                                        pu1_qp[col - 1 - qp_strd];

                    }

                    qp_q = u4_qp_const_in_ctb[1] ?

                                    pu1_qp[-ctb_size / 8 * qp_strd] :

                                    pu1_qp[col - qp_strd];

                }

                else

                {

                    if(0 == col)

                    {

                        qp_p = u4_qp_const_in_ctb[2] ?

                                        pu1_qp[-ctb_size / 8] :

                                        pu1_qp[((row - 1) >> 1) * qp_strd - 1];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[3] ?

                                        pu1_qp[0] :

                                        pu1_qp[((row - 1) >> 1) * qp_strd + col - 1];

                    }

                    qp_q = u4_qp_const_in_ctb[3] ?

                                    pu1_qp[0] :

                                    pu1_qp[((row - 1) >> 1) * qp_strd + col];

                }

                filter_p = (pu2_ctb_no_loop_filter_flag[(row + 1) >> 1] >> col) & 1;

                filter_q = (pu2_ctb_no_loop_filter_flag[(row + 1) >> 1] >> col) & 2;

                /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */

                filter_p = !filter_p;

                filter_q = !filter_q;

                if(filter_p || filter_q)

                {

                    DUMP_DEBLK_LUMA_VERT(pu1_src, src_strd,

                                         u4_bs & 3, qp_p, qp_q,

                                         ps_slice_hdr->i1_beta_offset_div2,

                                         ps_slice_hdr->i1_tc_offset_div2,

                                         filter_p, filter_q);

                    ps_codec->s_func_selector.ihevc_deblk_luma_vert_fptr(pu1_src, src_strd,

                                                                         u4_bs & 3, qp_p, qp_q,

                                                                         i1_beta_offset_div2,

                                                                         i1_tc_offset_div2,

                                                                         filter_p, filter_q);

                }

                pu1_src += 4 * src_strd;

                u4_bs = u4_bs >> 2;

                row++;

            }

            if((64 == ctb_size) ||

                            ((32 == ctb_size) && (col & 1)))

            {

                pu4_vert_bs++;

            }

            pu1_src -= (src_strd << log2_ctb_size);

            pu1_src += 8;

        }

        pu4_vert_bs = pu4_ctb_vert_bs;

    }

    /* Luma Horizontal Edge */

    if(0 == i4_is_last_ctb_y)

    {

        /* Left CTB's slice header */

        slice_header_t *ps_slice_hdr_left;

        {

            WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb;

            if(i4_is_last_ctb_x)

                cur_ctb_indx += 1;

            ps_slice_hdr_left = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - 1];

        }

        pu1_src = ps_deblk->pu1_cur_pic_luma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd) << log2_ctb_size);

        pu1_src += i4_is_last_ctb_x ? ctb_size : 0;

        /** Deblocking is done on a shifted CTB -

         *  Horizontal edge processing is done by shifting the CTB left by four pixels */

        pu1_src -= 4;

        for(row = 0; row < ctb_size / 8; row++)

        {

            WORD32 shift = 0;

            /* downshift vert_bs by ctb_size/2 for each column

             *  shift = (row & (MAX_CTB_SIZE / ctb_size - 1)) * ctb_size / 2;

             *  which will reduce to the following assuming ctb size is one of 16, 32 and 64

             *  and deblocking is done on 8x8 grid

             */

            if(6 != log2_ctb_size)

                shift = (row & 1) << (log2_ctb_size - 1);

            /* BS for the row - Last column is excluded and the left column is included*/

            u4_bs = (pu4_horz_bs[0] >> shift) << 2;

            if(ps_deblk->i4_ctb_x || i4_is_last_ctb_x)

            {

                /** Picking the last BS of the previous CTB corresponding to the same row

                * UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (ctb_size / 8) * (ctb_size / 4) / 8 * 2);

                */

                UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (1 << (2 * log2_ctb_size - 7)));

                UWORD32 u4_left_bs = (*pu4_horz_bs_left) >> (shift + (1 << (log2_ctb_size - 1)) - 2);

                u4_bs |= u4_left_bs & 3;

            }

            for(col = 0; col < ctb_size / 4;)

            {

                WORD8 i1_beta_offset_div2 = ps_slice_hdr->i1_beta_offset_div2;

                WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2;

                bs_tz = CTZ(u4_bs) >> 1;

                if(0 != bs_tz)

                {

                    u4_bs = u4_bs >> (bs_tz << 1);

                    if((col + bs_tz) >= (ctb_size / 4))

                        pu1_src += 4 * (ctb_size / 4 - col);

                    else

                        pu1_src += 4 * bs_tz;

                    col += bs_tz;

                    continue;

                }

                if(0 == col)

                {

                    i1_beta_offset_div2 = ps_slice_hdr_left->i1_beta_offset_div2;

                    i1_tc_offset_div2 = ps_slice_hdr_left->i1_tc_offset_div2;

                    if(0 == row)

                    {

                        qp_p = u4_qp_const_in_ctb[0] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] :

                                        pu1_qp[-qp_strd - 1];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[2] ?

                                        pu1_qp[-ctb_size / 8] :

                                        pu1_qp[(row - 1) * qp_strd - 1];

                    }

                    qp_q = u4_qp_const_in_ctb[2] ?

                                    pu1_qp[-ctb_size / 8] :

                                    pu1_qp[row * qp_strd - 1];

                }

                else

                {

                    if(0 == row)

                    {

                        qp_p = u4_qp_const_in_ctb[1] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd] :

                                        pu1_qp[((col - 1) >> 1) - qp_strd];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[3] ?

                                        pu1_qp[0] :

                                        pu1_qp[((col - 1) >> 1) + (row - 1) * qp_strd];

                    }

                    qp_q = u4_qp_const_in_ctb[3] ?

                                    pu1_qp[0] :

                                    pu1_qp[((col - 1) >> 1) + row * qp_strd];

                }

                filter_p = (pu2_ctb_no_loop_filter_flag[row] >> ((col + 1) >> 1)) & 1;

                filter_q = (pu2_ctb_no_loop_filter_flag[row + 1] >> ((col + 1) >> 1)) & 1;

                /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */

                filter_p = !filter_p;

                filter_q = !filter_q;

                if(filter_p || filter_q)

                {

                    DUMP_DEBLK_LUMA_HORZ(pu1_src, src_strd,

                                         u4_bs & 3, qp_p, qp_q,

                                         ps_slice_hdr->i1_beta_offset_div2,

                                         ps_slice_hdr->i1_tc_offset_div2,

                                         filter_p, filter_q);

                    ps_codec->s_func_selector.ihevc_deblk_luma_horz_fptr(pu1_src, src_strd,

                                                                         u4_bs & 3, qp_p, qp_q,

                                                                         i1_beta_offset_div2,

                                                                         i1_tc_offset_div2, filter_p, filter_q);

                }

                pu1_src += 4;

                u4_bs = u4_bs >> 2;

                col++;

            }

            if((64 == ctb_size) ||

                            ((32 == ctb_size) && (row & 1)))

            {

                pu4_horz_bs++;

            }

            pu1_src -= ctb_size;

            pu1_src += (src_strd << 3);

        }

        pu4_horz_bs = pu4_ctb_horz_bs;

    }

    /* Chroma Veritcal Edge */

    if(CHROMA_FMT_IDC_MONOCHROME != ps_sps->i1_chroma_format_idc && 0 == i4_is_last_ctb_x)

    {

        /* Top CTB's slice header */

        slice_header_t *ps_slice_hdr_top;

        {

            WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb;

            if(i4_is_last_ctb_y)

                cur_ctb_indx += ps_sps->i2_pic_wd_in_ctb;

            ps_slice_hdr_top = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - ps_sps->i2_pic_wd_in_ctb];

        }

        pu1_src = ps_deblk->pu1_cur_pic_chroma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd / 2) << log2_ctb_size);

        pu1_src += i4_is_last_ctb_y ? (ps_deblk->ps_codec->i4_strd / 2) << log2_ctb_size : 0;

        /** Deblocking is done on a shifted CTB -

         *  Vertical edge processing is done by shifting the CTB up by four pixels */

        pu1_src -= 4 * src_strd;

        for(col = 0; col < ctb_size / 16; col++)

        {

            /* BS for the column - Last row is excluded and the top row is included*/

            u4_bs = pu4_vert_bs[0] << 2;

            if(ps_deblk->i4_ctb_y || i4_is_last_ctb_y)

            {

                /* Picking the last BS of the previous CTB corresponding to the same column */

                UWORD32 *pu4_vert_bs_top = (UWORD32 *)((UWORD8 *)pu4_vert_bs - bs_strd);

                UWORD32 u4_top_bs = (*pu4_vert_bs_top) >> ((1 << (log2_ctb_size - 1)) - 2);

                u4_bs |= u4_top_bs & 3;

            }

            /* Every alternate boundary strength value is used for chroma */

            u4_bs &= 0x22222222;

            for(row = 0; row < ctb_size / 8;)

            {

                WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2;

                bs_tz = CTZ(u4_bs) >> 2;

                if(0 != bs_tz)

                {

                    if((row + bs_tz) >= (ctb_size / 8))

                        pu1_src += 4 * (ctb_size / 8 - row) * src_strd;

                    else

                        pu1_src += 4 * bs_tz  * src_strd;

                    row += bs_tz;

                    u4_bs = u4_bs >> (bs_tz << 2);

                    continue;

                }

                if(0 == row)

                {

                    i1_tc_offset_div2 = ps_slice_hdr_top->i1_tc_offset_div2;

                    if(0 == col)

                    {

                        qp_p = u4_qp_const_in_ctb[0] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] :

                                        pu1_qp[-qp_strd - 1];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[1] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd] :

                                        pu1_qp[2 * col - 1 - qp_strd];

                    }

                    qp_q = u4_qp_const_in_ctb[1] ?

                                    pu1_qp[-ctb_size / 8 * qp_strd] :

                                    pu1_qp[2 * col - qp_strd];

                }

                else

                {

                    if(0 == col)

                    {

                        qp_p = u4_qp_const_in_ctb[2] ?

                                        pu1_qp[-ctb_size / 8] :

                                        pu1_qp[(row - 1) * qp_strd - 1];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[3] ?

                                        pu1_qp[0] :

                                        pu1_qp[(row - 1) * qp_strd + 2 * col - 1];

                    }

                    qp_q = u4_qp_const_in_ctb[3] ?

                                    pu1_qp[0] :

                                    pu1_qp[(row - 1) * qp_strd + 2 * col];

                }

                filter_p = (pu2_ctb_no_loop_filter_flag[row] >> (col << 1)) & 1;

                filter_q = (pu2_ctb_no_loop_filter_flag[row] >> (col << 1)) & 2;

                /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */

                filter_p = !filter_p;

                filter_q = !filter_q;

                if(filter_p || filter_q)

                {

                    ASSERT(1 == ((u4_bs & 3) >> 1));

                    DUMP_DEBLK_CHROMA_VERT(pu1_src, src_strd,

                                           u4_bs & 3, qp_p, qp_q,

                                           ps_pps->i1_pic_cb_qp_offset,

                                           ps_pps->i1_pic_cr_qp_offset,

                                           ps_slice_hdr->i1_tc_offset_div2,

                                           filter_p, filter_q);

                    if(chroma_yuv420sp_vu)

                    {

                        ps_codec->s_func_selector.ihevc_deblk_chroma_vert_fptr(pu1_src,

                                                                               src_strd,

                                                                               qp_q,

                                                                               qp_p,

                                                                               ps_pps->i1_pic_cr_qp_offset,

                                                                               ps_pps->i1_pic_cb_qp_offset,

                                                                               i1_tc_offset_div2,

                                                                               filter_q,

                                                                               filter_p);

                    }

                    else

                    {

                        ps_codec->s_func_selector.ihevc_deblk_chroma_vert_fptr(pu1_src,

                                                                               src_strd,

                                                                               qp_p,

                                                                               qp_q,

                                                                               ps_pps->i1_pic_cb_qp_offset,

                                                                               ps_pps->i1_pic_cr_qp_offset,

                                                                               i1_tc_offset_div2,

                                                                               filter_p,

                                                                               filter_q);

                    }

                }

                pu1_src += 4 * src_strd;

                u4_bs = u4_bs >> 4;

                row++;

            }

            pu4_vert_bs += (64 == ctb_size) ? 2 : 1;

            pu1_src -= ((src_strd / 2) << log2_ctb_size);

            pu1_src += 16;

        }

    }

    /* Chroma Horizontal Edge */

    if(CHROMA_FMT_IDC_MONOCHROME != ps_sps->i1_chroma_format_idc && 0 == i4_is_last_ctb_y)

    {

        /* Left CTB's slice header */

        slice_header_t *ps_slice_hdr_left;

        {

            WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb;

            if(i4_is_last_ctb_x)

                cur_ctb_indx += 1;

            ps_slice_hdr_left = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - 1];

        }

        pu1_src = ps_deblk->pu1_cur_pic_chroma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd / 2) << log2_ctb_size);

        pu1_src += i4_is_last_ctb_x ? ctb_size : 0;

        /** Deblocking is done on a shifted CTB -

         * Vertical edge processing is done by shifting the CTB up by four pixels (8 here beacuse UV are interleaved) */

        pu1_src -= 8;

        for(row = 0; row < ctb_size / 16; row++)

        {

            /* BS for the row - Last column is excluded and the left column is included*/

            u4_bs = pu4_horz_bs[0] << 2;

            if(ps_deblk->i4_ctb_x || i4_is_last_ctb_x)

            {

                /** Picking the last BS of the previous CTB corresponding to the same row

                * UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (ctb_size / 8) * (ctb_size / 4) / 8 * 2);

                */

                UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (1 << (2 * log2_ctb_size - 7)));

                UWORD32 u4_left_bs = (*pu4_horz_bs_left) >> ((1 << (log2_ctb_size - 1)) - 2);

                u4_bs |= u4_left_bs & 3;

            }

            /* Every alternate boundary strength value is used for chroma */

            u4_bs &= 0x22222222;

            for(col = 0; col < ctb_size / 8;)

            {

                WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2;

                bs_tz = CTZ(u4_bs) >> 2;

                if(0 != bs_tz)

                {

                    u4_bs = u4_bs >> (bs_tz << 2);

                    if((col + bs_tz) >= (ctb_size / 8))

                        pu1_src += 8 * (ctb_size / 8 - col);

                    else

                        pu1_src += 8 * bs_tz;

                    col += bs_tz;

                    continue;

                }

                if(0 == col)

                {

                    i1_tc_offset_div2 = ps_slice_hdr_left->i1_tc_offset_div2;

                    if(0 == row)

                    {

                        qp_p = u4_qp_const_in_ctb[0] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] :

                                        pu1_qp[-qp_strd - 1];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[2] ?

                                        pu1_qp[-ctb_size / 8] :

                                        pu1_qp[(2 * row - 1) * qp_strd - 1];

                    }

                    qp_q = u4_qp_const_in_ctb[2] ?

                                    pu1_qp[-ctb_size / 8] :

                                    pu1_qp[(2 * row) * qp_strd - 1];

                }

                else

                {

                    if(0 == row)

                    {

                        qp_p = u4_qp_const_in_ctb[1] ?

                                        pu1_qp[-ctb_size / 8 * qp_strd] :

                                        pu1_qp[col - 1 - qp_strd];

                    }

                    else

                    {

                        qp_p = u4_qp_const_in_ctb[3] ?

                                        pu1_qp[0] :

                                        pu1_qp[(col - 1) +  (2 * row - 1) * qp_strd];

                    }

                    qp_q = u4_qp_const_in_ctb[3] ?

                                    pu1_qp[0] :

                                    pu1_qp[(col - 1) + 2 * row * qp_strd];

                }

                filter_p = (pu2_ctb_no_loop_filter_flag[row << 1] >> col) & 1;

                filter_q = (pu2_ctb_no_loop_filter_flag[(row << 1) + 1] >> col) & 1;

                /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */

                filter_p = !filter_p;

                filter_q = !filter_q;

                if(filter_p || filter_q)

                {

                    ASSERT(1 == ((u4_bs & 3) >> 1));

                    DUMP_DEBLK_CHROMA_HORZ(pu1_src, src_strd,

                                           u4_bs & 3, qp_p, qp_q,

                                           ps_pps->i1_pic_cb_qp_offset,

                                           ps_pps->i1_pic_cr_qp_offset,

                                           ps_slice_hdr->i1_tc_offset_div2,

                                           filter_p, filter_q);

                    if(chroma_yuv420sp_vu)

                    {

                        ps_codec->s_func_selector.ihevc_deblk_chroma_horz_fptr(pu1_src,

                                                                               src_strd,

                                                                               qp_q,

                                                                               qp_p,

                                                                               ps_pps->i1_pic_cr_qp_offset,

                                                                               ps_pps->i1_pic_cb_qp_offset,

                                                                               i1_tc_offset_div2,

                                                                               filter_q,

                                                                               filter_p);

                    }

                    else

                    {

                        ps_codec->s_func_selector.ihevc_deblk_chroma_horz_fptr(pu1_src,

                                                                               src_strd,

                                                                               qp_p,

                                                                               qp_q,

                                                                               ps_pps->i1_pic_cb_qp_offset,

                                                                               ps_pps->i1_pic_cr_qp_offset,

                                                                               i1_tc_offset_div2,

                                                                               filter_p,

                                                                               filter_q);

                    }

                }

                pu1_src += 8;

                u4_bs = u4_bs >> 4;

                col++;

            }

            pu4_horz_bs += (64 == ctb_size) ? 2 : 1;

            pu1_src -= ctb_size;

            pu1_src += 8 * src_strd;

        }

    }

}