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

 *

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

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

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

/**

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

* @file

*  ihevce_sao.c

*

* @brief

*  Contains definition for the ctb level sao function

*

* @author

*  Ittiam

*

* @par List of Functions:

*  ihevce_sao_set_avilability()

*  ihevce_sao_ctb()

*  ihevce_sao_analyse()

*

* @remarks

*  None

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

/* User include files */

#include "ihevc_typedefs.h"

#include "itt_video_api.h"

#include "ihevce_api.h"

#include "rc_cntrl_param.h"

#include "rc_frame_info_collector.h"

#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"

#include "ihevc_structs.h"

#include "ihevc_platform_macros.h"

#include "ihevc_deblk.h"

#include "ihevc_itrans_recon.h"

#include "ihevc_chroma_itrans_recon.h"

#include "ihevc_chroma_intra_pred.h"

#include "ihevc_intra_pred.h"

#include "ihevc_inter_pred.h"

#include "ihevc_mem_fns.h"

#include "ihevc_padding.h"

#include "ihevc_weighted_pred.h"

#include "ihevc_sao.h"

#include "ihevc_resi_trans.h"

#include "ihevc_quant_iquant_ssd.h"

#include "ihevc_cabac_tables.h"

#include "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_had_satd.h"

#include "ihevce_error_codes.h"

#include "ihevce_bitstream.h"

#include "ihevce_cabac.h"

#include "ihevce_rdoq_macros.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_entropy_structs.h"

#include "ihevce_cmn_utils_instr_set_router.h"

#include "ihevce_enc_loop_structs.h"

#include "ihevce_cabac_rdo.h"

#include "ihevce_sao.h"

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

/* Function Definitions                                                      */

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

/**

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

*

* @brief

*     ihevce_sao_set_avilability

*

* @par Description:

*     Sets the availability flag for SAO.

*

* @param[in]

*   ps_sao_ctxt:   Pointer to SAO context

* @returns

*

* @remarks

*  None

*

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

*/

void ihevce_sao_set_avilability(

    UWORD8 *pu1_avail, sao_ctxt_t *ps_sao_ctxt, ihevce_tile_params_t *ps_tile_params)

{

    WORD32 i;

    WORD32 ctb_x_pos = ps_sao_ctxt->i4_ctb_x;

    WORD32 ctb_y_pos = ps_sao_ctxt->i4_ctb_y;

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

    {

        pu1_avail[i] = 255;

    }

    /* SAO_note_01: If the CTB lies on a tile or a slice boundary and

    in-loop filtering is enabled at tile and slice boundary, then SAO must

    be performed at tile/slice boundaries also.

    Hence the boundary checks should be based on frame position of CTB

    rather than s_ctb_nbr_avail_flags.u1_left_avail flags.

    Search for <SAO_note_01> in workspace to know more */

    /* Availaibility flags for first col*/

    if(ctb_x_pos == ps_tile_params->i4_first_ctb_x)

    {

        pu1_avail[0] = 0;

        pu1_avail[4] = 0;

        pu1_avail[6] = 0;

    }

    /* Availaibility flags for last col*/

    if((ctb_x_pos + 1) ==

       (ps_tile_params->i4_first_ctb_x + ps_tile_params->i4_curr_tile_wd_in_ctb_unit))

    {

        pu1_avail[1] = 0;

        pu1_avail[5] = 0;

        pu1_avail[7] = 0;

    }

    /* Availaibility flags for first row*/

    if(ctb_y_pos == ps_tile_params->i4_first_ctb_y)

    {

        pu1_avail[2] = 0;

        pu1_avail[4] = 0;

        pu1_avail[5] = 0;

    }

    /* Availaibility flags for last row*/

    if((ctb_y_pos + 1) ==

       (ps_tile_params->i4_first_ctb_y + ps_tile_params->i4_curr_tile_ht_in_ctb_unit))

    {

        pu1_avail[3] = 0;

        pu1_avail[6] = 0;

        pu1_avail[7] = 0;

    }

}

/**

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

*

* @brief

*   Sao CTB level function.

*

* @par Description:

*   For a given CTB, sao is done. Both the luma and chroma

*   blocks are processed

*

* @param[in]

*   ps_sao_ctxt:   Pointer to SAO context

*

* @returns

*

* @remarks

*  None

*

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

*/

void ihevce_sao_ctb(sao_ctxt_t *ps_sao_ctxt, ihevce_tile_params_t *ps_tile_params)

