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

*

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

 *

 * @brief

 *  Contains function definitions for sample adaptive offset process

 *

 * @author

 *  Srinivas T

 *

 * @par List of Functions:

 *

 * @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_sao.h"

#include "ihevc_mem_fns.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 "ihevc_deblk.h"

#include "ihevc_deblk_tables.h"

#include "ihevcd_profile.h"

#include "ihevcd_sao.h"

#include "ihevcd_debug.h"

#define SAO_SHIFT_CTB    8

#define UPDATE_LUMA_BUFFERS(pu1_src_luma, src_strd, pu1_src_left_luma, pu1_src_top_luma, pu1_top_left, sao_wd_luma, sao_ht_luma, pixel_size_y) do { \

    if(PIXEL_SIZE_1BYTE == (pixel_size_y)) { \

        for(row = 0; row < (sao_ht_luma); row++) { \

            (pu1_src_left_luma)[row] = (pu1_src_luma)[row * (src_strd) + ((sao_wd_luma) - 1)]; \

        } \

        (pu1_top_left)[0] = (pu1_src_top_luma)[(sao_wd_luma) - 1]; \

    } else { \

        UWORD16 *pu2_src_left = (UWORD16 *)(pu1_src_left_luma); \

        UWORD16 *pu2_src = (UWORD16 *)(pu1_src_luma); \

        UWORD16 *pu2_top = (UWORD16 *)(pu1_src_top_luma); \

        UWORD16 *pu2_top_left = (UWORD16 *)(pu1_top_left); \

        for(row = 0; row < (sao_ht_luma); row++) { \

            pu2_src_left[row] = pu2_src[row * (src_strd) + ((sao_wd_luma) - 1)]; \

        } \

        pu2_top_left[0] = pu2_top[(sao_wd_luma) - 1]; \

    } \

    memcpy((pu1_src_top_luma), &(pu1_src_luma)[((sao_ht_luma) - 1) * (src_strd) * (pixel_size_y)], (sao_wd_luma) * (pixel_size_y)); \

} while(0)

#define UPDATE_CHROMA_BUFFERS(pu1_src_chroma, chroma_strd, pu1_src_left_chroma, pu1_src_top_chroma, pu1_top_left, sao_wd_chroma, sao_ht_chroma, pixel_size_uv) do { \

    if(PIXEL_SIZE_1BYTE == (pixel_size_uv)) { \

        for(row = 0; row < (sao_ht_chroma); row++) { \

            (pu1_src_left_chroma)[2 * row] = (pu1_src_chroma)[row * (chroma_strd) + ((sao_wd_chroma) - 2)]; \

            (pu1_src_left_chroma)[2 * row + 1] = (pu1_src_chroma)[row * (chroma_strd) + ((sao_wd_chroma) - 1)]; \

        } \

        (pu1_top_left)[0] = (pu1_src_top_chroma)[(sao_wd_chroma) - 2]; \

        (pu1_top_left)[1] = (pu1_src_top_chroma)[(sao_wd_chroma) - 1]; \

    } else { \

        UWORD16 *pu2_src_left = (UWORD16 *)(pu1_src_left_chroma); \

        UWORD16 *pu2_src = (UWORD16 *)(pu1_src_chroma); \

        UWORD16 *pu2_top = (UWORD16 *)(pu1_src_top_chroma); \

        UWORD16 *pu2_top_left = (UWORD16 *)(pu1_top_left); \

        for(row = 0; row < (sao_ht_chroma); row++) { \

            pu2_src_left[2 * row] = pu2_src[row * (chroma_strd) + ((sao_wd_chroma) - 2)]; \

            pu2_src_left[2 * row + 1] = pu2_src[row * (chroma_strd) + ((sao_wd_chroma) - 1)]; \

        } \

        pu2_top_left[0] = pu2_top[(sao_wd_chroma) - 2]; \

        pu2_top_left[1] = pu2_top[(sao_wd_chroma) - 1]; \

    } \

    memcpy((pu1_src_top_chroma), &(pu1_src_chroma)[((sao_ht_chroma) - 1) * (chroma_strd) * (pixel_size_uv)], (sao_wd_chroma) * (pixel_size_uv)); \

} while(0)

void ihevcd_sao_shift_ctb(sao_ctxt_t *ps_sao_ctxt)