{

    sao_enc_t *ps_sao;

    UWORD8 u1_src_top_left_luma, u1_src_top_left_chroma[2];

    UWORD8 *pu1_src_left_luma_buf, *pu1_src_top_luma_buf;

    UWORD8 *pu1_src_left_chroma_buf, *pu1_src_top_chroma_buf;

    UWORD8 *pu1_src_luma, *pu1_src_chroma;

    WORD32 luma_src_stride, ctb_size;

    WORD32 chroma_src_stride;

    UWORD8 au1_avail_luma[8], au1_avail_chroma[8];

    WORD32 sao_blk_wd, sao_blk_ht, sao_wd_chroma, sao_ht_chroma;

    UWORD8 *pu1_top_left_luma, *pu1_top_left_chroma;

    UWORD8 *pu1_src_bot_left_luma, *pu1_src_top_right_luma;

    UWORD8 *pu1_src_bot_left_chroma, *pu1_src_top_right_chroma;

    UWORD8 u1_is_422 = (ps_sao_ctxt->ps_sps->i1_chroma_format_idc == 2);

    ps_sao = ps_sao_ctxt->ps_sao;

    ASSERT(

        (abs(ps_sao->u1_y_offset[1]) <= 7) && (abs(ps_sao->u1_y_offset[2]) <= 7) &&

        (abs(ps_sao->u1_y_offset[3]) <= 7) && (abs(ps_sao->u1_y_offset[4]) <= 7));

    ASSERT(

        (abs(ps_sao->u1_cb_offset[1]) <= 7) && (abs(ps_sao->u1_cb_offset[2]) <= 7) &&

        (abs(ps_sao->u1_cb_offset[3]) <= 7) && (abs(ps_sao->u1_cb_offset[4]) <= 7));

    ASSERT(

        (abs(ps_sao->u1_cr_offset[1]) <= 7) && (abs(ps_sao->u1_cr_offset[2]) <= 7) &&

        (abs(ps_sao->u1_cr_offset[3]) <= 7) && (abs(ps_sao->u1_cr_offset[4]) <= 7));

    ASSERT(

        (ps_sao->b5_y_band_pos <= 28) && (ps_sao->b5_cb_band_pos <= 28) &&

        (ps_sao->b5_cr_band_pos <= 28));

    if(ps_sao_ctxt->i1_slice_sao_luma_flag)

    {

        /*initialize the src pointer to current row*/

        luma_src_stride = ps_sao_ctxt->i4_cur_luma_recon_stride;

        ctb_size = ps_sao_ctxt->i4_ctb_size;

        /* 1 extra byte in top buf stride for top left of 1st ctb of every row*/

        ps_sao->u1_y_offset[0] = 0; /* 0th element is not being used  */

        sao_blk_wd = ps_sao_ctxt->i4_sao_blk_wd;

        sao_blk_ht = ps_sao_ctxt->i4_sao_blk_ht;

        pu1_src_luma = ps_sao_ctxt->pu1_cur_luma_recon_buf;

        /* Pointer to the top luma buffer corresponding to the current ctb row*/

        pu1_src_top_luma_buf = ps_sao_ctxt->pu1_curr_sao_src_top_luma;

        /* Pointer to left luma buffer corresponding to the current ctb row*/

        pu1_src_left_luma_buf = ps_sao_ctxt->au1_left_luma_scratch;

        /* Pointer to the top right luma buffer corresponding to the current ctb row*/

        pu1_src_top_right_luma = pu1_src_top_luma_buf /*- top_buf_stide*/ + sao_blk_wd;

        /* Pointer to the bottom left luma buffer corresponding to the current ctb row*/

        pu1_src_bot_left_luma =

            ps_sao_ctxt->pu1_frm_luma_recon_buf + ctb_size * ps_sao_ctxt->i4_frm_luma_recon_stride -

            1 + (ps_sao_ctxt->i4_frm_luma_recon_stride * ps_sao_ctxt->i4_ctb_y * ctb_size) +

            (ps_sao_ctxt->i4_ctb_x * ctb_size); /* Bottom left*/

        /* Back up the top left pixel for (x+1, y+1)th ctb*/

        u1_src_top_left_luma = *(pu1_src_top_luma_buf + sao_blk_wd - 1);

        pu1_top_left_luma = pu1_src_top_luma_buf - 1;

        if(SAO_BAND == ps_sao->b3_y_type_idx)

        {

            ihevc_sao_band_offset_luma(

                pu1_src_luma,

                luma_src_stride,

                pu1_src_left_luma_buf, /* Pass the pointer to the left luma buffer backed up in the (x-1,y)th ctb */

                pu1_src_top_luma_buf, /* Pass the ptr to the top luma buf backed up in the (x,y-1)th ctb */

                pu1_src_top_luma_buf - 1, /* Top left*/

                ps_sao->b5_y_band_pos,

                ps_sao->u1_y_offset,

                sao_blk_wd,

                sao_blk_ht);

            if((ps_sao_ctxt->i4_ctb_y > 0))

            {

                *(pu1_src_top_luma_buf + sao_blk_wd - 1) = u1_src_top_left_luma;

            }

        }

        else if(ps_sao->b3_y_type_idx >= SAO_EDGE_0_DEG)

        {

            /*In case of edge offset, 1st and 2nd offsets are always inferred as offsets

            * corresponding to EO category 1 and 2 which should be always positive

            * And 3rd and 4th offsets are always inferred as offsets corresponding to

            * EO category 3 and 4 which should be negative for all the EO classes(or EO typeidx)

            */

            // clang-format off

            ASSERT((ps_sao->u1_y_offset[1] >= 0) && (ps_sao->u1_y_offset[2] >= 0));

            ASSERT((ps_sao->u1_y_offset[3] <= 0) && (ps_sao->u1_y_offset[4] <= 0));

            // clang-format on

            ihevce_sao_set_avilability(au1_avail_luma, ps_sao_ctxt, ps_tile_params);

            ps_sao_ctxt->apf_sao_luma[ps_sao->b3_y_type_idx - 2](

                pu1_src_luma,

                luma_src_stride,

                pu1_src_left_luma_buf, /* Pass the pointer to the left luma buffer backed up in the (x-1,y)th ctb */

                pu1_src_top_luma_buf, /* Pass the ptr to the top luma buf backed up in the (x,y-1)th ctb */

                pu1_top_left_luma, /* Top left*/

                pu1_src_top_right_luma, /* Top right*/

                pu1_src_bot_left_luma, /* Bottom left*/

                au1_avail_luma,

                ps_sao->u1_y_offset,

                sao_blk_wd,

                sao_blk_ht);

            if((ps_sao_ctxt->i4_ctb_y > 0))

            {

                *(pu1_src_top_luma_buf + sao_blk_wd - 1) = u1_src_top_left_luma;

            }

        }

    }

    if(ps_sao_ctxt->i1_slice_sao_chroma_flag)

    {

        /*initialize the src pointer to current row*/

        chroma_src_stride = ps_sao_ctxt->i4_cur_chroma_recon_stride;

        ctb_size = ps_sao_ctxt->i4_ctb_size;

        /* 1 extra byte in top buf stride for top left of 1st ctb of every row*/

        //top_buf_stide = ps_sao_ctxt->u4_ctb_aligned_wd + 2;

        ps_sao->u1_cb_offset[0] = 0; /* 0th element is not used  */

        ps_sao->u1_cr_offset[0] = 0;

        sao_wd_chroma = ps_sao_ctxt->i4_sao_blk_wd;

        sao_ht_chroma = ps_sao_ctxt->i4_sao_blk_ht / (!u1_is_422 + 1);

        pu1_src_chroma = ps_sao_ctxt->pu1_cur_chroma_recon_buf;

        /* Pointer to the top luma buffer corresponding to the current ctb row*/

        pu1_src_top_chroma_buf = ps_sao_ctxt->pu1_curr_sao_src_top_chroma;

        // clang-format off

        /* Pointer to left luma buffer corresponding to the current ctb row*/

        pu1_src_left_chroma_buf = ps_sao_ctxt->au1_left_chroma_scratch;  //ps_sao_ctxt->au1_sao_src_left_chroma;

        // clang-format on

        /* Pointer to the top right chroma buffer corresponding to the current ctb row*/

        pu1_src_top_right_chroma = pu1_src_top_chroma_buf /*- top_buf_stide*/ + sao_wd_chroma;

        /* Pointer to the bottom left luma buffer corresponding to the current ctb row*/

        pu1_src_bot_left_chroma =

            ps_sao_ctxt->pu1_frm_chroma_recon_buf +

            (ctb_size >> !u1_is_422) * ps_sao_ctxt->i4_frm_chroma_recon_stride - 2 +

            (ps_sao_ctxt->i4_frm_chroma_recon_stride * ps_sao_ctxt->i4_ctb_y *

             (ctb_size >> !u1_is_422)) +

            (ps_sao_ctxt->i4_ctb_x * ctb_size); /* Bottom left*/

        /* Back up the top left pixel for (x+1, y+1)th ctb*/

        u1_src_top_left_chroma[0] = *(pu1_src_top_chroma_buf + sao_wd_chroma - 2);

        u1_src_top_left_chroma[1] = *(pu1_src_top_chroma_buf + sao_wd_chroma - 1);

        pu1_top_left_chroma = pu1_src_top_chroma_buf - 2;

        if(SAO_BAND == ps_sao->b3_cb_type_idx)

        {

            ihevc_sao_band_offset_chroma(

                pu1_src_chroma,

                chroma_src_stride,

                pu1_src_left_chroma_buf, /* Pass the pointer to the left luma buffer backed up in the (x-1,y)th ctb */

                pu1_src_top_chroma_buf, /* Pass the ptr to the top luma buf backed up in the (x,y-1)th ctb */

                pu1_top_left_chroma, /* Top left*/

                ps_sao->b5_cb_band_pos,

                ps_sao->b5_cr_band_pos,

                ps_sao->u1_cb_offset,

                ps_sao->u1_cr_offset,

                sao_wd_chroma,

                sao_ht_chroma);

            if((ps_sao_ctxt->i4_ctb_y > 0))

            {

                *(pu1_src_top_chroma_buf + sao_wd_chroma - 2) = u1_src_top_left_chroma[0];

                *(pu1_src_top_chroma_buf + sao_wd_chroma - 1) = u1_src_top_left_chroma[1];

            }

        }

        else if(ps_sao->b3_cb_type_idx >= SAO_EDGE_0_DEG)

        {

            /*In case of edge offset, 1st and 2nd offsets are always inferred as offsets

            * corresponding to EO category 1 and 2 which should be always positive

            * And 3rd and 4th offsets are always inferred as offsets corresponding to

            * EO category 3 and 4 which should be negative for all the EO classes(or EO typeidx)

            */

            ASSERT((ps_sao->u1_cb_offset[1] >= 0) && (ps_sao->u1_cb_offset[2] >= 0));

            ASSERT((ps_sao->u1_cb_offset[3] <= 0) && (ps_sao->u1_cb_offset[4] <= 0));

            ASSERT((ps_sao->u1_cr_offset[1] >= 0) && (ps_sao->u1_cr_offset[2] >= 0));

            ASSERT((ps_sao->u1_cr_offset[3] <= 0) && (ps_sao->u1_cr_offset[4] <= 0));

            ihevce_sao_set_avilability(au1_avail_chroma, ps_sao_ctxt, ps_tile_params);

            ps_sao_ctxt->apf_sao_chroma[ps_sao->b3_cb_type_idx - 2](

                pu1_src_chroma,

                chroma_src_stride,

                pu1_src_left_chroma_buf, /* Pass the pointer to the left luma buffer backed up in the (x-1,y)th ctb */

                pu1_src_top_chroma_buf, /* Pass the ptr to the top luma buf backed up in the (x,y-1)th ctb */

                pu1_top_left_chroma, /* Top left*/

                pu1_src_top_right_chroma, /* Top right*/

                pu1_src_bot_left_chroma, /* Bottom left*/

                au1_avail_chroma,

                ps_sao->u1_cb_offset,

                ps_sao->u1_cr_offset,

                sao_wd_chroma,

                sao_ht_chroma);

            if((ps_sao_ctxt->i4_ctb_y > 0))

            {

                *(pu1_src_top_chroma_buf + sao_wd_chroma - 2) = u1_src_top_left_chroma[0];

                *(pu1_src_top_chroma_buf + sao_wd_chroma - 1) = u1_src_top_left_chroma[1];

            }

        }

    }

}