{

    codec_t *ps_codec = ps_sao_ctxt->ps_codec;

    UWORD8 *pu1_src_luma;

    UWORD8 *pu1_src_chroma;

    WORD32 src_strd;

    WORD32 chroma_strd;

    WORD32 ctb_size;

    WORD32 log2_ctb_size;

    sps_t *ps_sps;

    sao_t *ps_sao;

    pps_t *ps_pps;

    slice_header_t *ps_slice_hdr, *ps_slice_hdr_base;

    tile_t *ps_tile;

    UWORD16 *pu1_slice_idx;

    UWORD16 *pu1_tile_idx;

    WORD32 row, col;

    UWORD8 au1_avail_luma[8];

    UWORD8 au1_avail_chroma[8];

    UWORD8 au1_tile_slice_boundary[8];

    UWORD8 au4_ilf_across_tile_slice_enable[8];

    WORD32 i;

    UWORD8 *pu1_src_top_luma;

    UWORD8 *pu1_src_top_chroma;

    UWORD8 *pu1_src_left_luma;

    UWORD8 *pu1_src_left_chroma;

    UWORD8 au1_src_top_right[2];

    UWORD8 au1_src_bot_left[2];

    UWORD16 au2_src_top_right[2];

    UWORD16 au2_src_bot_left[2];

    UWORD8 *pu1_no_loop_filter_flag;

    UWORD8 *pu1_src_backup_luma;

    UWORD8 *pu1_src_backup_chroma;

    WORD32 backup_strd;

    WORD32 loop_filter_strd;

    UWORD32 u4_bit_depth_luma, u4_bit_depth_chroma;

    WORD32 pixel_size_y, pixel_size_uv;

    WORD32 no_loop_filter_enabled_luma = 0;

    WORD32 no_loop_filter_enabled_chroma = 0;

    UWORD8 *pu1_sao_src_top_left_chroma_curr_ctb;

    UWORD8 *pu1_sao_src_top_left_luma_curr_ctb;

    UWORD8 *pu1_sao_src_luma_top_left_ctb;

    UWORD8 *pu1_sao_src_chroma_top_left_ctb;

    UWORD8 *pu1_sao_src_top_left_luma_top_right;

    UWORD8 *pu1_sao_src_top_left_chroma_top_right;

    UWORD8  u1_sao_src_top_left_luma_bot_left;

    UWORD8  *pu1_sao_src_top_left_luma_bot_left;

    UWORD8 *au1_sao_src_top_left_chroma_bot_left;

    UWORD16 *au2_sao_src_top_left_chroma_bot_left;

    UWORD16 u2_sao_src_top_left_luma_bot_left;

    UWORD8 *pu1_sao_src_top_left_chroma_bot_left;

    /* Only first 5 values are used, but arrays are large

     enough so that SIMD functions can read 64 bits at a time */

    WORD8 ai1_offset_y[8] = {0};

    WORD8 ai1_offset_cb[8] = {0};

    WORD8 ai1_offset_cr[8] = {0};

    WORD32  chroma_yuv420sp_vu = ps_sao_ctxt->is_chroma_yuv420sp_vu;

    PROFILE_DISABLE_SAO();

    ps_sps = ps_sao_ctxt->ps_sps;

    ps_pps = ps_sao_ctxt->ps_pps;

    ps_tile = ps_sao_ctxt->ps_tile;

    WORD32 is_yuv444 = ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444 ? 1 : 0;

    WORD32 h_samp_factor = (CHROMA_FMT_IDC_YUV444 == ps_sps->i1_chroma_format_idc) ? 1 : 2;

    WORD32 v_samp_factor = (CHROMA_FMT_IDC_YUV420 == ps_sps->i1_chroma_format_idc) ? 2 : 1;

    WORD32 chroma_pixel_strd = 2;

    log2_ctb_size = ps_sps->i1_log2_ctb_size;

    ctb_size = (1 << log2_ctb_size);

    src_strd = ps_sao_ctxt->ps_codec->i4_strd;

    chroma_strd = src_strd * chroma_pixel_strd / h_samp_factor;

    u4_bit_depth_luma = (UWORD32)ps_sao_ctxt->ps_codec->i4_bit_depth_luma;

    u4_bit_depth_chroma = (UWORD32)ps_sao_ctxt->ps_codec->i4_bit_depth_chroma;

    pixel_size_y = (u4_bit_depth_luma > 8) ? 2 : 1;

    pixel_size_uv = (u4_bit_depth_chroma > 8) ? 2 : 1;

    ps_slice_hdr_base = ps_sao_ctxt->ps_codec->ps_slice_hdr_base;

    ps_slice_hdr = ps_slice_hdr_base + (ps_sao_ctxt->i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1));

    pu1_slice_idx = ps_sao_ctxt->pu1_slice_idx;

    pu1_tile_idx = ps_sao_ctxt->pu1_tile_idx;

    pu1_src_luma = ps_sao_ctxt->pu1_cur_pic_luma + (((ps_sao_ctxt->i4_ctb_x + ps_sao_ctxt->i4_ctb_y * ps_sao_ctxt->ps_codec->i4_strd) << (log2_ctb_size)) * pixel_size_y);

    pu1_src_chroma = ps_sao_ctxt->pu1_cur_pic_chroma

                    + (((ps_sao_ctxt->i4_ctb_x * chroma_pixel_strd / h_samp_factor

                    + ps_sao_ctxt->i4_ctb_y * ps_sao_ctxt->ps_codec->i4_strd * chroma_pixel_strd / (h_samp_factor * v_samp_factor)) << (log2_ctb_size)) * pixel_size_uv);

    /*Stores the left value for each row ctbs- Needed for column tiles*/

    pu1_sao_src_top_left_luma_curr_ctb = ps_sao_ctxt->pu1_sao_src_top_left_luma_curr_ctb + ((ps_sao_ctxt->i4_ctb_y) * pixel_size_y);

    pu1_sao_src_top_left_chroma_curr_ctb = ps_sao_ctxt->pu1_sao_src_top_left_chroma_curr_ctb + (2 * (ps_sao_ctxt->i4_ctb_y) * pixel_size_uv);

    pu1_sao_src_luma_top_left_ctb = ps_sao_ctxt->pu1_sao_src_luma_top_left_ctb + ((ps_sao_ctxt->i4_ctb_y) * pixel_size_y);

    pu1_sao_src_chroma_top_left_ctb = ps_sao_ctxt->pu1_sao_src_chroma_top_left_ctb + (2 * ps_sao_ctxt->i4_ctb_y * pixel_size_uv);

    u1_sao_src_top_left_luma_bot_left = ps_sao_ctxt->u2_sao_src_top_left_luma_bot_left; // + ((ps_sao_ctxt->i4_ctb_y));

    u2_sao_src_top_left_luma_bot_left = ps_sao_ctxt->u2_sao_src_top_left_luma_bot_left;

    pu1_sao_src_top_left_luma_bot_left = ps_sao_ctxt->pu1_sao_src_top_left_luma_bot_left + ((ps_sao_ctxt->i4_ctb_y) * pixel_size_y);

    au1_sao_src_top_left_chroma_bot_left = (UWORD8 *)ps_sao_ctxt->au2_sao_src_top_left_chroma_bot_left; // + (2 * ps_sao_ctxt->i4_ctb_y);

    au2_sao_src_top_left_chroma_bot_left = ps_sao_ctxt->au2_sao_src_top_left_chroma_bot_left;

    pu1_sao_src_top_left_chroma_bot_left = ps_sao_ctxt->pu1_sao_src_top_left_chroma_bot_left + (2 * ps_sao_ctxt->i4_ctb_y * pixel_size_uv);

    pu1_sao_src_top_left_luma_top_right = ps_sao_ctxt->pu1_sao_src_top_left_luma_top_right + ((ps_sao_ctxt->i4_ctb_x) * pixel_size_y);

    pu1_sao_src_top_left_chroma_top_right = ps_sao_ctxt->pu1_sao_src_top_left_chroma_top_right + (2 * ps_sao_ctxt->i4_ctb_x * pixel_size_uv);

    ps_sao = ps_sao_ctxt->ps_pic_sao + ps_sao_ctxt->i4_ctb_x + ps_sao_ctxt->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb;

    loop_filter_strd =  (ps_sps->i2_pic_width_in_luma_samples + 63) >> 6;

    backup_strd = 2 * MAX_CTB_SIZE;

    DEBUG_INIT_TMP_BUF(ps_sao_ctxt->pu1_tmp_buf_luma, ps_sao_ctxt->pu1_tmp_buf_chroma);

    {

        /* Check the loop filter flags and copy the original values for back up */

        /* Luma */

        /* Done unconditionally since SAO is done on a shifted CTB and the constituent CTBs

         * can belong to different slice with their own sao_enable flag */

        {

            UWORD32 u4_no_loop_filter_flag;

            WORD32 loop_filter_bit_pos;

            WORD32 log2_min_cu = 3;

            WORD32 min_cu = (1 << log2_min_cu);

            UWORD8 *pu1_src_tmp_luma = pu1_src_luma;

            WORD32 sao_blk_ht = ctb_size - SAO_SHIFT_CTB;

            WORD32 sao_blk_wd = ctb_size;

            WORD32 remaining_rows;

            WORD32 remaining_cols;

            remaining_rows = ps_sps->i2_pic_height_in_luma_samples - ((ps_sao_ctxt->i4_ctb_y << log2_ctb_size) + ctb_size - SAO_SHIFT_CTB);

            remaining_cols = ps_sps->i2_pic_width_in_luma_samples - ((ps_sao_ctxt->i4_ctb_x << log2_ctb_size) + ctb_size - SAO_SHIFT_CTB);

            if(remaining_rows <= SAO_SHIFT_CTB)

                sao_blk_ht += remaining_rows;

            if(remaining_cols <= SAO_SHIFT_CTB)

                sao_blk_wd += remaining_cols;

            pu1_src_tmp_luma -= ps_sao_ctxt->i4_ctb_x ? SAO_SHIFT_CTB * pixel_size_y : 0;

            pu1_src_tmp_luma -= ps_sao_ctxt->i4_ctb_y ? SAO_SHIFT_CTB * src_strd * pixel_size_y : 0;

            pu1_src_backup_luma = ps_sao_ctxt->pu1_tmp_buf_luma;

            loop_filter_bit_pos = (ps_sao_ctxt->i4_ctb_x << (log2_ctb_size - 3)) +

                            (ps_sao_ctxt->i4_ctb_y << (log2_ctb_size - 3)) * (loop_filter_strd << 3);

            if(ps_sao_ctxt->i4_ctb_x > 0)

                loop_filter_bit_pos -= 1;

            pu1_no_loop_filter_flag = ps_sao_ctxt->pu1_pic_no_loop_filter_flag +

                            (loop_filter_bit_pos >> 3);

            for(i = -(ps_sao_ctxt->i4_ctb_y ? SAO_SHIFT_CTB : 0) >> log2_min_cu;

                            i < (sao_blk_ht + (min_cu - 1)) >> log2_min_cu; i++)

            {

                WORD32 tmp_wd = sao_blk_wd;

                u4_no_loop_filter_flag = (*(UWORD32 *)(pu1_no_loop_filter_flag + i * loop_filter_strd)) >>

                                (loop_filter_bit_pos & 7);

                u4_no_loop_filter_flag &= (1 << ((tmp_wd + (min_cu - 1)) >> log2_min_cu)) - 1;

                if(u4_no_loop_filter_flag)

                {

                    no_loop_filter_enabled_luma = 1;

                    while(tmp_wd > 0)

                    {

                        if(CTZ(u4_no_loop_filter_flag))

                        {

                            pu1_src_tmp_luma += MIN((WORD32)(CTZ(u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * pixel_size_y;

                            pu1_src_backup_luma += MIN((WORD32)(CTZ(u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * pixel_size_y;

                            tmp_wd -= (WORD32)(CTZ(u4_no_loop_filter_flag) << log2_min_cu);

                            u4_no_loop_filter_flag  >>= (CTZ(u4_no_loop_filter_flag));

                        }

                        else

                        {

                            for(row = 0; row < min_cu; row++)

                            {

                                for(col = 0; col < MIN((WORD32)(CTZ(~u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * pixel_size_y; col++)

                                {

                                    pu1_src_backup_luma[row * backup_strd * pixel_size_y + col] = pu1_src_tmp_luma[row * src_strd * pixel_size_y + col];

                                }

                            }

                            pu1_src_tmp_luma += MIN(((WORD32)CTZ(~u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * pixel_size_y;

                            pu1_src_backup_luma += MIN(((WORD32)CTZ(~u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * pixel_size_y;

                            tmp_wd -= (WORD32)(CTZ(~u4_no_loop_filter_flag) << log2_min_cu);

                            u4_no_loop_filter_flag  >>= (CTZ(~u4_no_loop_filter_flag));

                        }

                    }

                    pu1_src_tmp_luma -= sao_blk_wd * pixel_size_y;

                    pu1_src_backup_luma -= sao_blk_wd * pixel_size_y;

                }

                pu1_src_tmp_luma += ((src_strd << log2_min_cu) * pixel_size_y);

                pu1_src_backup_luma += ((backup_strd << log2_min_cu) * pixel_size_y);

            }

        }

        /* Chroma */

        if (CHROMA_FMT_IDC_MONOCHROME != ps_sps->i1_chroma_format_idc)

        {

            UWORD32 u4_no_loop_filter_flag;

            WORD32 loop_filter_bit_pos;

            WORD32 log2_min_cu = 3;

            WORD32 min_cu = (1 << log2_min_cu);

            UWORD8 *pu1_src_tmp_chroma = pu1_src_chroma;

            WORD32 sao_blk_ht = ctb_size - 2 * SAO_SHIFT_CTB;

            WORD32 sao_blk_wd = ctb_size;

            WORD32 remaining_rows;

            WORD32 remaining_cols;

            remaining_rows = ps_sps->i2_pic_height_in_luma_samples - ((ps_sao_ctxt->i4_ctb_y << log2_ctb_size) + ctb_size - 2 * SAO_SHIFT_CTB);

            remaining_cols = ps_sps->i2_pic_width_in_luma_samples - ((ps_sao_ctxt->i4_ctb_x << log2_ctb_size) + ctb_size - 2 * SAO_SHIFT_CTB);

            if(remaining_rows <= 2 * SAO_SHIFT_CTB)

                sao_blk_ht += remaining_rows;

            if(remaining_cols <= 2 * SAO_SHIFT_CTB)

                sao_blk_wd += remaining_cols;

            pu1_src_tmp_chroma -= (ps_sao_ctxt->i4_ctb_x ? SAO_SHIFT_CTB * 2 : 0) * pixel_size_uv;

            pu1_src_tmp_chroma -= (ps_sao_ctxt->i4_ctb_y ? SAO_SHIFT_CTB * chroma_strd : 0) * pixel_size_uv;

            pu1_src_backup_chroma = ps_sao_ctxt->pu1_tmp_buf_chroma;

            loop_filter_bit_pos = (ps_sao_ctxt->i4_ctb_x << (log2_ctb_size - 3)) +

                            (ps_sao_ctxt->i4_ctb_y << (log2_ctb_size - 3)) * (loop_filter_strd << 3);

            if(ps_sao_ctxt->i4_ctb_x > 0)

                loop_filter_bit_pos -= (is_yuv444 ? 1 : 2);

            pu1_no_loop_filter_flag = ps_sao_ctxt->pu1_pic_no_loop_filter_flag +

                            (loop_filter_bit_pos >> 3);

            for(i = -(ps_sao_ctxt->i4_ctb_y ? 2 * SAO_SHIFT_CTB : 0) >> log2_min_cu;

                            i < (sao_blk_ht + (min_cu - 1)) >> log2_min_cu; i++)

            {

                WORD32 tmp_wd = sao_blk_wd;

                u4_no_loop_filter_flag = (*(UWORD32 *)(pu1_no_loop_filter_flag + i * loop_filter_strd)) >>

                                (loop_filter_bit_pos & 7);

                u4_no_loop_filter_flag &= (1 << ((tmp_wd + (min_cu - 1)) >> log2_min_cu)) - 1;

                if(u4_no_loop_filter_flag)

                {

                    no_loop_filter_enabled_chroma = 1;

                    while(tmp_wd > 0)

                    {

                        if(CTZ(u4_no_loop_filter_flag))

                        {

                            pu1_src_tmp_chroma += MIN(((WORD32)CTZ(u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv;

                            pu1_src_backup_chroma += MIN(((WORD32)CTZ(u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv;

                            tmp_wd -= (WORD32)(CTZ(u4_no_loop_filter_flag) << log2_min_cu);

                            u4_no_loop_filter_flag  >>= (CTZ(u4_no_loop_filter_flag));

                        }

                        else

                        {

                            for(row = 0; row < min_cu / v_samp_factor; row++)

                            {

                                for(col = 0; col < MIN(((WORD32)CTZ(~u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv; col++)

                                {

                                    pu1_src_backup_chroma[row * backup_strd * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv + col] = pu1_src_tmp_chroma[row * chroma_strd * pixel_size_uv + col];

                                }

                            }

                            pu1_src_tmp_chroma += MIN(((WORD32)CTZ(~u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv;

                            pu1_src_backup_chroma += MIN(((WORD32)CTZ(~u4_no_loop_filter_flag) << log2_min_cu), tmp_wd) * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv;

                            tmp_wd -= (WORD32)(CTZ(~u4_no_loop_filter_flag) << log2_min_cu);

                            u4_no_loop_filter_flag  >>= (CTZ(~u4_no_loop_filter_flag));

                        }

                    }

                    pu1_src_tmp_chroma -= sao_blk_wd * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv;

                    pu1_src_backup_chroma -= sao_blk_wd * (chroma_pixel_strd / h_samp_factor) * pixel_size_uv;

                }

                pu1_src_tmp_chroma += ((((src_strd * chroma_pixel_strd) / (h_samp_factor * v_samp_factor)) << log2_min_cu) * pixel_size_uv);

                pu1_src_backup_chroma += ((((backup_strd * chroma_pixel_strd) / (h_samp_factor * v_samp_factor)) << log2_min_cu) * pixel_size_uv);

            }

        }

    }

    DEBUG_PROCESS_TMP_BUF(ps_sao_ctxt->pu1_tmp_buf_luma, ps_sao_ctxt->pu1_tmp_buf_chroma);

    /* Top-left CTB */

    if(ps_sao_ctxt->i4_ctb_x > 0 && ps_sao_ctxt->i4_ctb_y > 0)

    {

        WORD32 sao_wd_luma = SAO_SHIFT_CTB;

        WORD32 sao_wd_chroma = 2 * SAO_SHIFT_CTB;

        WORD32 sao_ht_luma = SAO_SHIFT_CTB;

        WORD32 sao_ht_chroma = SAO_SHIFT_CTB;

        WORD32 ctbx_tl_t = 0, ctbx_tl_l = 0, ctbx_tl_r = 0, ctbx_tl_d = 0, ctbx_tl = 0;

        WORD32 ctby_tl_t = 0, ctby_tl_l = 0, ctby_tl_r = 0, ctby_tl_d = 0, ctby_tl = 0;

        WORD32 au4_idx_tl[8], idx_tl;

        slice_header_t *ps_slice_hdr_top_left;

        {

            WORD32 top_left_ctb_indx = (ps_sao_ctxt->i4_ctb_y - 1) * ps_sps->i2_pic_wd_in_ctb +

                                        (ps_sao_ctxt->i4_ctb_x - 1);

            ps_slice_hdr_top_left = ps_slice_hdr_base + pu1_slice_idx[top_left_ctb_indx];

        }

        pu1_src_luma -= (sao_wd_luma + sao_ht_luma * src_strd) * pixel_size_y;

        pu1_src_chroma -= (sao_wd_chroma + sao_ht_chroma * chroma_strd) * pixel_size_uv;

        ps_sao -= (1 + ps_sps->i2_pic_wd_in_ctb);

        pu1_src_top_luma = ps_sao_ctxt->pu1_sao_src_top_luma + ((ps_sao_ctxt->i4_ctb_x << log2_ctb_size) - sao_wd_luma) * pixel_size_y;

        pu1_src_top_chroma = ps_sao_ctxt->pu1_sao_src_top_chroma + ((ps_sao_ctxt->i4_ctb_x << log2_ctb_size) * (chroma_pixel_strd / h_samp_factor) - sao_wd_chroma) * pixel_size_uv;

        pu1_src_left_luma = ps_sao_ctxt->pu1_sao_src_left_luma + ((ps_sao_ctxt->i4_ctb_y << log2_ctb_size) - sao_ht_luma) * pixel_size_y;

        pu1_src_left_chroma = ps_sao_ctxt->pu1_sao_src_left_chroma + ((ps_sao_ctxt->i4_ctb_y << log2_ctb_size) * (chroma_pixel_strd / v_samp_factor) - (2 * sao_ht_chroma)) * pixel_size_uv;

        if(ps_slice_hdr_top_left->i1_slice_sao_luma_flag)

        {

            if(0 == ps_sao->b3_y_type_idx)

            {

                UPDATE_LUMA_BUFFERS(pu1_src_luma, src_strd, pu1_src_left_luma, pu1_src_top_luma, pu1_sao_src_luma_top_left_ctb, sao_wd_luma, sao_ht_luma, pixel_size_y);

            }

            else if(1 == ps_sao->b3_y_type_idx)

            {

                ai1_offset_y[1] = ps_sao->b8_y_offset_1;

                ai1_offset_y[2] = ps_sao->b8_y_offset_2;

                ai1_offset_y[3] = ps_sao->b8_y_offset_3;

                ai1_offset_y[4] = ps_sao->b8_y_offset_4;

                if(PIXEL_SIZE_1BYTE == pixel_size_y)

                {

                    ps_codec->s_func_selector.ihevc_sao_band_offset_luma_fptr(

                        pu1_src_luma,

                        src_strd,

                        pu1_src_left_luma,

                        pu1_src_top_luma,

                        pu1_sao_src_luma_top_left_ctb,

                        ps_sao->b5_y_band_pos,

                        ai1_offset_y,

                        sao_wd_luma,

                        sao_ht_luma);

                }

                else

                {

                    ps_codec->s_func_selector.ihevc_hbd_sao_band_offset_luma_fptr(

                        (UWORD16 *)pu1_src_luma,

                        src_strd,

                        (UWORD16 *)pu1_src_left_luma,

                        (UWORD16 *)pu1_src_top_luma,

                        (UWORD16 *)pu1_sao_src_luma_top_left_ctb,

                        ps_sao->b5_y_band_pos,

                        ai1_offset_y,

                        sao_wd_luma,

                        sao_ht_luma,

                        u4_bit_depth_luma);

                }

            }

            else // if(2 <= ps_sao->b3_y_type_idx)

            {

                ai1_offset_y[1] = ps_sao->b8_y_offset_1;

                ai1_offset_y[2] = ps_sao->b8_y_offset_2;

                ai1_offset_y[3] = ps_sao->b8_y_offset_3;

                ai1_offset_y[4] = ps_sao->b8_y_offset_4;

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

                {

                    au1_avail_luma[i] = 255;

                    au1_tile_slice_boundary[i] = 0;

                    au4_idx_tl[i] = 0;

                    au4_ilf_across_tile_slice_enable[i] = 1;

                }

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

                 * Derive the  Top-left CTB's neighbor pixel's slice indices.

                 *

                 *          TL_T

                 *       4  _2__5________

                 *     0   |    |       |

                 *    TL_L | TL | 1 TL_R|

                 *         |____|_______|____

                 *        6|TL_D|7      |    |

                 *         | 3  |       |    |

                 *         |____|_______|    |

                 *              |            |

                 *              |            |

                 *              |____________|

                 *

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

                /*In case of slices, unless we encounter multiple slice/tiled clips, don't enter*/

                {

                    if((!ps_slice_hdr->i1_first_slice_in_pic_flag) || (ps_pps->i1_tiles_enabled_flag))

                    {

                        {

                            /*Assuming that sao shift is uniform along x and y directions*/

                            if((0 == (1 << log2_ctb_size) - sao_wd_luma) && (ps_sao_ctxt->i4_ctb_y > 1) && (ps_sao_ctxt->i4_ctb_x > 1))

                            {

                                ctby_tl_t = ps_sao_ctxt->i4_ctb_y - 2;

                                ctbx_tl_l = ps_sao_ctxt->i4_ctb_x - 2;

                            }

                            else if(!(0 == (1 << log2_ctb_size) - sao_wd_luma))

                            {

                                ctby_tl_t = ps_sao_ctxt->i4_ctb_y - 1;

                                ctbx_tl_l = ps_sao_ctxt->i4_ctb_x - 1;

                            }

                            ctbx_tl_t = ps_sao_ctxt->i4_ctb_x - 1;

                            ctby_tl_l = ps_sao_ctxt->i4_ctb_y - 1;

                            ctbx_tl_r = ps_sao_ctxt->i4_ctb_x;

                            ctby_tl_r = ps_sao_ctxt->i4_ctb_y - 1;

                            ctbx_tl_d =  ps_sao_ctxt->i4_ctb_x - 1;

                            ctby_tl_d =  ps_sao_ctxt->i4_ctb_y;

                            ctbx_tl = ps_sao_ctxt->i4_ctb_x - 1;

                            ctby_tl = ps_sao_ctxt->i4_ctb_y - 1;

                        }

                        if(!ps_slice_hdr->i1_first_slice_in_pic_flag)

                        {

                            /*Calculate slice indices for neighbor pixels*/

                            idx_tl   = pu1_slice_idx[ctbx_tl + (ctby_tl * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[2] = au4_idx_tl[4] = *(pu1_slice_idx + ctbx_tl_t + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb));

                            au4_idx_tl[0] =  pu1_slice_idx[ctbx_tl_l + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[1] = au4_idx_tl[5] = pu1_slice_idx[ctbx_tl_r + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[3] = au4_idx_tl[6] =   pu1_slice_idx[ctbx_tl_d + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[7] = pu1_slice_idx[ctbx_tl_d + 1 + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                            if((0 == (1 << log2_ctb_size) - sao_wd_luma))

                            {

                                if(ps_sao_ctxt->i4_ctb_x == 1)

                                {

                                    au4_idx_tl[6] = -1;

                                    au4_idx_tl[4] = -1;

                                }

                                else

                                {

                                    au4_idx_tl[6] = pu1_slice_idx[(ctbx_tl_d - 1) + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                                }

                                if(ps_sao_ctxt->i4_ctb_y == 1)

                                {

                                    au4_idx_tl[5] = -1;

                                    au4_idx_tl[4] = -1;

                                }

                                else

                                {

                                    au4_idx_tl[5] = pu1_slice_idx[(ctbx_tl_l + 1) + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[4] = pu1_slice_idx[(ctbx_tl_t - 1) + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb)];

                                }

                                au4_idx_tl[7] = pu1_slice_idx[(ctbx_tl_d + 1) + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                            }

                            /* Verify that the neighbor ctbs dont cross pic boundary.

                             * Between each neighbor and the current CTB, the i1_slice_loop_filter_across_slices_enabled_flag

                             * of the pixel having a greater address is checked. Accordingly, set the availability flags.

                             * Hence, for top and left pixels, current ctb flag is checked. For right and down pixels,

                             * the respective pixel's flags are checked

                             */

                            if((0 == (ps_sao_ctxt->i4_ctb_x << log2_ctb_size) - sao_wd_luma))

                            {

                                au4_ilf_across_tile_slice_enable[4] = 0;

                                au4_ilf_across_tile_slice_enable[6] = 0;

                            }

                            else

                            {

                                au4_ilf_across_tile_slice_enable[6] = (ps_slice_hdr_base + au4_idx_tl[6])->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            if((0 == (ps_sao_ctxt->i4_ctb_y << log2_ctb_size) - sao_ht_luma))

                            {

                                au4_ilf_across_tile_slice_enable[5] = 0;

                                au4_ilf_across_tile_slice_enable[4] = 0;

                            }

                            else

                            {

                                au4_ilf_across_tile_slice_enable[5] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                                au4_ilf_across_tile_slice_enable[4] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            au4_ilf_across_tile_slice_enable[2] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[0] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[1] = (ps_slice_hdr_base + au4_idx_tl[1])->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[3] = (ps_slice_hdr_base + au4_idx_tl[3])->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[7] = (ps_slice_hdr_base + au4_idx_tl[7])->i1_slice_loop_filter_across_slices_enabled_flag;

                            if(au4_idx_tl[5] > idx_tl)

                            {

                                au4_ilf_across_tile_slice_enable[5] = (ps_slice_hdr_base + au4_idx_tl[5])->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            /*

                             * Between each neighbor and the current CTB, the i1_slice_loop_filter_across_slices_enabled_flag

                             * of the pixel having a greater address is checked. Accordingly, set the availability flags.

                             * Hence, for top and left pixels, current ctb flag is checked. For right and down pixels,

                             * the respective pixel's flags are checked

                             */

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

                            {

                                /*Sets the edges that lie on the slice/tile boundary*/

                                if(au4_idx_tl[i] != idx_tl)

                                {

                                    au1_tile_slice_boundary[i] = 1;

                                }

                                else

                                {

                                    au4_ilf_across_tile_slice_enable[i] = 1;

                                }

                            }

                            memset((UWORD8 *)au4_idx_tl, 0, 8 * sizeof(WORD32));

                        }

                        if(ps_pps->i1_tiles_enabled_flag)

                        {

                            /* Calculate availability flags at slice boundary */

                            if(((ps_tile->u1_pos_x == ps_sao_ctxt->i4_ctb_x) || (ps_tile->u1_pos_y == ps_sao_ctxt->i4_ctb_y)) && (!((0 == ps_tile->u1_pos_x) && (0 == ps_tile->u1_pos_y))))

                            {

                                /*If ilf across tiles is enabled, boundary availability for tiles is not checked. */

                                if(!ps_pps->i1_loop_filter_across_tiles_enabled_flag)

                                {

                                    /*Set the boundary arrays*/

                                    /*Calculate tile indices for neighbor pixels*/

                                    idx_tl   = pu1_tile_idx[ctbx_tl + (ctby_tl * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[2] = au4_idx_tl[4] = *(pu1_tile_idx + ctbx_tl_t + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb));

                                    au4_idx_tl[0] =  pu1_tile_idx[ctbx_tl_l + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[1] = au4_idx_tl[5] = pu1_tile_idx[ctbx_tl_r + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[3] = au4_idx_tl[6] =   pu1_tile_idx[ctbx_tl_d + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[7] = pu1_tile_idx[ctbx_tl_d + 1 + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                                    if((0 == (1 << log2_ctb_size) - sao_wd_luma))

                                    {

                                        if(ps_sao_ctxt->i4_ctb_x == 1)

                                        {

                                            au4_idx_tl[6] = -1;

                                            au4_idx_tl[4] = -1;

                                        }

                                        else

                                        {

                                            au4_idx_tl[6] = pu1_tile_idx[(ctbx_tl_d - 1) + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                                        }

                                        if(ps_sao_ctxt->i4_ctb_y == 1)

                                        {

                                            au4_idx_tl[5] = -1;

                                            au4_idx_tl[4] = -1;

                                        }

                                        else

                                        {

                                            au4_idx_tl[5] = pu1_tile_idx[(ctbx_tl_l + 1) + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                                            au4_idx_tl[4] = pu1_tile_idx[(ctbx_tl_t - 1) + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb)];

                                        }

                                        au4_idx_tl[7] = pu1_tile_idx[(ctbx_tl_d + 1) + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                                    }

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

                                    {

                                        /*Sets the edges that lie on the tile boundary*/

                                        if(au4_idx_tl[i] != idx_tl)

                                        {

                                            au1_tile_slice_boundary[i] |= 1;

                                            au4_ilf_across_tile_slice_enable[i] &= ps_pps->i1_loop_filter_across_tiles_enabled_flag; //=0

                                        }

                                    }

                                }

                            }

                        }

                        /*Set availability flags based on tile and slice boundaries*/

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

                        {

                            /*Sets the edges that lie on the slice/tile boundary*/

                            if((au1_tile_slice_boundary[i]) && !(au4_ilf_across_tile_slice_enable[i]))

                            {

                                au1_avail_luma[i] = 0;

                            }

                        }

                    }

                }

                if(0 == (ps_sao_ctxt->i4_ctb_x << log2_ctb_size) - sao_wd_luma)

                {

                    au1_avail_luma[0] = 0;

                    au1_avail_luma[4] = 0;

                    au1_avail_luma[6] = 0;

                }

                if(ps_sps->i2_pic_wd_in_ctb == ps_sao_ctxt->i4_ctb_x)

                {

                    au1_avail_luma[1] = 0;

                    au1_avail_luma[5] = 0;

                    au1_avail_luma[7] = 0;

                }

                //y==1 case

                if((0 == (ps_sao_ctxt->i4_ctb_y << log2_ctb_size) - sao_ht_luma))

                {

                    au1_avail_luma[2] = 0;

                    au1_avail_luma[4] = 0;

                    au1_avail_luma[5] = 0;

                }

                if(ps_sps->i2_pic_ht_in_ctb == ps_sao_ctxt->i4_ctb_y)

                {

                    au1_avail_luma[3] = 0;

                    au1_avail_luma[6] = 0;

                    au1_avail_luma[7] = 0;

                }

                if(PIXEL_SIZE_1BYTE == pixel_size_y)

                {

                    au1_src_top_right[0] = pu1_src_top_luma[sao_wd_luma];

                    u1_sao_src_top_left_luma_bot_left = pu1_src_left_luma[sao_ht_luma];

                    ps_codec->apf_sao_luma[ps_sao->b3_y_type_idx - 2](pu1_src_luma,

                                                              src_strd,

                                                              pu1_src_left_luma,

                                                              pu1_src_top_luma,

                                                              pu1_sao_src_luma_top_left_ctb,

                                                              au1_src_top_right,

                                                              &u1_sao_src_top_left_luma_bot_left,

                                                              au1_avail_luma,

                                                              ai1_offset_y,

                                                              sao_wd_luma,

                                                              sao_ht_luma);

                }

                else

                {

                    UWORD16 *pu2_src_top_luma = (UWORD16 *)pu1_src_top_luma;

                    UWORD16 *pu2_src_left_luma = (UWORD16 *)pu1_src_left_luma;

                    au2_src_top_right[0] = pu2_src_top_luma[sao_wd_luma];

                    u2_sao_src_top_left_luma_bot_left = pu2_src_left_luma[sao_ht_luma];

                    ps_codec->apf_hbd_sao_luma[ps_sao->b3_y_type_idx - 2]((UWORD16 *)pu1_src_luma,

                                                                  src_strd,

                                                                  (UWORD16 *)pu1_src_left_luma,

                                                                  (UWORD16 *)pu1_src_top_luma,

                                                                  (UWORD16 *)pu1_sao_src_luma_top_left_ctb,

                                                                  au2_src_top_right,

                                                                  &u2_sao_src_top_left_luma_bot_left,

                                                                  au1_avail_luma,

                                                                  ai1_offset_y,

                                                                  sao_wd_luma,

                                                                  sao_ht_luma,

                                                                  u4_bit_depth_luma);

                }

            }

        }

        else if((!ps_slice_hdr->i1_first_slice_in_pic_flag) || (ps_pps->i1_tiles_enabled_flag))

        {

            UPDATE_LUMA_BUFFERS(pu1_src_luma, src_strd, pu1_src_left_luma, pu1_src_top_luma, pu1_sao_src_luma_top_left_ctb, sao_wd_luma, sao_ht_luma, pixel_size_y);

        }

        if(CHROMA_FMT_IDC_MONOCHROME != ps_sps->i1_chroma_format_idc && ps_slice_hdr_top_left->i1_slice_sao_chroma_flag)

        {

            if(0 == ps_sao->b3_cb_type_idx)

            {

                UPDATE_CHROMA_BUFFERS(pu1_src_chroma, chroma_strd, pu1_src_left_chroma, pu1_src_top_chroma, pu1_sao_src_chroma_top_left_ctb, sao_wd_chroma, sao_ht_chroma, pixel_size_uv);

            }

            else if(1 == ps_sao->b3_cb_type_idx)

            {

                ai1_offset_cb[1] = ps_sao->b8_cb_offset_1;

                ai1_offset_cb[2] = ps_sao->b8_cb_offset_2;

                ai1_offset_cb[3] = ps_sao->b8_cb_offset_3;

                ai1_offset_cb[4] = ps_sao->b8_cb_offset_4;

                ai1_offset_cr[1] = ps_sao->b8_cr_offset_1;

                ai1_offset_cr[2] = ps_sao->b8_cr_offset_2;

                ai1_offset_cr[3] = ps_sao->b8_cr_offset_3;

                ai1_offset_cr[4] = ps_sao->b8_cr_offset_4;

                if(chroma_yuv420sp_vu)

                {

                    if(PIXEL_SIZE_1BYTE == pixel_size_uv)

                    {

                        ps_codec->s_func_selector.ihevc_sao_band_offset_chroma_fptr(

                            pu1_src_chroma,

                            chroma_strd,

                            pu1_src_left_chroma,

                            pu1_src_top_chroma,

                            pu1_sao_src_chroma_top_left_ctb,

                            ps_sao->b5_cr_band_pos,

                            ps_sao->b5_cb_band_pos,

                            ai1_offset_cr,

                            ai1_offset_cb,

                            sao_wd_chroma,

                            sao_ht_chroma);

                    }

                    else

                    {

                        ps_codec->s_func_selector.ihevc_hbd_sao_band_offset_chroma_fptr(

                            (UWORD16 *)pu1_src_chroma,

                            chroma_strd,

                            (UWORD16 *)pu1_src_left_chroma,

                            (UWORD16 *)pu1_src_top_chroma,

                            (UWORD16 *)pu1_sao_src_chroma_top_left_ctb,

                            ps_sao->b5_cr_band_pos,

                            ps_sao->b5_cb_band_pos,

                            ai1_offset_cr,

                            ai1_offset_cb,

                            sao_wd_chroma,

                            sao_ht_chroma,

                            u4_bit_depth_chroma);

                    }

                }

                else

                {

                    if(PIXEL_SIZE_1BYTE == pixel_size_uv)

                    {

                        ps_codec->s_func_selector.ihevc_sao_band_offset_chroma_fptr(

                            pu1_src_chroma,

                            chroma_strd,

                            pu1_src_left_chroma,

                            pu1_src_top_chroma,

                            pu1_sao_src_chroma_top_left_ctb,

                            ps_sao->b5_cb_band_pos,

                            ps_sao->b5_cr_band_pos,

                            ai1_offset_cb,

                            ai1_offset_cr,

                            sao_wd_chroma,

                            sao_ht_chroma);

                    }

                    else

                    {

                        ps_codec->s_func_selector.ihevc_hbd_sao_band_offset_chroma_fptr(

                            (UWORD16 *)pu1_src_chroma,

                            chroma_strd,

                            (UWORD16 *)pu1_src_left_chroma,

                            (UWORD16 *)pu1_src_top_chroma,

                            (UWORD16 *)pu1_sao_src_chroma_top_left_ctb,

                            ps_sao->b5_cb_band_pos,

                            ps_sao->b5_cr_band_pos,

                            ai1_offset_cb,

                            ai1_offset_cr,

                            sao_wd_chroma,

                            sao_ht_chroma,

                            u4_bit_depth_chroma);

                    }

                }

            }

            else // if(2 <= ps_sao->b3_cb_type_idx)

            {

                ai1_offset_cb[1] = ps_sao->b8_cb_offset_1;

                ai1_offset_cb[2] = ps_sao->b8_cb_offset_2;

                ai1_offset_cb[3] = ps_sao->b8_cb_offset_3;

                ai1_offset_cb[4] = ps_sao->b8_cb_offset_4;

                ai1_offset_cr[1] = ps_sao->b8_cr_offset_1;

                ai1_offset_cr[2] = ps_sao->b8_cr_offset_2;

                ai1_offset_cr[3] = ps_sao->b8_cr_offset_3;

                ai1_offset_cr[4] = ps_sao->b8_cr_offset_4;

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

                {

                    au1_avail_chroma[i] = 255;

                    au1_tile_slice_boundary[i] = 0;

                    au4_idx_tl[i] = 0;

                    au4_ilf_across_tile_slice_enable[i] = 1;

                }

                /*In case of slices*/

                {

                    if((!ps_slice_hdr->i1_first_slice_in_pic_flag) || (ps_pps->i1_tiles_enabled_flag))

                    {

                        if((0 == (1 << log2_ctb_size) - sao_wd_chroma) && (ps_sao_ctxt->i4_ctb_y > 1) && (ps_sao_ctxt->i4_ctb_x > 1))

                        {

                            ctby_tl_t = ps_sao_ctxt->i4_ctb_y - 2;

                            ctbx_tl_l = ps_sao_ctxt->i4_ctb_x - 2;

                        }

                        else if(!(0 == (1 << log2_ctb_size) - sao_wd_chroma))

                        {

                            ctby_tl_t = ps_sao_ctxt->i4_ctb_y - 1;

                            ctbx_tl_l = ps_sao_ctxt->i4_ctb_x - 1;

                        }

                        ctbx_tl_t = ps_sao_ctxt->i4_ctb_x - 1;

                        ctby_tl_l = ps_sao_ctxt->i4_ctb_y - 1;

                        ctbx_tl_r = ps_sao_ctxt->i4_ctb_x;

                        ctby_tl_r = ps_sao_ctxt->i4_ctb_y - 1;

                        ctbx_tl_d =  ps_sao_ctxt->i4_ctb_x - 1;

                        ctby_tl_d =  ps_sao_ctxt->i4_ctb_y;

                        ctbx_tl = ps_sao_ctxt->i4_ctb_x - 1;

                        ctby_tl = ps_sao_ctxt->i4_ctb_y - 1;

                        if(!ps_slice_hdr->i1_first_slice_in_pic_flag)

                        {

                            idx_tl   = pu1_slice_idx[ctbx_tl + (ctby_tl * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[2] = au4_idx_tl[4] = *(pu1_slice_idx + ctbx_tl_t + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb));

                            au4_idx_tl[0] =  pu1_slice_idx[ctbx_tl_l + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[1] = au4_idx_tl[5] = pu1_slice_idx[ctbx_tl_r + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[3] = au4_idx_tl[6] =   pu1_slice_idx[ctbx_tl_d + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                            au4_idx_tl[7] = pu1_slice_idx[ctbx_tl_d + 1 + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                            if((0 == (1 << log2_ctb_size) - sao_wd_chroma))

                            {

                                if(ps_sao_ctxt->i4_ctb_x == 1)

                                {

                                    au4_idx_tl[6] = -1;

                                    au4_idx_tl[4] = -1;

                                }

                                else

                                {

                                    au4_idx_tl[6] = pu1_slice_idx[(ctbx_tl_d - 1) + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                                }

                                if(ps_sao_ctxt->i4_ctb_y == 1)

                                {

                                    au4_idx_tl[5] = -1;

                                    au4_idx_tl[4] = -1;

                                }

                                else

                                {

                                    au4_idx_tl[5] = pu1_slice_idx[(ctbx_tl_l + 1) + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                                    if(ctbx_tl_t > 0)

                                        au4_idx_tl[4] = pu1_slice_idx[(ctbx_tl_t - 1) + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb)];

                                }

                                au4_idx_tl[7] = pu1_slice_idx[(ctbx_tl_d + 1) + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                            }

                            /* Verify that the neighbor ctbs don't cross pic boundary

                             * Also, the ILF flag belonging to the higher pixel address (between neighbor and current pixels) must be assigned*/

                            if((0 == ((ps_sao_ctxt->i4_ctb_x << log2_ctb_size) * (chroma_pixel_strd / h_samp_factor)) - sao_wd_chroma))

                            {

                                au4_ilf_across_tile_slice_enable[4] = 0;

                                au4_ilf_across_tile_slice_enable[6] = 0;

                            }

                            else

                            {

                                au4_ilf_across_tile_slice_enable[6] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            if((0 == ((ps_sao_ctxt->i4_ctb_y << log2_ctb_size) / v_samp_factor) - sao_ht_chroma))

                            {

                                au4_ilf_across_tile_slice_enable[5] = 0;

                                au4_ilf_across_tile_slice_enable[4] = 0;

                            }

                            else

                            {

                                au4_ilf_across_tile_slice_enable[4] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                                au4_ilf_across_tile_slice_enable[5] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            if(au4_idx_tl[5] > idx_tl)

                            {

                                au4_ilf_across_tile_slice_enable[5] = (ps_slice_hdr_base + au4_idx_tl[5])->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            if(au4_idx_tl[6] > idx_tl)

                            {

                                au4_ilf_across_tile_slice_enable[6] = (ps_slice_hdr_base + au4_idx_tl[6])->i1_slice_loop_filter_across_slices_enabled_flag;

                            }

                            au4_ilf_across_tile_slice_enable[2] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[0] = (ps_slice_hdr_base + idx_tl)->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[1] = (ps_slice_hdr_base + au4_idx_tl[1])->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[3] = (ps_slice_hdr_base + au4_idx_tl[3])->i1_slice_loop_filter_across_slices_enabled_flag;

                            au4_ilf_across_tile_slice_enable[7] = (ps_slice_hdr_base + au4_idx_tl[7])->i1_slice_loop_filter_across_slices_enabled_flag;

                            /*

                             * Between each neighbor and the current CTB, the i1_slice_loop_filter_across_slices_enabled_flag

                             * of the pixel having a greater address is checked. Accordingly, set the availability flags

                             */

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

                            {

                                /*Sets the edges that lie on the slice/tile boundary*/

                                if(au4_idx_tl[i] != idx_tl)

                                {

                                    au1_tile_slice_boundary[i] = 1;

                                }

                                else

                                {

                                    au4_ilf_across_tile_slice_enable[i] = 1;

                                }

                            }

                            /*Reset indices*/

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

                            {

                                au4_idx_tl[i] = 0;

                            }

                        }

                        if(ps_pps->i1_tiles_enabled_flag)

                        {

                            /* Calculate availability flags at slice boundary */

                            if(((ps_tile->u1_pos_x == ps_sao_ctxt->i4_ctb_x) || (ps_tile->u1_pos_y == ps_sao_ctxt->i4_ctb_y)) && (!((0 == ps_tile->u1_pos_x) && (0 == ps_tile->u1_pos_y))))

                            {

                                /*If ilf across tiles is enabled, boundary availability for tiles is not checked. */

                                if(!ps_pps->i1_loop_filter_across_tiles_enabled_flag)

                                {

                                    /*Set the boundary arrays*/

                                    /*Calculate tile indices for neighbor pixels*/

                                    idx_tl   = pu1_tile_idx[ctbx_tl + (ctby_tl * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[2] = au4_idx_tl[4] = *(pu1_tile_idx + ctbx_tl_t + (ctby_tl_t * ps_sps->i2_pic_wd_in_ctb));

                                    au4_idx_tl[0] =  pu1_tile_idx[ctbx_tl_l + (ctby_tl_l * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[1] = au4_idx_tl[5] = pu1_tile_idx[ctbx_tl_r + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[3] = au4_idx_tl[6] =   pu1_tile_idx[ctbx_tl_d + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                                    au4_idx_tl[7] = pu1_tile_idx[ctbx_tl_d + 1 + (ctby_tl_d * ps_sps->i2_pic_wd_in_ctb)];

                                    if((0 == (1 << log2_ctb_size) - sao_wd_luma))

                                    {

                                        if(ps_sao_ctxt->i4_ctb_x == 1)

                                        {

                                            au4_idx_tl[6] = -1;

                                            au4_idx_tl[4] = -1;

                                        }

                                        else

                                        {

                                            au4_idx_tl[6] = pu1_tile_idx[(ctbx_tl_d - 1) + (ctby_tl_r * ps_sps->i2_pic_wd_in_ctb)];

                                        }