/**

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

*

* @brief

*   CTB level function to do SAO analysis.

*

* @par Description:

*   For a given CTB, sao analysis is done for both luma and chroma.

*

*

* @param[in]

*   ps_sao_ctxt:   Pointer to SAO context

*   ps_ctb_enc_loop_out : pointer to ctb level output structure from enc loop

*

* @returns

*

* @remarks

*  None

*

* @Assumptions:

*   1) Initial Cabac state for current ctb to be sao'ed (i.e (x-1,y-1)th ctb) is assumed to be

*      almost same as cabac state of (x,y)th ctb.

*   2) Distortion is calculated in spatial domain but lamda used to calculate the cost is

*      in freq domain.

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

*/

void ihevce_sao_analyse(

    sao_ctxt_t *ps_sao_ctxt,

    ctb_enc_loop_out_t *ps_ctb_enc_loop_out,

    UWORD32 *pu4_frame_rdopt_header_bits,

    ihevce_tile_params_t *ps_tile_params)

{

    UWORD8 *pu1_luma_scratch_buf;

    UWORD8 *pu1_chroma_scratch_buf;

    UWORD8 *pu1_src_luma, *pu1_recon_luma;

    UWORD8 *pu1_src_chroma, *pu1_recon_chroma;

    WORD32 luma_src_stride, luma_recon_stride, ctb_size, ctb_wd, ctb_ht;

    WORD32 chroma_src_stride, chroma_recon_stride;

    WORD32 i4_luma_scratch_buf_stride;

    WORD32 i4_chroma_scratch_buf_stride;

    sao_ctxt_t s_sao_ctxt;

    UWORD32 ctb_bits = 0, distortion = 0, curr_cost = 0, best_cost = 0;

    LWORD64 i8_cl_ssd_lambda_qf, i8_cl_ssd_lambda_chroma_qf;

    WORD32 rdo_cand, num_luma_rdo_cand = 0, num_rdo_cand = 0;

    WORD32 curr_buf_idx, best_buf_idx, best_cand_idx;

    WORD32 row;

    WORD32 edgeidx;

    WORD32 acc_error_category[5] = { 0, 0, 0, 0, 0 }, category_count[5] = { 0, 0, 0, 0, 0 };

    sao_enc_t s_best_luma_chroma_cand;

    WORD32 best_ctb_sao_bits = 0;

#if DISABLE_SAO_WHEN_NOISY && !defined(ENC_VER_v2)

    UWORD8 u1_force_no_offset =

        ps_sao_ctxt

            ->ps_ctb_data

                [ps_sao_ctxt->i4_ctb_x + ps_sao_ctxt->i4_ctb_data_stride * ps_sao_ctxt->i4_ctb_y]

            .s_ctb_noise_params.i4_noise_present;

#endif

    UWORD8 u1_is_422 = (ps_sao_ctxt->ps_sps->i1_chroma_format_idc == 2);

    *pu4_frame_rdopt_header_bits = 0;

    ctb_size = ps_sao_ctxt->i4_ctb_size;

    ctb_wd = ps_sao_ctxt->i4_sao_blk_wd;

    ctb_ht = ps_sao_ctxt->i4_sao_blk_ht;

    s_sao_ctxt = ps_sao_ctxt[0];

    /* Memset the best luma_chroma_cand structure to avoid asserts in debug mode*/

    memset(&s_best_luma_chroma_cand, 0, sizeof(sao_enc_t));

    /* Initialize the pointer and strides for luma buffers*/

    pu1_recon_luma = ps_sao_ctxt->pu1_cur_luma_recon_buf;

    luma_recon_stride = ps_sao_ctxt->i4_cur_luma_recon_stride;

    pu1_src_luma = ps_sao_ctxt->pu1_cur_luma_src_buf;

    luma_src_stride = ps_sao_ctxt->i4_cur_luma_src_stride;

    i4_luma_scratch_buf_stride = SCRATCH_BUF_STRIDE;

    /* Initialize the pointer and strides for luma buffers*/

    pu1_recon_chroma = ps_sao_ctxt->pu1_cur_chroma_recon_buf;

    chroma_recon_stride = ps_sao_ctxt->i4_cur_chroma_recon_stride;

    pu1_src_chroma = ps_sao_ctxt->pu1_cur_chroma_src_buf;

    chroma_src_stride = ps_sao_ctxt->i4_cur_chroma_src_stride;

    i4_chroma_scratch_buf_stride = SCRATCH_BUF_STRIDE;

    i8_cl_ssd_lambda_qf = ps_sao_ctxt->i8_cl_ssd_lambda_qf;

    i8_cl_ssd_lambda_chroma_qf = ps_sao_ctxt->i8_cl_ssd_lambda_chroma_qf;

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

    /********************RDO FOR LUMA CAND****************/

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

#if !DISABLE_SAO_WHEN_NOISY

    if(ps_sao_ctxt->ps_slice_hdr->i1_slice_sao_luma_flag)

#else

    if(ps_sao_ctxt->ps_slice_hdr->i1_slice_sao_luma_flag && !u1_force_no_offset)

#endif

    {

        /* Candidate for Edge offset SAO*/

        /* Following is the convention for curr pixel and

        * two neighbouring pixels for 0 deg, 90 deg, 135 deg and 45 deg */

        /*

        * 0 deg :  a c b     90 deg:  a       135 deg: a          45 deg:     a

        *                             c                  c                  c

        *                             b                    b              b

        */

        /* 0 deg SAO CAND*/

        /* Reset the error and edge count*/

        for(edgeidx = 0; edgeidx < 5; edgeidx++)

        {

            acc_error_category[edgeidx] = 0;

            category_count[edgeidx] = 0;

        }

        /* Call the funciton to populate the EO parameter for this ctb for 0 deg EO class*/

        // clang-format off

        ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_get_luma_eo_sao_params(ps_sao_ctxt, SAO_EDGE_0_DEG,

                acc_error_category, category_count);

        // clang-format on

        // clang-format off

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_y_type_idx = SAO_EDGE_0_DEG;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[1] = category_count[0]

                ? (CLIP3(acc_error_category[0] / category_count[0], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[2] = category_count[1]

                ? (CLIP3(acc_error_category[1] / category_count[1], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[3] = category_count[3]

                ? (CLIP3(acc_error_category[3] / category_count[3], -7, 0))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[4] =category_count[4]

                ? (CLIP3(acc_error_category[4] / category_count[4], -7, 0))

                : 0;

        // clang-format on

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_y_band_pos = 0;

        // clang-format off

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cb_type_idx = SAO_NONE;

        // clang-format on

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cb_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cr_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cr_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_left_flag = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_up_flag = 0;

        num_luma_rdo_cand++;

        /* 90 degree SAO CAND*/

        for(edgeidx = 0; edgeidx < 5; edgeidx++)

        {

            acc_error_category[edgeidx] = 0;

            category_count[edgeidx] = 0;

        }

        /* Call the funciton to populate the EO parameter for this ctb for 90 deg EO class*/

        // clang-format off

        ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_get_luma_eo_sao_params(ps_sao_ctxt, SAO_EDGE_90_DEG,

                acc_error_category, category_count);

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_y_type_idx = SAO_EDGE_90_DEG;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[1] = category_count[0]

                ? (CLIP3(acc_error_category[0] / category_count[0], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[2] = category_count[1]

                ? (CLIP3(acc_error_category[1] / category_count[1], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[3] = category_count[3]

                ? (CLIP3(acc_error_category[3] / category_count[3], -7, 0))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[4] = category_count[4]

                ? (CLIP3(acc_error_category[4] / category_count[4], -7, 0))

                : 0;

        // clang-format on

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_y_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cb_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cb_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cr_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cr_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_left_flag = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_up_flag = 0;

        num_luma_rdo_cand++;

        /* 135 degree SAO CAND*/

        for(edgeidx = 0; edgeidx < 5; edgeidx++)

        {

            acc_error_category[edgeidx] = 0;

            category_count[edgeidx] = 0;

        }

        /* Call the funciton to populate the EO parameter for this ctb for 135 deg EO class*/

        // clang-format off

        ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_get_luma_eo_sao_params(ps_sao_ctxt, SAO_EDGE_135_DEG,

                acc_error_category, category_count);

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_y_type_idx = SAO_EDGE_135_DEG;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[1] = category_count[0]

                ? (CLIP3(acc_error_category[0] / category_count[0], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[2] = category_count[1]

                ? (CLIP3(acc_error_category[1] / category_count[1], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[3] = category_count[3]

                ? (CLIP3(acc_error_category[3] / category_count[3], -7, 0))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[4] = category_count[4]

                ? (CLIP3(acc_error_category[4] / category_count[4], -7, 0))

                : 0;

        // clang-format on

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_y_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cb_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cb_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cr_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cr_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_left_flag = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_up_flag = 0;

        num_luma_rdo_cand++;

        /* 45 degree SAO CAND*/

        for(edgeidx = 0; edgeidx < 5; edgeidx++)

        {

            acc_error_category[edgeidx] = 0;

            category_count[edgeidx] = 0;

        }

        /* Call the funciton to populate the EO parameter for this ctb for 45 deg EO class*/

        // clang-format off

        ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_get_luma_eo_sao_params(ps_sao_ctxt, SAO_EDGE_45_DEG,

                acc_error_category, category_count);

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_y_type_idx = SAO_EDGE_45_DEG;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[1] = category_count[0]

                ? (CLIP3(acc_error_category[0] / category_count[0], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[2] = category_count[1]

                ? (CLIP3(acc_error_category[1] / category_count[1], 0, 7))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[3] = category_count[3]

                ? (CLIP3(acc_error_category[3] / category_count[3], -7, 0))

                : 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_y_offset[4] = category_count[4]

                ? (CLIP3(acc_error_category[4] / category_count[4], -7, 0))

                : 0;

        // clang-format on

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_y_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cb_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cb_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cb_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b3_cr_type_idx = SAO_NONE;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[1] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[2] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[3] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].u1_cr_offset[4] = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b5_cr_band_pos = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_left_flag = 0;

        ps_sao_ctxt->as_sao_rd_cand[num_luma_rdo_cand].b1_sao_merge_up_flag = 0;

        num_luma_rdo_cand++;

        /* First cand will be best cand after 1st iteration*/

        curr_buf_idx = 0;

        best_buf_idx = 1;

        best_cost = 0xFFFFFFFF;

        best_cand_idx = 0;

        /*Back up the top pixels for (x,y+1)th ctb*/

        if(!ps_sao_ctxt->i4_is_last_ctb_row)

        {

            memcpy(

                ps_sao_ctxt->pu1_curr_sao_src_top_luma + ps_sao_ctxt->i4_frm_top_luma_buf_stride,

                pu1_recon_luma + luma_recon_stride * (ctb_size - 1),

                ps_sao_ctxt->i4_sao_blk_wd);

        }

        for(rdo_cand = 0; rdo_cand < num_luma_rdo_cand; rdo_cand++)

        {

            s_sao_ctxt.ps_sao = &ps_sao_ctxt->as_sao_rd_cand[rdo_cand];

            /* This memcpy is required because cabac uses parameters from this structure

            * to evaluate bits and this structure ptr is sent to cabac through

            * "ihevce_cabac_rdo_encode_sao" function

            */

            memcpy(&ps_ctb_enc_loop_out->s_sao, s_sao_ctxt.ps_sao, sizeof(sao_enc_t));

            /* Copy the left pixels to the scratch buffer for evry rdo cand because its

            overwritten by the sao leaf level function for next ctb*/

            memcpy(

                s_sao_ctxt.au1_left_luma_scratch,

                ps_sao_ctxt->au1_sao_src_left_luma,

                ps_sao_ctxt->i4_sao_blk_ht);

            /* Copy the top and top left pixels to the scratch buffer for evry rdo cand because its

            overwritten by the sao leaf level function for next ctb*/

            memcpy(

                s_sao_ctxt.au1_top_luma_scratch,

                ps_sao_ctxt->pu1_curr_sao_src_top_luma - 1,

                ps_sao_ctxt->i4_sao_blk_wd + 2);

            s_sao_ctxt.pu1_curr_sao_src_top_luma = s_sao_ctxt.au1_top_luma_scratch + 1;

            pu1_luma_scratch_buf = ps_sao_ctxt->au1_sao_luma_scratch[curr_buf_idx];

            ASSERT(

                (abs(s_sao_ctxt.ps_sao->u1_y_offset[1]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_y_offset[2]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_y_offset[3]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_y_offset[4]) <= 7));

            ASSERT(

                (abs(s_sao_ctxt.ps_sao->u1_cb_offset[1]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_cb_offset[2]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_cb_offset[3]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_cb_offset[4]) <= 7));

            ASSERT(

                (abs(s_sao_ctxt.ps_sao->u1_cr_offset[1]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_cr_offset[2]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_cr_offset[3]) <= 7) &&

                (abs(s_sao_ctxt.ps_sao->u1_cr_offset[4]) <= 7));

            ASSERT(

                (s_sao_ctxt.ps_sao->b5_y_band_pos <= 28) &&

                (s_sao_ctxt.ps_sao->b5_cb_band_pos <= 28) &&

                (s_sao_ctxt.ps_sao->b5_cr_band_pos <= 28));

            /* Copy the deblocked recon data to scratch buffer to do sao*/

            ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_copy_2d(

                pu1_luma_scratch_buf,

                i4_luma_scratch_buf_stride,

                pu1_recon_luma,

                luma_recon_stride,

                SCRATCH_BUF_STRIDE,

                ctb_ht + 1);

            s_sao_ctxt.pu1_cur_luma_recon_buf = pu1_luma_scratch_buf;

            s_sao_ctxt.i4_cur_luma_recon_stride = i4_luma_scratch_buf_stride;

            s_sao_ctxt.i1_slice_sao_luma_flag = s_sao_ctxt.ps_slice_hdr->i1_slice_sao_luma_flag;

            s_sao_ctxt.i1_slice_sao_chroma_flag = 0;

            ihevce_sao_ctb(&s_sao_ctxt, ps_tile_params);

            /* Calculate the distortion between sao'ed ctb and original src ctb*/

            // clang-format off

            distortion =

                ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_ssd_calculator(pu1_src_luma,

                        s_sao_ctxt.pu1_cur_luma_recon_buf, luma_src_stride,

                        s_sao_ctxt.i4_cur_luma_recon_stride, ctb_wd, ctb_ht, NULL_PLANE);

            // clang-format on

            ps_sao_ctxt->ps_rdopt_entropy_ctxt->i4_curr_buf_idx = curr_buf_idx;

            ctb_bits = ihevce_cabac_rdo_encode_sao(

                ps_sao_ctxt->ps_rdopt_entropy_ctxt, ps_ctb_enc_loop_out);

            /* Calculate the cost as D+(lamda)*R   */

            curr_cost = distortion +

                        COMPUTE_RATE_COST_CLIP30(ctb_bits, i8_cl_ssd_lambda_qf, LAMBDA_Q_SHIFT);

            if(curr_cost < best_cost)

            {

                best_cost = curr_cost;

                best_buf_idx = ps_sao_ctxt->ps_rdopt_entropy_ctxt->i4_curr_buf_idx;

                best_cand_idx = rdo_cand;

                curr_buf_idx = !curr_buf_idx;

            }

        }

        /* Copy the sao parameters of the best luma cand into the luma_chroma cnad structure for next stage of RDO

        * between luma_chroma combined cand, NO SAO cand, LEFT and TOP merge cand

        */

        s_best_luma_chroma_cand.b3_y_type_idx =

            ps_sao_ctxt->as_sao_rd_cand[best_cand_idx].b3_y_type_idx;

        s_best_luma_chroma_cand.u1_y_offset[1] =

            ps_sao_ctxt->as_sao_rd_cand[best_cand_idx].u1_y_offset[1];

        s_best_luma_chroma_cand.u1_y_offset[2] =

            ps_sao_ctxt->as_sao_rd_cand[best_cand_idx].u1_y_offset[2];

        s_best_luma_chroma_cand.u1_y_offset[3] =

            ps_sao_ctxt->as_sao_rd_cand[best_cand_idx].u1_y_offset[3];

        s_best_luma_chroma_cand.u1_y_offset[4] =

            ps_sao_ctxt->as_sao_rd_cand[best_cand_idx].u1_y_offset[4];

        s_best_luma_chroma_cand.b5_y_band_pos =

            ps_sao_ctxt->as_sao_rd_cand[best_cand_idx].b5_y_band_pos;

    }

    else

    {

        /*Back up the top pixels for (x,y+1)th ctb*/

        if(!ps_sao_ctxt->i4_is_last_ctb_row)

        {

            memcpy(

                ps_sao_ctxt->pu1_curr_sao_src_top_luma + ps_sao_ctxt->i4_frm_top_luma_buf_stride,

                pu1_recon_luma + luma_recon_stride * (ctb_size - 1),

                ps_sao_ctxt->i4_sao_blk_wd);

        }

        s_best_luma_chroma_cand.b3_y_type_idx = SAO_NONE;

        s_best_luma_chroma_cand.u1_y_offset[1] = 0;

        s_best_luma_chroma_cand.u1_y_offset[2] = 0;

        s_best_luma_chroma_cand.u1_y_offset[3] = 0;

        s_best_luma_chroma_cand.u1_y_offset[4] = 0;

        s_best_luma_chroma_cand.b5_y_band_pos = 0;

        s_best_luma_chroma_cand.b1_sao_merge_left_flag = 0;

        s_best_luma_chroma_cand.b1_sao_merge_up_flag = 0;

        s_best_luma_chroma_cand.b3_cb_type_idx = SAO_NONE;

        s_best_luma_chroma_cand.u1_cb_offset[1] = 0;

        s_best_luma_chroma_cand.u1_cb_offset[2] = 0;

        s_best_luma_chroma_cand.u1_cb_offset[3] = 0;

        s_best_luma_chroma_cand.u1_cb_offset[4] = 0;

        s_best_luma_chroma_cand.b5_cb_band_pos = 0;

        s_best_luma_chroma_cand.b3_cr_type_idx = SAO_NONE;

        s_best_luma_chroma_cand.u1_cr_offset[1] = 0;

        s_best_luma_chroma_cand.u1_cr_offset[2] = 0;

        s_best_luma_chroma_cand.u1_cr_offset[3] = 0;

        s_best_luma_chroma_cand.u1_cr_offset[4] = 0;

        s_best_luma_chroma_cand.b5_cr_band_pos = 0;

    }

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

    /********************RDO FOR CHROMA CAND**************/

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

#if !DISABLE_SAO_WHEN_NOISY

    if(ps_sao_ctxt->ps_slice_hdr->i1_slice_sao_chroma_flag)

#else

    if(ps_sao_ctxt->ps_slice_hdr->i1_slice_sao_chroma_flag && !u1_force_no_offset)

#endif

    {

        /*Back up the top pixels for (x,y+1)th ctb*/

        if(!ps_sao_ctxt->i4_is_last_ctb_row)

        {

            memcpy(

                ps_sao_ctxt->pu1_curr_sao_src_top_chroma +

                    ps_sao_ctxt->i4_frm_top_chroma_buf_stride,

                pu1_recon_chroma + chroma_recon_stride * ((ctb_size >> !u1_is_422) - 1),

                ps_sao_ctxt->i4_sao_blk_wd);

        }

        /* Reset the error and edge count*/

        for(edgeidx = 0; edgeidx < 5; edgeidx++)

        {

            acc_error_category[edgeidx] = 0;

            category_count[edgeidx] = 0;

        }

        // clang-format off

        ps_sao_ctxt->ps_cmn_utils_optimised_function_list->pf_get_chroma_eo_sao_params(ps_sao_ctxt,

                s_best_luma_chroma_cand.b3_y_type_idx, acc_error_category,

                category_count);

        // clang-format on

        /* Copy the sao parameters of the best luma cand into the luma_chroma cnad structure for next stage of RDO

        * between luma_chroma combined cand, NO SAO cand, LEFT and TOP merge cand

        */

        // clang-format off

        s_best_luma_chroma_cand.b3_cb_type_idx = s_best_luma_chroma_cand.b3_y_type_idx;

        s_best_luma_chroma_cand.u1_cb_offset[1] = category_count[0]

                ? (CLIP3(acc_error_category[0] / category_count[0], 0, 7))

                : 0;

        s_best_luma_chroma_cand.u1_cb_offset[2] = category_count[1]

                ? (CLIP3(acc_error_category[1] / category_count[1], 0, 7))

                : 0;

        s_best_luma_chroma_cand.u1_cb_offset[3] = category_count[3]

                ? (CLIP3(acc_error_category[3] / category_count[3], -7, 0))

                : 0;

        s_best_luma_chroma_cand.u1_cb_offset[4] = category_count[4]

                ? (CLIP3(acc_error_category[4] / category_count[4], -7, 0))

                : 0;

        s_best_luma_chroma_cand.b5_cb_band_pos = 0;

        s_best_luma_chroma_cand.b3_cr_type_idx = s_best_luma_chroma_cand.b3_y_type_idx;

        s_best_luma_chroma_cand.u1_cr_offset[1] = category_count[0]

                ? (CLIP3(acc_error_category[0] / category_count[0], 0, 7))

                : 0;

        s_best_luma_chroma_cand.u1_cr_offset[2] = category_count[1]

                ? (CLIP3(acc_error_category[1] / category_count[1], 0, 7))

                : 0;

        s_best_luma_chroma_cand.u1_cr_offset[3] = category_count[3]

                ? (CLIP3(acc_error_category[3] / category_count[3], -7, 0))

                : 0;

        s_best_luma_chroma_cand.u1_cr_offset[4] = category_count[4]

                ? (CLIP3(acc_error_category[4] / category_count[4], -7, 0))

                : 0;

        // clang-format on

        s_best_luma_chroma_cand.b5_cr_band_pos = 0;

    }

    else

    {

        /*Back up the top pixels for (x,y+1)th ctb*/

        if(!ps_sao_ctxt->i4_is_last_ctb_row)

        {

            memcpy(

                ps_sao_ctxt->pu1_curr_sao_src_top_chroma +

                    ps_sao_ctxt->i4_frm_top_chroma_buf_stride,

                pu1_recon_chroma + chroma_recon_stride * ((ctb_size >> !u1_is_422) - 1),

                ps_sao_ctxt->i4_sao_blk_wd);

        }

        s_best_luma_chroma_cand.b3_cb_type_idx = SAO_NONE;

        s_best_luma_chroma_cand.u1_cb_offset[1] = 0;

        s_best_luma_chroma_cand.u1_cb_offset[2] = 0;

        s_best_luma_chroma_cand.u1_cb_offset[3] = 0;

        s_best_luma_chroma_cand.u1_cb_offset[4] = 0;

        s_best_luma_chroma_cand.b5_cb_band_pos = 0;

        s_best_luma_chroma_cand.b3_cr_type_idx = SAO_NONE;

        s_best_luma_chroma_cand.u1_cr_offset[1] = 0;

        s_best_luma_chroma_cand.u1_cr_offset[2] = 0;

        s_best_luma_chroma_cand.u1_cr_offset[3] = 0;

        s_best_luma_chroma_cand.u1_cr_offset[4] = 0;

        s_best_luma_chroma_cand.b5_cr_band_pos = 0;

        s_best_luma_chroma_cand.b1_sao_merge_left_flag = 0;

        s_best_luma_chroma_cand.b1_sao_merge_up_flag = 0;

    }

    s_best_luma_chroma_cand.b1_sao_merge_left_flag = 0;

    s_best_luma_chroma_cand.b1_sao_merge_up_flag = 0;

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

    /**RDO for Best Luma - Chroma combined, No SAO,*******/

    /*************Left merge and Top merge****************/

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

    /* No SAO cand*/

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_left_flag = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_up_flag = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b3_y_type_idx = SAO_NONE;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_y_offset[1] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_y_offset[2] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_y_offset[3] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_y_offset[4] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b5_y_band_pos = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b3_cb_type_idx = SAO_NONE;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cb_offset[1] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cb_offset[2] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cb_offset[3] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cb_offset[4] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b5_cb_band_pos = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b3_cr_type_idx = SAO_NONE;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cr_offset[1] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cr_offset[2] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cr_offset[3] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].u1_cr_offset[4] = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b5_cr_band_pos = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_left_flag = 0;

    ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_up_flag = 0;

    num_rdo_cand++;

    /* SAO_note_01: If the CTB lies on a tile or a slice boundary, then

    the standard mandates that the merge candidates must be set to unavailable.

    Hence, check for tile boundary condition by reading

    s_ctb_nbr_avail_flags.u1_left_avail rather than frame position of CTB.

    A special case: Merge-candidates should be available at dependent-slices boundaries.

    Search for <SAO_note_01> in workspace to know more */

#if !DISABLE_SAO_WHEN_NOISY

    if(1)

#else

    if(!u1_force_no_offset)

#endif

    {

        /* Merge left cand*/

        if(ps_ctb_enc_loop_out->s_ctb_nbr_avail_flags.u1_left_avail)

        {

            memcpy(

                &ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand],

                &ps_sao_ctxt->s_left_ctb_sao,

                sizeof(sao_enc_t));

            ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_left_flag = 1;

            ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_up_flag = 0;

            num_rdo_cand++;

        }

        /* Merge top cand*/

        if(ps_ctb_enc_loop_out->s_ctb_nbr_avail_flags.u1_top_avail)

        {

            memcpy(

                &ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand],

                (ps_sao_ctxt->ps_top_ctb_sao - ps_sao_ctxt->u4_num_ctbs_horz),

                sizeof(sao_enc_t));

            ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_left_flag = 0;

            ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand].b1_sao_merge_up_flag = 1;

            num_rdo_cand++;

        }

        /* Best luma-chroma candidate*/

        memcpy(

            &ps_sao_ctxt->as_sao_rd_cand[num_rdo_cand],

            &s_best_luma_chroma_cand,

            sizeof(sao_enc_t));

        num_rdo_cand++;

    }

    {

        UWORD32 luma_distortion = 0, chroma_distortion = 0;

        /* First cand will be best cand after 1st iteration*/

        curr_buf_idx = 0;

        best_buf_idx = 1;