xref: /aosp_15_r20/external/libavc/common/svc/isvc_intra_resample.c (revision 495ae853bb871d1e5a258cb02c2cc13cde8ddb9a)

/******************************************************************************
 *
 * Copyright (C) 2022 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 isvcd_resamp_svc.c
 *
 * \brief
 *    Contains routines that resample for SVC resampling
 *
 * Detailed_description
 *
 * \date
 *
 *
 * \author
 **************************************************************************
 */
#include <assert.h>
#include <string.h>

#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "isvc_macros.h"
#include "ih264_platform_macros.h"
#include "isvc_intra_resample.h"
#include "ih264_debug.h"
#include "isvc_defs.h"
#include "isvc_structs.h"

#define NUM_SEGMENTS 16
#define NUM_INTRA_SAMP_FXNS 32
#define INTERPOL_FILTER_SIZE_LUMA 64
#define INTERPOL_FILTER_SIZE_CHROMA 32

typedef void(PF_INTRA_SAMP_PADDING)(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index, WORD8 i1_yd_index,
                                    UWORD8 u1_seg_wd, UWORD8 u1_seg_ht, UWORD8 *pu1_refarray_1,
                                    UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                                    WORD32 i4_mb_adjoin_x, WORD32 i4_mb_adjoin_y,
                                    WORD32 i4_corner_pixel_available);

static const WORD8 g_ai1_interp_filter_luma[INTERPOL_FILTER_SIZE_LUMA] = {
    0,  -1, -2, -3, -3, -4, -4, -3, -3, -3, -2, -1, -1, -1, -1, -1, 32, 32, 31, 30, 28, 26,
    24, 22, 19, 16, 14, 11, 8,  6,  4,  2,  0,  2,  4,  6,  8,  11, 14, 16, 19, 22, 24, 26,
    28, 30, 31, 32, 0,  -1, -1, -1, -1, -1, -2, -3, -3, -3, -4, -4, -3, -3, -2, -1};

static const UWORD8 g_au1_interp_filter_chroma[INTERPOL_FILTER_SIZE_CHROMA] = {
    32, 30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8,  6,  4,  2,
    0,  2,  4,  6,  8,  10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30};

static const UWORD32 gu4_valid_segs_lookup[NUM_SEGMENTS] = {
    0x0F000000, 0xCF000000, 0x3F000000, 0xFF000000, 0x0F000000, 0xCF000000, 0x3F000000, 0xFF000000,
    0x0F000000, 0x8F000000, 0x6F000000, 0xEF000000, 0x1F000000, 0x9F000000, 0x7F000000, 0xFF000000};

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_copy_data                                           */
/*                                                                           */
/*  Description   : this module copies the data from source to destination   */
/*                  the amount of data to be copied is passed as input       */
/*                                                                           */
/*  Inputs        : pu1_src : pointer to the source buffer                   */
/*                  u2_src_stride : source buffer stride                     */
/*                  pu1_dst : pointer to the destination buffer              */
/*                  u2_dst_stride : destination buffer stride                */
/*                  u4_num_bytes : number of bytes to be copied              */
/*                  u4_num_lines : number of lines to be copied              */
/*  Globals       : none                                                     */
/*  Processing    : it does a memcpy from source to destination              */
/*                                                                           */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*  Issues        : both buffers are assumed to be 2-D buffers               */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         29 04 2009   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
/** \brief performs the 2-D memory transfer  */
static void isvc_copy_data(UWORD8 *pu1_src, WORD32 i4_src_stride, UWORD8 *pu1_dst,
                           WORD32 i4_dst_stride, WORD32 i4_num_bytes, WORD32 i4_num_lines)
{
    WORD32 i4_vert_lines;
    ASSERT(NULL != pu1_src);
    ASSERT(NULL != pu1_dst);

    for(i4_vert_lines = 0; i4_vert_lines < i4_num_lines; i4_vert_lines++)
    {
        memcpy(pu1_dst, pu1_src, i4_num_bytes);
        pu1_src += i4_src_stride;
        pu1_dst += i4_dst_stride;
    }
}

static void isvc_copy_data_semiplanr(UWORD8 *pu1_src, WORD32 i4_src_stride, UWORD8 *pu1_dst1,
                                     UWORD8 *pu1_dst2, WORD32 i4_dst_stride, WORD32 i4_num_bytes,
                                     WORD32 i4_num_lines)
{
    WORD32 i4_vert_lines, u4_i;

    ASSERT(NULL != pu1_src);
    ASSERT(NULL != pu1_dst1);
    ASSERT(NULL != pu1_dst2);

    for(i4_vert_lines = 0; i4_vert_lines < i4_num_lines; i4_vert_lines++)
    {
        for(u4_i = 0; u4_i < i4_num_bytes; u4_i++)
        {
            *(pu1_dst1 + u4_i) = *(pu1_src + (2 * u4_i));
            *(pu1_dst2 + u4_i) = *(pu1_src + (2 * u4_i) + 1);
        }
        pu1_src += i4_src_stride;
        pu1_dst1 += i4_dst_stride;
        pu1_dst2 += i4_dst_stride;
    }
}

static void isvc_left_right_padding(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index, WORD8 i1_yd_index,
                                    UWORD8 u1_seg_wd, UWORD8 u1_seg_ht, UWORD8 *pu1_refarray_1,
                                    UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                                    WORD32 i4_mb_adjoin_x, WORD32 i4_mb_adjoin_y,
                                    WORD32 i4_corner_pixel_available)
{
    WORD32 i4_idx_i;
    UWORD8 *pu1_src, *pu1_dst;

    UNUSED(i1_yd_index);
    UNUSED(pu1_refarray_2);
    UNUSED(i4_mb_adjoin_x);
    UNUSED(i4_mb_adjoin_y);
    UNUSED(i4_corner_pixel_available);

    pu1_dst = pu1_refarray_1 + i4_x + (i4_y * i4_refarray_stride);
    pu1_src = pu1_dst + i1_xd_index;

    i1_xd_index = MIN(i1_xd_index, MAX_PIX_FILL_LUMA);
    u1_seg_wd = MIN(u1_seg_wd, MAX_PIX_FILL_LUMA);
    pu1_dst = pu1_src - i1_xd_index;

    for(i4_idx_i = 0; i4_idx_i < u1_seg_ht; i4_idx_i++)
    {
        memset(pu1_dst, *pu1_src, u1_seg_wd);
        pu1_dst += i4_refarray_stride;
        pu1_src += i4_refarray_stride;
    }
}

static void isvc_left_right_padding_chroma(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index,
                                           WORD8 i1_yd_index, UWORD8 u1_seg_wd, UWORD8 u1_seg_ht,
                                           UWORD8 *pu1_refarray_1, UWORD8 *pu1_refarray_2,
                                           WORD32 i4_refarray_stride, WORD32 i4_mb_adjoin_x,
                                           WORD32 i4_mb_adjoin_y, WORD32 i4_corner_pixel_available)
{
    WORD32 i4_idx_i;
    UWORD8 *pu1_src_cb, *pu1_dst_cb;
    UWORD8 *pu1_src_cr, *pu1_dst_cr;
    WORD32 i4_tmp;

    UNUSED(i1_yd_index);
    UNUSED(i4_mb_adjoin_x);
    UNUSED(i4_mb_adjoin_y);
    UNUSED(i4_corner_pixel_available);

    i4_tmp = i4_x + (i4_y * i4_refarray_stride);
    pu1_dst_cb = pu1_refarray_1 + i4_tmp;
    pu1_src_cb = pu1_dst_cb + i1_xd_index;

    pu1_dst_cr = pu1_refarray_2 + i4_tmp;
    pu1_src_cr = pu1_dst_cr + i1_xd_index;

    i1_xd_index = MIN(i1_xd_index, MAX_PIX_FILL_CHROMA);
    u1_seg_wd = MIN(u1_seg_wd, MAX_PIX_FILL_CHROMA);
    pu1_dst_cb = pu1_src_cb - i1_xd_index;
    pu1_dst_cr = pu1_src_cr - i1_xd_index;

    for(i4_idx_i = 0; i4_idx_i < u1_seg_ht; i4_idx_i++)
    {
        memset(pu1_dst_cb, *pu1_src_cb, u1_seg_wd);
        pu1_dst_cb += i4_refarray_stride;
        pu1_src_cb += i4_refarray_stride;

        memset(pu1_dst_cr, *pu1_src_cr, u1_seg_wd);
        pu1_dst_cr += i4_refarray_stride;
        pu1_src_cr += i4_refarray_stride;
    }
}

static void isvc_top_bot_padding(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index, WORD8 i1_yd_index,
                                 UWORD8 u1_seg_wd, UWORD8 u1_seg_ht, UWORD8 *pu1_refarray_1,
                                 UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                                 WORD32 i4_mb_adjoin_x, WORD32 i4_mb_adjoin_y,
                                 WORD32 i4_corner_pixel_available)
{
    WORD32 i4_idx_i;
    UWORD8 *pu1_src, *pu1_dst;

    UNUSED(i1_xd_index);
    UNUSED(pu1_refarray_2);
    UNUSED(i4_mb_adjoin_x);
    UNUSED(i4_mb_adjoin_y);
    UNUSED(i4_corner_pixel_available);

    pu1_dst = pu1_refarray_1 + i4_x + (i4_y * i4_refarray_stride);
    pu1_src = pu1_dst + (i1_yd_index * i4_refarray_stride);

    i1_yd_index = MIN(i1_yd_index, MAX_PIX_FILL_LUMA);
    u1_seg_ht = MIN(u1_seg_ht, MAX_PIX_FILL_LUMA);
    pu1_dst = pu1_src - (i1_yd_index * i4_refarray_stride);

    for(i4_idx_i = 0; i4_idx_i < u1_seg_ht; i4_idx_i++)
    {
        memcpy(pu1_dst, pu1_src, u1_seg_wd);
        pu1_dst += i4_refarray_stride;
    }
}

static void isvc_top_bot_padding_chroma(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index,
                                        WORD8 i1_yd_index, UWORD8 u1_seg_wd, UWORD8 u1_seg_ht,
                                        UWORD8 *pu1_refarray_1, UWORD8 *pu1_refarray_2,
                                        WORD32 i4_refarray_stride, WORD32 i4_mb_adjoin_x,
                                        WORD32 i4_mb_adjoin_y, WORD32 i4_corner_pixel_available)
{
    WORD32 i4_idx_i;
    UWORD8 *pu1_src_cb, *pu1_dst_cb;
    UWORD8 *pu1_src_cr, *pu1_dst_cr;
    WORD32 i4_tmp;

    UNUSED(i1_xd_index);
    UNUSED(i4_mb_adjoin_x);
    UNUSED(i4_mb_adjoin_y);
    UNUSED(i4_corner_pixel_available);

    i4_tmp = i4_x + (i4_y * i4_refarray_stride);
    pu1_dst_cb = pu1_refarray_1 + i4_tmp;
    pu1_dst_cr = pu1_refarray_2 + i4_tmp;

    i4_tmp = (i1_yd_index * i4_refarray_stride);
    pu1_src_cb = pu1_dst_cb + i4_tmp;
    pu1_src_cr = pu1_dst_cr + i4_tmp;

    i1_yd_index = MIN(i1_yd_index, MAX_PIX_FILL_CHROMA);
    u1_seg_ht = MIN(u1_seg_ht, MAX_PIX_FILL_CHROMA);

    i4_tmp = (i1_yd_index * i4_refarray_stride);
    pu1_dst_cb = pu1_src_cb - i4_tmp;

    pu1_dst_cr = pu1_src_cr - i4_tmp;

    for(i4_idx_i = 0; i4_idx_i < u1_seg_ht; i4_idx_i++)
    {
        memcpy(pu1_dst_cb, pu1_src_cb, u1_seg_wd);
        pu1_dst_cb += i4_refarray_stride;

        memcpy(pu1_dst_cr, pu1_src_cr, u1_seg_wd);
        pu1_dst_cr += i4_refarray_stride;
    }
}

static void isvc_diag_reconstruction(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index, WORD8 i1_yd_index,
                                     UWORD8 u1_seg_wd, UWORD8 u1_seg_ht, UWORD8 *pu1_refarray_1,
                                     UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                                     WORD32 i4_mb_adjoin_x, WORD32 i4_mb_adjoin_y,
                                     WORD32 i4_corner_pixel_available)
{
    WORD32 i4_i;
    UWORD8 *pu1_src_1, *pu1_src_2, *pu1_dst;
    UWORD8 u1_filter_delay_buf[18];
    UWORD8 u1_out_buf[16];
    WORD32 i4_width, i4_height;
    WORD32 i4_x_off, i4_y_off;
    WORD32 i4_block_size = BLK_SIZE;

    UNUSED(pu1_refarray_2);

    pu1_dst = pu1_refarray_1 + i4_x + (i4_y * i4_refarray_stride);
    pu1_src_1 = pu1_dst + i1_xd_index;
    pu1_src_2 = pu1_dst + (i1_yd_index * i4_refarray_stride);

    i4_width = MAX(u1_seg_wd, (((i4_mb_adjoin_x >> 3) ^ 1) * i4_block_size));
    i4_height = MAX(u1_seg_ht, (((i4_mb_adjoin_y >> 4) ^ 1) * i4_block_size));

    i4_x_off = (i4_width - u1_seg_wd);
    i4_y_off = (i4_height - u1_seg_ht);

    if(i1_xd_index > 0 && i1_yd_index > 0)
    {
        /* Quadrant 1 Processing */

        /* load the pixel in the filter delay buffer  */
        memcpy(&u1_filter_delay_buf[0], pu1_src_2, (i4_width + 1));
        for(i4_i = i4_height; i4_i > 0; i4_i--)
        {
            u1_filter_delay_buf[i4_width + i4_i] = *pu1_src_1;
            pu1_src_1 += i4_refarray_stride;
        }

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf[i4_width] =
                (u1_filter_delay_buf[i4_width - 1] + u1_filter_delay_buf[i4_width + 1] + 1) >> 1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf[i4_i] = ((u1_filter_delay_buf[i4_i]) + (u1_filter_delay_buf[i4_i + 1] * 2) +
                                (u1_filter_delay_buf[i4_i + 2]) + 2) >>
                               2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 1; i4_i <= u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst, &u1_out_buf[i4_height - i4_i], u1_seg_wd);
            pu1_dst += i4_refarray_stride;
        }
    }
    else if(i1_xd_index < 0 && i1_yd_index > 0)
    {
        /* Quadrant 2 Processing */
        /* load the pixel in the filter delay buffer  */
        for(i4_i = 0; i4_i < (i4_height + 1); i4_i++)
        {
            u1_filter_delay_buf[i4_i] = *pu1_src_1;
            pu1_src_1 += i4_refarray_stride;
        }

        pu1_src_2 -= i4_x_off;
        memcpy(&u1_filter_delay_buf[i4_i], pu1_src_2, i4_width);

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf[i4_i - 1] =
                (u1_filter_delay_buf[i4_i] + u1_filter_delay_buf[i4_i - 2] + 1) >> 1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf[i4_i] = ((u1_filter_delay_buf[i4_i]) + (u1_filter_delay_buf[i4_i + 1] * 2) +
                                (u1_filter_delay_buf[i4_i + 2]) + 2) >>
                               2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 0; i4_i < u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst, &u1_out_buf[i4_x_off + i4_i], u1_seg_wd);
            pu1_dst += i4_refarray_stride;
        }
    }
    else if(i1_xd_index > 0 && i1_yd_index < 0)
    {
        /* Quadrant 3 Processing */
        /* load the pixel in the filter delay buffer  */
        memcpy(&u1_filter_delay_buf[0], pu1_src_2, (i4_width + 1));

        pu1_src_1 -= (i4_y_off * i4_refarray_stride);
        for(i4_i = 1; i4_i <= i4_height; i4_i++)
        {
            u1_filter_delay_buf[i4_width + i4_i] = *pu1_src_1;
            pu1_src_1 += i4_refarray_stride;
        }

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf[i4_width] =
                (u1_filter_delay_buf[i4_width - 1] + u1_filter_delay_buf[i4_width + 1] + 1) >> 1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf[i4_i] = ((u1_filter_delay_buf[i4_i]) + (u1_filter_delay_buf[i4_i + 1] * 2) +
                                (u1_filter_delay_buf[i4_i + 2]) + 2) >>
                               2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 0; i4_i < u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst, &u1_out_buf[i4_y_off + i4_i], u1_seg_wd);
            pu1_dst += i4_refarray_stride;
        }
    }
    else
    {
        /* Quadrant 4 Processing */
        /* load the pixel in the filter delay buffer  */
        pu1_src_1 += ((u1_seg_ht - 1) * i4_refarray_stride);
        for(i4_i = 0; i4_i <= i4_height; i4_i++)
        {
            u1_filter_delay_buf[i4_i] = *pu1_src_1;
            pu1_src_1 -= i4_refarray_stride;
        }

        pu1_src_2 -= i4_x_off;
        memcpy(&u1_filter_delay_buf[i4_i], pu1_src_2, i4_width);

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf[i4_i - 1] =
                (u1_filter_delay_buf[i4_i] + u1_filter_delay_buf[i4_i - 2] + 1) >> 1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf[i4_i] = ((u1_filter_delay_buf[i4_i]) + (u1_filter_delay_buf[i4_i + 1] * 2) +
                                (u1_filter_delay_buf[i4_i + 2]) + 2) >>
                               2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 1; i4_i <= u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst, &u1_out_buf[(u1_seg_ht + i4_x_off) - i4_i], u1_seg_wd);
            pu1_dst += i4_refarray_stride;
        }
    }
}

static void isvc_diag_reconstruction_chroma(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index,
                                            WORD8 i1_yd_index, UWORD8 u1_seg_wd, UWORD8 u1_seg_ht,
                                            UWORD8 *pu1_refarray_1, UWORD8 *pu1_refarray_2,
                                            WORD32 i4_refarray_stride, WORD32 i4_mb_adjoin_x,
                                            WORD32 i4_mb_adjoin_y, WORD32 i4_corner_pixel_available)
{
    WORD32 i4_i;
    UWORD8 u1_filter_delay_buf_cb[18], u1_filter_delay_buf_cr[18];
    UWORD8 u1_out_buf_cb[16], u1_out_buf_cr[16];
    WORD32 i4_width, i4_height;
    WORD32 i4_x_off, i4_y_off;
    WORD32 i4_block_size = BLK_SIZE >> 1;
    UWORD8 *pu1_src_1_cb, *pu1_src_2_cb, *pu1_dst_cb;
    UWORD8 *pu1_src_1_cr, *pu1_src_2_cr, *pu1_dst_cr;
    WORD32 i4_tmp;

    i4_tmp = i4_x + (i4_y * i4_refarray_stride);
    pu1_dst_cb = pu1_refarray_1 + i4_tmp;
    pu1_dst_cr = pu1_refarray_2 + i4_tmp;

    pu1_src_1_cb = pu1_dst_cb + i1_xd_index;
    pu1_src_1_cr = pu1_dst_cr + i1_xd_index;

    i4_tmp = (i1_yd_index * i4_refarray_stride);
    pu1_src_2_cb = pu1_dst_cb + i4_tmp;
    pu1_src_2_cr = pu1_dst_cr + i4_tmp;

    i4_width = MAX(u1_seg_wd, (((i4_mb_adjoin_x >> 3) ^ 1) * i4_block_size));
    i4_height = MAX(u1_seg_ht, (((i4_mb_adjoin_y >> 4) ^ 1) * i4_block_size));

    i4_x_off = (i4_width - u1_seg_wd);
    i4_y_off = (i4_height - u1_seg_ht);

    if(i1_xd_index < 0 && i1_yd_index > 0)
    {
        /* Quadrant 1 Processing */

        /* load the pixel in the filter delay buffer  */
        for(i4_i = 0; i4_i < (i4_height + 1); i4_i++)
        {
            u1_filter_delay_buf_cb[i4_i] = *pu1_src_1_cb;
            pu1_src_1_cb += i4_refarray_stride;

            u1_filter_delay_buf_cr[i4_i] = *pu1_src_1_cr;
            pu1_src_1_cr += i4_refarray_stride;
        }

        pu1_src_2_cb -= i4_x_off;
        pu1_src_2_cr -= i4_x_off;

        memcpy(&u1_filter_delay_buf_cb[i4_i], pu1_src_2_cb, i4_width);
        memcpy(&u1_filter_delay_buf_cr[i4_i], pu1_src_2_cr, i4_width);

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf_cb[i4_i - 1] =
                (u1_filter_delay_buf_cb[i4_i] + u1_filter_delay_buf_cb[i4_i - 2] + 1) >> 1;

            u1_filter_delay_buf_cr[i4_i - 1] =
                (u1_filter_delay_buf_cr[i4_i] + u1_filter_delay_buf_cr[i4_i - 2] + 1) >> 1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf_cb[i4_i] =
                ((u1_filter_delay_buf_cb[i4_i]) + (u1_filter_delay_buf_cb[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cb[i4_i + 2]) + 2) >>
                2;

            u1_out_buf_cr[i4_i] =
                ((u1_filter_delay_buf_cr[i4_i]) + (u1_filter_delay_buf_cr[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cr[i4_i + 2]) + 2) >>
                2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 0; i4_i < u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst_cb, &u1_out_buf_cb[i4_x_off + i4_i], u1_seg_wd);
            pu1_dst_cb += i4_refarray_stride;

            memcpy(pu1_dst_cr, &u1_out_buf_cr[i4_x_off + i4_i], u1_seg_wd);
            pu1_dst_cr += i4_refarray_stride;
        }
    }
    else if(i1_xd_index > 0 && i1_yd_index > 0)
    {
        /* Quadrant 2 Processing */

        /* load the pixel in the filter delay buffer  */
        memcpy(&u1_filter_delay_buf_cb[0], pu1_src_2_cb, (i4_width + 1));
        memcpy(&u1_filter_delay_buf_cr[0], pu1_src_2_cr, (i4_width + 1));

        for(i4_i = i4_height; i4_i > 0; i4_i--)
        {
            u1_filter_delay_buf_cb[i4_width + i4_i] = *pu1_src_1_cb;
            pu1_src_1_cb += i4_refarray_stride;

            u1_filter_delay_buf_cr[i4_width + i4_i] = *pu1_src_1_cr;
            pu1_src_1_cr += i4_refarray_stride;
        }

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf_cb[i4_width] =
                (u1_filter_delay_buf_cb[i4_width - 1] + u1_filter_delay_buf_cb[i4_width + 1] + 1) >>
                1;

            u1_filter_delay_buf_cr[i4_width] =
                (u1_filter_delay_buf_cr[i4_width - 1] + u1_filter_delay_buf_cr[i4_width + 1] + 1) >>
                1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf_cb[i4_i] =
                ((u1_filter_delay_buf_cb[i4_i]) + (u1_filter_delay_buf_cb[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cb[i4_i + 2]) + 2) >>
                2;

            u1_out_buf_cr[i4_i] =
                ((u1_filter_delay_buf_cr[i4_i]) + (u1_filter_delay_buf_cr[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cr[i4_i + 2]) + 2) >>
                2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 1; i4_i <= u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst_cb, &u1_out_buf_cb[i4_height - i4_i], u1_seg_wd);
            pu1_dst_cb += i4_refarray_stride;

            memcpy(pu1_dst_cr, &u1_out_buf_cr[i4_height - i4_i], u1_seg_wd);
            pu1_dst_cr += i4_refarray_stride;
        }
    }
    else if(i1_xd_index > 0 && i1_yd_index < 0)
    {
        /* Quadrant 3 Processing */

        /* load the pixel in the filter delay buffer  */
        memcpy(&u1_filter_delay_buf_cb[0], pu1_src_2_cb, (i4_width + 1));
        memcpy(&u1_filter_delay_buf_cr[0], pu1_src_2_cr, (i4_width + 1));

        i4_tmp = (i4_y_off * i4_refarray_stride);
        pu1_src_1_cb -= i4_tmp;
        pu1_src_1_cr -= i4_tmp;
        for(i4_i = 1; i4_i <= i4_height; i4_i++)
        {
            u1_filter_delay_buf_cb[i4_width + i4_i] = *pu1_src_1_cb;
            pu1_src_1_cb += i4_refarray_stride;

            u1_filter_delay_buf_cr[i4_width + i4_i] = *pu1_src_1_cr;
            pu1_src_1_cr += i4_refarray_stride;
        }

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf_cb[i4_width] =
                (u1_filter_delay_buf_cb[i4_width - 1] + u1_filter_delay_buf_cb[i4_width + 1] + 1) >>
                1;

            u1_filter_delay_buf_cr[i4_width] =
                (u1_filter_delay_buf_cr[i4_width - 1] + u1_filter_delay_buf_cr[i4_width + 1] + 1) >>
                1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf_cb[i4_i] =
                ((u1_filter_delay_buf_cb[i4_i]) + (u1_filter_delay_buf_cb[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cb[i4_i + 2]) + 2) >>
                2;

            u1_out_buf_cr[i4_i] =
                ((u1_filter_delay_buf_cr[i4_i]) + (u1_filter_delay_buf_cr[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cr[i4_i + 2]) + 2) >>
                2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 0; i4_i < u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst_cb, &u1_out_buf_cb[i4_y_off + i4_i], u1_seg_wd);
            pu1_dst_cb += i4_refarray_stride;

            memcpy(pu1_dst_cr, &u1_out_buf_cr[i4_y_off + i4_i], u1_seg_wd);
            pu1_dst_cr += i4_refarray_stride;
        }
    }
    else
    {
        /* Quadrant 4 Processing */

        /* load the pixel in the filter delay buffer  */
        i4_tmp = ((u1_seg_ht - 1) * i4_refarray_stride);
        pu1_src_1_cb += i4_tmp;
        pu1_src_1_cr += i4_tmp;

        for(i4_i = 0; i4_i <= i4_height; i4_i++)
        {
            u1_filter_delay_buf_cb[i4_i] = *pu1_src_1_cb;
            pu1_src_1_cb -= i4_refarray_stride;

            u1_filter_delay_buf_cr[i4_i] = *pu1_src_1_cr;
            pu1_src_1_cr -= i4_refarray_stride;
        }

        pu1_src_2_cb -= i4_x_off;
        pu1_src_2_cr -= i4_x_off;

        memcpy(&u1_filter_delay_buf_cb[i4_i], pu1_src_2_cb, i4_width);
        memcpy(&u1_filter_delay_buf_cr[i4_i], pu1_src_2_cr, i4_width);

        if(0 == i4_corner_pixel_available)
        {
            /* interpolate the unavailable corner pixel */
            u1_filter_delay_buf_cb[i4_i - 1] =
                (u1_filter_delay_buf_cb[i4_i] + u1_filter_delay_buf_cb[i4_i - 2] + 1) >> 1;

            u1_filter_delay_buf_cr[i4_i - 1] =
                (u1_filter_delay_buf_cr[i4_i] + u1_filter_delay_buf_cr[i4_i - 2] + 1) >> 1;
        }

        for(i4_i = 0; i4_i < (i4_width + i4_height - 1); i4_i++)
        {
            /* get the filtered output */
            u1_out_buf_cb[i4_i] =
                ((u1_filter_delay_buf_cb[i4_i]) + (u1_filter_delay_buf_cb[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cb[i4_i + 2]) + 2) >>
                2;

            u1_out_buf_cr[i4_i] =
                ((u1_filter_delay_buf_cr[i4_i]) + (u1_filter_delay_buf_cr[i4_i + 1] * 2) +
                 (u1_filter_delay_buf_cr[i4_i + 2]) + 2) >>
                2;
        }

        /* fill the segment with diagonal reconstructed output */
        for(i4_i = 1; i4_i <= u1_seg_ht; i4_i++)
        {
            memcpy(pu1_dst_cb, &u1_out_buf_cb[(u1_seg_ht + i4_x_off) - i4_i], u1_seg_wd);
            pu1_dst_cb += i4_refarray_stride;

            memcpy(pu1_dst_cr, &u1_out_buf_cr[(u1_seg_ht + i4_x_off) - i4_i], u1_seg_wd);
            pu1_dst_cr += i4_refarray_stride;
        }
    }
}

static void isvc_diag_padding(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index, WORD8 i1_yd_index,
                              UWORD8 u1_seg_wd, UWORD8 u1_seg_ht, UWORD8 *pu1_refarray_1,
                              UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                              WORD32 i4_mb_adjoin_x, WORD32 i4_mb_adjoin_y,
                              WORD32 i4_corner_pixel_available)

{
    WORD32 i4_idx_i;
    UWORD8 *pu1_src, *pu1_dst;

    UNUSED(pu1_refarray_2);
    UNUSED(i4_mb_adjoin_x);
    UNUSED(i4_mb_adjoin_y);
    UNUSED(i4_corner_pixel_available);

    pu1_dst = pu1_refarray_1 + i4_x + (i4_y * i4_refarray_stride);
    pu1_src = pu1_dst + i1_xd_index + (i1_yd_index * i4_refarray_stride);

    i1_xd_index = MIN(i1_xd_index, MAX_PIX_FILL_LUMA);
    u1_seg_wd = MIN(u1_seg_wd, MAX_PIX_FILL_LUMA);

    i1_yd_index = MIN(i1_yd_index, MAX_PIX_FILL_LUMA);
    u1_seg_ht = MIN(u1_seg_ht, MAX_PIX_FILL_LUMA);
    pu1_dst = pu1_src - i1_xd_index - (i1_yd_index * i4_refarray_stride);

    for(i4_idx_i = 0; i4_idx_i < u1_seg_ht; i4_idx_i++)
    {
        memset(pu1_dst, *pu1_src, u1_seg_wd);
        pu1_dst += i4_refarray_stride;
    }
}

static void isvc_diag_padding_chroma(WORD32 i4_x, WORD32 i4_y, WORD8 i1_xd_index, WORD8 i1_yd_index,
                                     UWORD8 u1_seg_wd, UWORD8 u1_seg_ht, UWORD8 *pu1_refarray_1,
                                     UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                                     WORD32 i4_mb_adjoin_x, WORD32 i4_mb_adjoin_y,
                                     WORD32 i4_corner_pixel_available)
{
    WORD32 i4_idx_i;
    UWORD8 *pu1_src_cb, *pu1_dst_cb;
    UWORD8 *pu1_src_cr, *pu1_dst_cr;
    WORD32 i4_tmp;

    UNUSED(i4_mb_adjoin_x);
    UNUSED(i4_mb_adjoin_y);
    UNUSED(i4_corner_pixel_available);

    i4_tmp = i4_x + (i4_y * i4_refarray_stride);
    pu1_dst_cb = pu1_refarray_1 + i4_tmp;
    pu1_dst_cr = pu1_refarray_2 + i4_tmp;

    i4_tmp = i1_xd_index + (i1_yd_index * i4_refarray_stride);
    pu1_src_cb = pu1_dst_cb + i4_tmp;
    pu1_src_cr = pu1_dst_cr + i4_tmp;

    i1_xd_index = MIN(i1_xd_index, MAX_PIX_FILL_LUMA);
    u1_seg_wd = MIN(u1_seg_wd, MAX_PIX_FILL_LUMA);

    i1_yd_index = MIN(i1_yd_index, MAX_PIX_FILL_LUMA);
    u1_seg_ht = MIN(u1_seg_ht, MAX_PIX_FILL_LUMA);

    i4_tmp = (i1_xd_index + (i1_yd_index * i4_refarray_stride));
    pu1_dst_cb = pu1_src_cb - i4_tmp;
    pu1_dst_cr = pu1_src_cr - i4_tmp;

    for(i4_idx_i = 0; i4_idx_i < u1_seg_ht; i4_idx_i++)
    {
        memset(pu1_dst_cb, *pu1_src_cb, u1_seg_wd);
        pu1_dst_cb += i4_refarray_stride;

        memset(pu1_dst_cr, *pu1_src_cr, u1_seg_wd);
        pu1_dst_cr += i4_refarray_stride;
    }
}

static PF_INTRA_SAMP_PADDING *gpf_lookup_fxns_luma[NUM_INTRA_SAMP_FXNS] = {
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    &isvc_left_right_padding,
    NULL,
    &isvc_diag_reconstruction,
    NULL,
    &isvc_left_right_padding,
    NULL,
    &isvc_diag_reconstruction,
    NULL,
    NULL,
    &isvc_top_bot_padding,
    &isvc_diag_reconstruction,
    NULL,
    NULL,
    &isvc_top_bot_padding,
    &isvc_diag_reconstruction,
    NULL,
    &isvc_left_right_padding,
    &isvc_top_bot_padding,
    &isvc_diag_reconstruction,
    &isvc_diag_padding,
    &isvc_left_right_padding,
    &isvc_top_bot_padding,
    &isvc_diag_reconstruction,
};

static PF_INTRA_SAMP_PADDING *gpf_lookup_fxns_chroma[NUM_INTRA_SAMP_FXNS] = {
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    &isvc_left_right_padding_chroma,
    NULL,
    &isvc_diag_reconstruction_chroma,
    NULL,
    &isvc_left_right_padding_chroma,
    NULL,
    &isvc_diag_reconstruction_chroma,
    NULL,
    NULL,
    &isvc_top_bot_padding_chroma,
    &isvc_diag_reconstruction_chroma,
    NULL,
    NULL,
    &isvc_top_bot_padding_chroma,
    &isvc_diag_reconstruction_chroma,
    NULL,
    &isvc_left_right_padding_chroma,
    &isvc_top_bot_padding_chroma,
    &isvc_diag_reconstruction_chroma,
    &isvc_diag_padding_chroma,
    &isvc_left_right_padding_chroma,
    &isvc_top_bot_padding_chroma,
    &isvc_diag_reconstruction_chroma,
};

static void isvc_get_ref_layer_avlblty_dyadic(WORD8 *pi1_ref_mb_modes, WORD32 i4_ref_mode_stride,
                                              WORD32 i4_element_size, WORD32 i4_ref_mb_x,
                                              WORD32 i4_ref_mb_y, WORD32 *pi4_avlblty,
                                              WORD8 i1_curr_slice_id, WORD8 i1_cons_intr_samp_flag)
{
    WORD8 i1_mb_mode;

    pi1_ref_mb_modes += (i4_ref_mb_y * i4_ref_mode_stride * i4_element_size);
    pi1_ref_mb_modes += (i4_ref_mb_x * i4_element_size);
    i1_mb_mode = *pi1_ref_mb_modes;
    i1_mb_mode = (i1_mb_mode < 0) ? i1_mb_mode : SVC_EXTRACT_MB_MODE(*pi1_ref_mb_modes);

    if(i1_mb_mode <= SVC_INTER_MB)
    {
        *pi4_avlblty = 0;
    }
    else
    {
        *pi4_avlblty = 1;
    }

    if(1 == i1_cons_intr_samp_flag)
    {
        if(1 == *pi4_avlblty)
        {
            if(i1_mb_mode != i1_curr_slice_id)
            {
                *pi4_avlblty = 0;
            }
        }
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_diagonal_construct_dyadic                          */
/*                                                                           */
/*  Description   : This function fills the unavaible pixels in the reference*/
/*                  array with diagonally constructed samples                */
/*  Inputs        : i4_x :current position in reference array X to be filled */
/*                  i4_y :current position in reference array Y to be filled */
/*                  i4_xd_index : diagonal index in horizontal direction     */
/*                  i4_yd_index : diagonal index in vertical direction       */
/*                  pu1_refarray : popinter to reference array               */
/*                  i4_refarray_wd: width of the reference array             */
/*  Globals       : none                                                     */
/*  Processing    : Fills the sample which is unavailable with filtered      */
/*                  diagonal samples                                         */
/*  Outputs       : pixel filled                                             */
/*  Returns       : constructed pixel                                        */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 12 2010   Nithya          creation                             */
/*                                                                           */
/*****************************************************************************/
static UWORD8 isvc_diagonal_construct_dyadic(WORD32 i4_x, WORD32 i4_y, WORD32 i4_xd_index,
                                             WORD32 i4_yd_index, UWORD8 *pu1_refarray,
                                             WORD32 i4_refarray_wd)
{
    WORD32 i4_diff_hor_ver, i4_sgn_xy;
    WORD32 i4_xc, i4_yc;
    WORD32 i4_samp1, i4_samp2, i4_samp3;
    WORD32 i4_result;
    UWORD8 *pu1_tmp;

    i4_diff_hor_ver = ABS(i4_xd_index) - ABS(i4_yd_index);
    i4_sgn_xy = SIGN(i4_xd_index * i4_yd_index);

    if(i4_diff_hor_ver > 0)
    {
        i4_xc = i4_x - (i4_sgn_xy * i4_yd_index);
        i4_yc = i4_y - i4_yd_index;

        pu1_tmp = pu1_refarray + (i4_yc * i4_refarray_wd);

        i4_samp1 = pu1_tmp[i4_xc - 1];
        i4_samp2 = pu1_tmp[i4_xc];
        i4_samp3 = pu1_tmp[i4_xc + 1];
    }
    else if(i4_diff_hor_ver < 0)
    {
        i4_xc = i4_x - i4_xd_index;
        i4_yc = i4_y - (i4_sgn_xy * i4_xd_index);

        pu1_tmp = pu1_refarray + ((i4_yc - 1) * i4_refarray_wd);

        i4_samp1 = pu1_tmp[i4_xc];
        pu1_tmp += i4_refarray_wd;
        i4_samp2 = pu1_tmp[i4_xc];
        pu1_tmp += i4_refarray_wd;
        i4_samp3 = pu1_tmp[i4_xc];
    }
    else
    {
        WORD32 i4_ref_xd, i4_ref_yd;

        i4_ref_xd = i4_x - i4_xd_index;
        i4_ref_yd = i4_y - i4_yd_index;

        i4_xc = i4_ref_xd + SIGN(i4_xd_index);
        i4_yc = i4_ref_yd + SIGN(i4_yd_index);

        pu1_tmp = pu1_refarray + (i4_ref_yd * i4_refarray_wd);

        i4_samp1 = pu1_tmp[i4_xc];
        i4_samp2 = pu1_tmp[i4_ref_xd];
        pu1_tmp = pu1_refarray + (i4_yc * i4_refarray_wd);
        i4_samp3 = pu1_tmp[i4_ref_xd];
    }

    i4_result = (i4_samp1 + (i4_samp2 << 1) + i4_samp3 + 2) >> 2;

    pu1_tmp = pu1_refarray + (i4_y * i4_refarray_wd);
    /* Store the filled sample */
    pu1_tmp[i4_x] = i4_result;

    return i4_result;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_corner_samp_dyadic                                 */
/*                                                                           */
/*  Description   : This function fills the corner sample in the reference   */
/*                  array with diagonally constructed samples                */
/*  Inputs        : i4_x :current position in reference array X to be filled */
/*                  i4_y :current position in reference array Y to be filled */
/*                  i4_xd_index : diagonal index in horizontal direction     */
/*                  i4_yd_index : diagonal index in vertical direction       */
/*                  pu1_refarray_y : pointer to luma reference array         */
/*                  pu1_refarray_cb : pointer to Cb reference array          */
/*                  pu1_refarray_cr : pointer to Cr reference array          */
/*  Globals       : none                                                     */
/*  Processing    : Fills the sample which is unavailable with filtered      */
/*                  diagonal samples                                         */
/*  Outputs       : pixel filled                                             */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 12 2010   Nithya          creation                             */
/*                                                                           */
/*****************************************************************************/
static void isvc_corner_samp_dyadic(WORD32 i4_x, WORD32 i4_y, WORD32 i4_xD, WORD32 i4_yD,
                                    UWORD8 *pu1_refarray_y, UWORD8 *pu1_refarray_cb,
                                    UWORD8 *pu1_refarray_cr)
{
    WORD32 i4_ref_xD, i4_ref_yD;
    WORD32 i4_c_ref_xD, i4_c_ref_yD;
    WORD32 i4_xc, i4_yc;
    WORD32 i4_c_xc, i4_c_yc;
    WORD32 i4_samp1, i4_samp2;
    UWORD8 *pu1_tmp_src, *pu1_tmp_dst;

    i4_ref_xD = i4_x - i4_xD;
    i4_ref_yD = i4_y - i4_yD;

    i4_xc = i4_ref_xD + SIGN(i4_xD);
    i4_yc = i4_ref_yD + SIGN(i4_yD);

    /* Luma */
    pu1_tmp_src = pu1_refarray_y + (i4_yc * DYADIC_REF_W_Y);
    i4_samp1 = pu1_tmp_src[i4_ref_xD];
    pu1_tmp_src = pu1_refarray_y + (i4_ref_yD * DYADIC_REF_W_Y);
    i4_samp2 = pu1_tmp_src[i4_xc];
    pu1_tmp_dst = pu1_tmp_src;

    pu1_tmp_dst[i4_ref_xD] = (i4_samp1 + i4_samp2 + 1) >> 1;

    /* Chroma */
    i4_c_ref_xD = i4_ref_xD >> 1;
    i4_c_ref_yD = i4_ref_yD >> 1;

    i4_c_xc = i4_c_ref_xD + SIGN(i4_xD);
    i4_c_yc = i4_c_ref_yD + SIGN(i4_yD);

    /* Cb */
    pu1_tmp_src = pu1_refarray_cb + (i4_c_yc * DYADIC_REF_W_C);
    i4_samp1 = pu1_tmp_src[i4_c_ref_xD];
    pu1_tmp_src = pu1_refarray_cb + (i4_c_ref_yD * DYADIC_REF_W_C);
    i4_samp2 = pu1_tmp_src[i4_c_xc];
    pu1_tmp_dst = pu1_tmp_src;

    pu1_tmp_dst[i4_c_ref_xD] = (i4_samp1 + i4_samp2 + 1) >> 1;

    /* Cr */
    pu1_tmp_src = pu1_refarray_cr + (i4_c_yc * DYADIC_REF_W_C);
    i4_samp1 = pu1_tmp_src[i4_c_ref_xD];
    pu1_tmp_src = pu1_refarray_cr + (i4_c_ref_yD * DYADIC_REF_W_C);
    i4_samp2 = pu1_tmp_src[i4_c_xc];
    pu1_tmp_dst = pu1_tmp_src;

    pu1_tmp_dst[i4_c_ref_xD] = (i4_samp1 + i4_samp2 + 1) >> 1;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_reflayer_construction_dyadic                       */
/*                                                                           */
/*  Description   :  This function constructs the reference array buffer     */
/*                   for dyadic cases used for intra resampling of a         */
/*                   component in an MB                                      */
/*                                                                           */
/*  Inputs        : pv_intra_samp_ctxt : intra sampling context              */
/*                  ps_ref_mb_mode_map : ref layer mb mode buffer desc       */
/*                  pu1_inp_luma : luma input (reference layer data)         */
/*                  pu1_inp_chroma : chroma input (reference layer data)     */
/*                  i4_inp_luma_stride : luma input buffer stride            */
/*                  i4_inp_chroma_stride : chroma input buffer stride        */
/*                  i4_top : indicates whether the core 8x8 reference block  */
/*                  is one of 0 and 1 or one of 2 and 3                      */
/*                  i4_left : indicates whether the core 8x8 reference block */
/*                  is one of 0 and 2 or one of 1 and 3                      */
/*                  ps_ref_mb_coord : coordinates of the reference MB        */
/*  Globals       : none                                                     */
/*  Processing    : it fills the reference layer data if they are falling in */
/*                  INTRA MB region. If all the pixels are not filled  it    */
/*                  calls the border extension algorithm to fill them        */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         02 12 2010   Nithya          creation               */
/*                                                                           */
/*****************************************************************************/
static void isvc_reflayer_construction_dyadic(void *pv_intra_samp_ctxt,
                                              mem_element_t *ps_ref_mb_mode_map,
                                              UWORD8 *pu1_inp_luma, UWORD8 *pu1_inp_chroma,
                                              WORD32 i4_inp_luma_stride,
                                              WORD32 i4_inp_chroma_stride, WORD32 i4_top,
                                              WORD32 i4_left, UWORD16 u2_mb_x, UWORD16 u2_mb_y)
{
    enum
    {
        TOPLEFT_MASK = 1,
        LEFT_MASK = 2,
        TOP_MASK = 4,
        TOPRIGHT_MASK = 8,
        BOTTOMLEFT_MASK = 16
    };

    WORD32 i4_x, i4_y;
    WORD32 i4_x0, i4_y0;
    WORD32 i4_xc0, i4_yc0;
    WORD32 i4_ref_xD, i4_ref_yD;
    WORD32 i4_c_ref_xD, i4_c_ref_yD;

    intra_sampling_ctxt_t *ps_ctxt;
    intra_samp_lyr_ctxt *ps_lyr_ctxt;
    WORD8 *pi1_ref_mb_modes;
    WORD32 i4_ref_mode_stride;
    WORD32 i4_element_size;
    WORD32 i4_mbaddr_y;
    WORD32 i4_mbaddr_x;

    WORD32 i4_refarray_wd_luma, i4_refarray_wd_chroma;
    WORD32 i4_refarray_ht_luma, i4_refarray_ht_chroma;
    WORD32 i4_avlblty;
    WORD8 i1_cons_intr_samp_flag;
    WORD8 i1_slice_id;
    WORD8 i1_corner_samp_avlbl_flag;
    UWORD8 u1_ny_avlblty;

    UWORD8 *pu1_refarray_luma;
    UWORD8 *pu1_refarray_cb, *pu1_refarray_cr;

    ps_ctxt = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];
    pi1_ref_mb_modes = (WORD8 *) ps_ref_mb_mode_map->pv_buffer;
    i4_ref_mode_stride = ps_ref_mb_mode_map->i4_num_element_stride;
    i4_element_size = ps_ref_mb_mode_map->i4_element_size;

    i1_cons_intr_samp_flag = ps_lyr_ctxt->i1_constrained_intra_rsmpl_flag;

    ASSERT(NULL != pi1_ref_mb_modes);

    pu1_refarray_luma = ps_ctxt->pu1_refarray_buffer;
    pu1_refarray_cb = ps_ctxt->pu1_refarray_cb;
    pu1_refarray_cr = ps_ctxt->pu1_refarray_cr;

    i4_mbaddr_x = u2_mb_x;
    i4_mbaddr_y = u2_mb_y;

    i4_refarray_wd_luma = 20;
    i4_refarray_ht_luma = 20;

    i4_refarray_wd_chroma = i4_refarray_wd_luma >> 1;
    i4_refarray_ht_chroma = i4_refarray_ht_luma >> 1;

    if(1 == i1_cons_intr_samp_flag)
    {
        WORD8 *pi1_ref_mb_mode_tmp;
        WORD8 i1_mb_mode;

        pi1_ref_mb_mode_tmp = pi1_ref_mb_modes;
        pi1_ref_mb_mode_tmp += (i4_mbaddr_y * i4_ref_mode_stride * i4_element_size);
        pi1_ref_mb_mode_tmp += (i4_mbaddr_x * i4_element_size);
        i1_mb_mode = *pi1_ref_mb_mode_tmp;
        i1_mb_mode = (i1_mb_mode < 0) ? i1_mb_mode : SVC_EXTRACT_MB_MODE(*pi1_ref_mb_mode_tmp);

        /* The reference layer MB should be intra */
        ASSERT(i1_mb_mode >= 0);

        i1_slice_id = i1_mb_mode;
    }
    else
    {
        i1_slice_id = -1;
    }

    {
        UWORD8 *pu1_src, *pu1_dst;
        WORD32 i4_src_stride, i4_dst_stride;

        /* Copy luma */
        i4_src_stride = i4_inp_luma_stride;
        i4_dst_stride = DYADIC_REF_W_Y;
        pu1_src = pu1_inp_luma;
        pu1_dst = pu1_refarray_luma;

        isvc_copy_data(pu1_src, i4_src_stride, pu1_dst, i4_dst_stride, i4_refarray_wd_luma,
                       i4_refarray_ht_luma);

        i4_src_stride = i4_inp_chroma_stride;
        i4_dst_stride = DYADIC_REF_W_C;
        pu1_src = pu1_inp_chroma;
        isvc_copy_data_semiplanr(pu1_src, i4_src_stride, pu1_refarray_cb, pu1_refarray_cr,
                                 i4_dst_stride, i4_refarray_wd_chroma, i4_refarray_ht_chroma);
    }

    {
        /* mb_x + left, mb_y + top */
        isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                          i4_mbaddr_x + i4_left, i4_mbaddr_y + i4_top, &i4_avlblty,
                                          i1_slice_id, i1_cons_intr_samp_flag);
        u1_ny_avlblty = i4_avlblty;

        /* mb_x + left, mb_y */
        isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                          i4_mbaddr_x + i4_left, i4_mbaddr_y, &i4_avlblty,
                                          i1_slice_id, i1_cons_intr_samp_flag);
        u1_ny_avlblty += (i4_avlblty << 1);

        /* mb_x, mb_y + top */
        isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                          i4_mbaddr_x, i4_mbaddr_y + i4_top, &i4_avlblty,
                                          i1_slice_id, i1_cons_intr_samp_flag);
        u1_ny_avlblty += (i4_avlblty << 2);

        /* mb_x - left, mb_y + top */
        isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                          i4_mbaddr_x - i4_left, i4_mbaddr_y + i4_top, &i4_avlblty,
                                          i1_slice_id, i1_cons_intr_samp_flag);
        u1_ny_avlblty += (i4_avlblty << 3);

        /* mb_x + left, mb_y - top */
        isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                          i4_mbaddr_x + i4_left, i4_mbaddr_y - i4_top, &i4_avlblty,
                                          i1_slice_id, i1_cons_intr_samp_flag);
        u1_ny_avlblty += (i4_avlblty << 4);
    }

    if((TOP_MASK | TOPLEFT_MASK | LEFT_MASK) == u1_ny_avlblty)
    {
        return;
    }

    if(!(u1_ny_avlblty & (TOP_MASK | TOPLEFT_MASK | LEFT_MASK)))
    {
        UWORD8 *pu1_tmp_src, *pu1_tmp_dst1, *pu1_tmp_dst2;
        UWORD8 *pu1_tmp_src1, *pu1_tmp_src2;

        /* Set the 4 corner samples to (x-xD,y-yD) */
        i4_x0 = 9 + (i4_left << 3) + i4_left;
        i4_y0 = 9 + (i4_top << 3) + i4_top;

        i4_ref_xD = i4_x0 - i4_left - (i4_left >> 1);
        i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);

        pu1_tmp_src = pu1_refarray_luma + (i4_ref_yD * DYADIC_REF_W_Y);
        pu1_tmp_dst1 = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);
        pu1_tmp_dst2 = pu1_tmp_dst1 + DYADIC_REF_W_Y;

        pu1_tmp_dst1[i4_x0] = pu1_tmp_src[i4_ref_xD];
        pu1_tmp_dst1[i4_x0 + 1] = pu1_tmp_src[i4_ref_xD];
        pu1_tmp_dst2[i4_x0] = pu1_tmp_src[i4_ref_xD];
        pu1_tmp_dst2[i4_x0 + 1] = pu1_tmp_src[i4_ref_xD];

        /* Set the corner sample of Cb and Cr to (x-xD,y-yD) */
        i4_xc0 = i4_x0 >> 1;
        i4_yc0 = i4_y0 >> 1;

        i4_c_ref_yD = i4_ref_yD >> 1;
        i4_c_ref_xD = i4_ref_xD >> 1;

        pu1_tmp_src1 = pu1_refarray_cb + (i4_c_ref_yD * DYADIC_REF_W_C);
        pu1_tmp_dst1 = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);
        pu1_tmp_dst1[i4_xc0] = pu1_tmp_src1[i4_c_ref_xD];
        pu1_tmp_src2 = pu1_refarray_cr + (i4_c_ref_yD * DYADIC_REF_W_C);
        pu1_tmp_dst2 = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);
        pu1_tmp_dst2[i4_xc0] = pu1_tmp_src2[i4_c_ref_xD];
    }

    if(!(u1_ny_avlblty & (TOP_MASK | TOPLEFT_MASK)))
    {
        UWORD8 *pu1_tmp_src, *pu1_tmp_dst1, *pu1_tmp_dst2;
        UWORD8 *pu1_tmp_src1, *pu1_tmp_src2;

        /* Copy (x0,ref_yD), (x0+1,ref_yD), ..., (x0+7,ref_yD) to */
        /* (x0,y0), (x0+1,y0), ..., (x0+7,y0) and   */
        /* (x0,y0+1), (x0+1,y0+1), ..., (x0+7,y0+1) */
        i4_x0 = 2;
        i4_y0 = 9 + (i4_top << 3) + i4_top;
        if(i4_left > 0)
        {
            i4_x0 += 8;
        }
        i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);

        pu1_tmp_src = pu1_refarray_luma + (i4_ref_yD * DYADIC_REF_W_Y);
        pu1_tmp_dst1 = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);
        pu1_tmp_dst2 = pu1_tmp_dst1 + DYADIC_REF_W_Y;

        for(i4_x = i4_x0; i4_x < i4_x0 + 8; i4_x++)
        {
            pu1_tmp_dst1[i4_x] = pu1_tmp_src[i4_x];
            pu1_tmp_dst2[i4_x] = pu1_tmp_src[i4_x];
        }

        /* Cb and Cr copy */
        i4_xc0 = i4_x0 >> 1;
        i4_yc0 = i4_y0 >> 1;
        i4_c_ref_yD = i4_ref_yD >> 1;

        pu1_tmp_src1 = pu1_refarray_cb + (i4_c_ref_yD * DYADIC_REF_W_C);
        pu1_tmp_dst1 = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);
        pu1_tmp_src2 = pu1_refarray_cr + (i4_c_ref_yD * DYADIC_REF_W_C);
        pu1_tmp_dst2 = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);

        for(i4_x = i4_xc0; i4_x < i4_xc0 + 4; i4_x++)
        {
            pu1_tmp_dst1[i4_x] = pu1_tmp_src1[i4_x];
            pu1_tmp_dst2[i4_x] = pu1_tmp_src2[i4_x];
        }
    }

    if(!(u1_ny_avlblty & (TOPLEFT_MASK | LEFT_MASK)))
    {
        UWORD8 *pu1_tmp_src, *pu1_tmp_dst1, *pu1_tmp_dst2;
        UWORD8 *pu1_tmp_src1, *pu1_tmp_src2;

        /* Copy (ref_xD,y0) to (x0,y0) and (x0+1,y0); */
        /* copy (ref_xD,y0+1) to (x0,y0+1) and (x0+1,y0+1); ... ;*/
        /* copy (ref_xD,y0+7) to (x0,y0+7) and (x0+1,y0+7) */
        i4_x0 = 9 + (i4_left << 3) + i4_left;
        i4_y0 = 2;
        if(i4_top > 0)
        {
            i4_y0 += 8;
        }
        i4_ref_xD = i4_x0 - i4_left - (i4_left >> 1);

        pu1_tmp_src = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);
        pu1_tmp_dst1 = pu1_tmp_src;

        for(i4_y = i4_y0; i4_y < i4_y0 + 8; i4_y++)
        {
            pu1_tmp_dst1[i4_x0] = pu1_tmp_src[i4_ref_xD];
            pu1_tmp_dst1[i4_x0 + 1] = pu1_tmp_src[i4_ref_xD];
            pu1_tmp_src += DYADIC_REF_W_Y;
            pu1_tmp_dst1 += DYADIC_REF_W_Y;
        }

        /* Cb and Cr copy */
        i4_xc0 = i4_x0 >> 1;
        i4_yc0 = i4_y0 >> 1;
        i4_c_ref_xD = i4_ref_xD >> 1;

        pu1_tmp_src1 = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);
        pu1_tmp_dst1 = pu1_tmp_src1;
        pu1_tmp_src2 = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);
        pu1_tmp_dst2 = pu1_tmp_src2;

        for(i4_y = i4_yc0; i4_y < i4_yc0 + 4; i4_y++)
        {
            pu1_tmp_dst1[i4_xc0] = pu1_tmp_src1[i4_c_ref_xD];
            pu1_tmp_dst2[i4_xc0] = pu1_tmp_src2[i4_c_ref_xD];
            pu1_tmp_src1 += DYADIC_REF_W_C;
            pu1_tmp_src2 += DYADIC_REF_W_C;
            pu1_tmp_dst1 += DYADIC_REF_W_C;
            pu1_tmp_dst2 += DYADIC_REF_W_C;
        }
    }

    if(!(u1_ny_avlblty & TOP_MASK))
    {
        if(!(u1_ny_avlblty & TOPRIGHT_MASK))
        {
            UWORD8 *pu1_tmp_src, *pu1_tmp_dst;

            i4_x0 = 9 - i4_left;
            i4_y0 = 9 + (i4_top << 3) + i4_top;

            i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);

            /* Copy (x0,ref_yD) and (x0+1,ref_yD) to (x0,y0) and (x0+1,y0), and */
            /* to (x0,y0+1) and (x0+1,y0+1) */
            pu1_tmp_src = pu1_refarray_luma + (i4_ref_yD * DYADIC_REF_W_Y);
            pu1_tmp_dst = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);

            pu1_tmp_dst[i4_x0] = pu1_tmp_src[i4_x0];
            pu1_tmp_dst[i4_x0 + 1] = pu1_tmp_src[i4_x0 + 1];

            pu1_tmp_dst += DYADIC_REF_W_Y;

            pu1_tmp_dst[i4_x0] = pu1_tmp_src[i4_x0];
            pu1_tmp_dst[i4_x0 + 1] = pu1_tmp_src[i4_x0 + 1];

            /* Cb copy */
            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            pu1_tmp_src = pu1_refarray_cb + (i4_c_ref_yD * DYADIC_REF_W_C);
            pu1_tmp_dst = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);

            pu1_tmp_dst[i4_xc0] = pu1_tmp_src[i4_xc0];

            /* Cr copy */
            pu1_tmp_src = pu1_refarray_cr + (i4_c_ref_yD * DYADIC_REF_W_C);
            pu1_tmp_dst = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);

            pu1_tmp_dst[i4_xc0] = pu1_tmp_src[i4_xc0];
        }
        else
        {
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;

            isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                              i4_mbaddr_x - i4_left, i4_mbaddr_y, &i4_avlblty,
                                              i1_slice_id, i1_cons_intr_samp_flag);
            i1_corner_samp_avlbl_flag = i4_avlblty;

            i4_x0 = 9 - i4_left;
            i4_y0 = 9 + (i4_top << 3) + i4_top;

            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;

            i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);
            i4_ref_xD = i4_x0 - (i4_left * 7) - (i4_left >> 1);

            i4_c_ref_xD = i4_ref_xD >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            i4_xD = i4_x0 - i4_ref_xD;
            i4_yD = i4_y0 - i4_ref_yD;

            i4_c_xD = i4_xc0 - i4_c_ref_xD;
            i4_c_yD = i4_yc0 - i4_c_ref_yD;

            /* Fill corner sample if not available */
            if(!i1_corner_samp_avlbl_flag)
            {
                isvc_corner_samp_dyadic(i4_x0, i4_y0, i4_xD, i4_yD, pu1_refarray_luma,
                                        pu1_refarray_cb, pu1_refarray_cr);
            }

            /* Call diagonal construction for luma */
            for(i4_y = i4_y0; i4_y < i4_y0 + 2; i4_y++)
            {
                for(i4_x = i4_x0; i4_x < i4_x0 + 2; i4_x++)
                {
                    isvc_diagonal_construct_dyadic(i4_x, i4_y, i4_xD, i4_yD, pu1_refarray_luma,
                                                   DYADIC_REF_W_Y);
                    i4_xD++;
                }
                i4_yD++;
                i4_xD -= 2;
            }

            /* Call diagonal construction for chroma */
            isvc_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD, pu1_refarray_cb,
                                           DYADIC_REF_W_C);

            isvc_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD, pu1_refarray_cr,
                                           DYADIC_REF_W_C);
        }
    }

    if(!(u1_ny_avlblty & LEFT_MASK))
    {
        if(!(u1_ny_avlblty & BOTTOMLEFT_MASK))
        {
            UWORD8 *pu1_tmp_src, *pu1_tmp_dst;

            i4_x0 = 9 + (i4_left << 3) + i4_left;
            i4_y0 = 9 - i4_top;
            i4_ref_xD = i4_x0 - i4_left - (i4_left >> 1);

            /* Copy (ref_xD,y0) to (x0,y0), (x0+1,y0), and  */
            /* copy (ref_xD,y0+1) to (x0,y0+1), (x0+1,y0+1) */
            pu1_tmp_src = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);
            pu1_tmp_dst = pu1_tmp_src;

            pu1_tmp_dst[i4_x0] = pu1_tmp_src[i4_ref_xD];
            pu1_tmp_dst[i4_x0 + 1] = pu1_tmp_src[i4_ref_xD];

            pu1_tmp_src += DYADIC_REF_W_Y;
            pu1_tmp_dst += DYADIC_REF_W_Y;

            pu1_tmp_dst[i4_x0] = pu1_tmp_src[i4_ref_xD];
            pu1_tmp_dst[i4_x0 + 1] = pu1_tmp_src[i4_ref_xD];

            /* Cb copy */
            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;
            i4_c_ref_xD = i4_ref_xD >> 1;

            pu1_tmp_src = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);
            pu1_tmp_dst = pu1_tmp_src;

            pu1_tmp_dst[i4_xc0] = pu1_tmp_src[i4_c_ref_xD];

            /* Cr copy */
            pu1_tmp_src = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);
            pu1_tmp_dst = pu1_tmp_src;

            pu1_tmp_dst[i4_xc0] = pu1_tmp_src[i4_c_ref_xD];
        }
        else
        {
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;

            isvc_get_ref_layer_avlblty_dyadic(pi1_ref_mb_modes, i4_ref_mode_stride, i4_element_size,
                                              i4_mbaddr_x, i4_mbaddr_y - i4_top, &i4_avlblty,
                                              i1_slice_id, i1_cons_intr_samp_flag);
            i1_corner_samp_avlbl_flag = i4_avlblty;

            i4_x0 = 9 + (i4_left << 3) + i4_left;
            i4_y0 = 9 - i4_top;

            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;

            i4_ref_xD = i4_x0 - i4_left - (i4_left >> 1);
            i4_ref_yD = i4_y0 - (i4_top * 7) - (i4_top >> 1);

            i4_c_ref_xD = i4_ref_xD >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            i4_xD = i4_x0 - i4_ref_xD;
            i4_yD = i4_y0 - i4_ref_yD;

            i4_c_xD = i4_xc0 - i4_c_ref_xD;
            i4_c_yD = i4_yc0 - i4_c_ref_yD;

            if(!i1_corner_samp_avlbl_flag)
            {
                isvc_corner_samp_dyadic(i4_x0, i4_y0, i4_xD, i4_yD, pu1_refarray_luma,
                                        pu1_refarray_cb, pu1_refarray_cr);
            }

            /* Call diagonal consrtuction for luma */
            for(i4_y = i4_y0; i4_y < i4_y0 + 2; i4_y++)
            {
                for(i4_x = i4_x0; i4_x < i4_x0 + 2; i4_x++)
                {
                    isvc_diagonal_construct_dyadic(i4_x, i4_y, i4_xD, i4_yD, pu1_refarray_luma,
                                                   DYADIC_REF_W_Y);
                    i4_xD++;
                }
                i4_yD++;
                i4_xD -= 2;
            }

            /* Call diagonal construction for chroma */
            isvc_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD, pu1_refarray_cb,
                                           DYADIC_REF_W_C);

            isvc_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD, pu1_refarray_cr,
                                           DYADIC_REF_W_C);
        }
    }

    if(u1_ny_avlblty & TOPLEFT_MASK)
    {
        if(!(u1_ny_avlblty & LEFT_MASK))
        {
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;
            UWORD8 *pu1_tmp_dst;
            UWORD8 u1_filled_samp;

            i1_corner_samp_avlbl_flag = (u1_ny_avlblty & 4) >> 2;

            i4_x0 = 9 + (i4_left << 3) + i4_left;
            i4_y0 = 2;
            i4_ref_yD = 1;
            if(i4_top > 0)
            {
                i4_y0 += 8;
                i4_ref_yD = 18;
            }

            i4_ref_xD = i4_x0 - (i4_left) - (i4_left >> 1);

            i4_xD = i4_x0 - i4_ref_xD;
            i4_yD = i4_y0 - i4_ref_yD;

            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;

            i4_c_ref_xD = i4_ref_xD >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            i4_c_xD = i4_xc0 - i4_c_ref_xD;
            i4_c_yD = i4_yc0 - i4_c_ref_yD;

            /* Fill corner sample if unavailable */
            if(!i1_corner_samp_avlbl_flag)
            {
                isvc_corner_samp_dyadic(i4_x0, i4_y0, i4_xD, i4_yD, pu1_refarray_luma,
                                        pu1_refarray_cb, pu1_refarray_cr);
            }

            /* Call the diagonal construction for the 8 rows */
            if(i4_top == i4_left)
            {
                /* if top * left = 1 */
                /* (x0,y0) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x0, i4_y0, i4_xD, i4_yD,
                                                                pu1_refarray_luma, DYADIC_REF_W_Y);

                pu1_tmp_dst = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);

                /* (x0,y0+1), ..., (x0,y0+7) and */
                /* (x0+1,y0), ..., (x0+1,y0+6)   */
                for(i4_y = i4_y0 + 1; i4_y < i4_y0 + 8; i4_y++)
                {
                    i4_yD++;
                    u1_filled_samp = isvc_diagonal_construct_dyadic(
                        i4_x0, i4_y, i4_xD, i4_yD, pu1_refarray_luma, DYADIC_REF_W_Y);
                    pu1_tmp_dst[i4_x0 + 1] = u1_filled_samp;
                    pu1_tmp_dst += DYADIC_REF_W_Y;
                }

                /* (x0+1,y0+7) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(
                    i4_x0 + 1, i4_y0 + 7, i4_xD + 1, i4_yD, pu1_refarray_luma, DYADIC_REF_W_Y);
            }
            else
            {
                /* top * left = -1 */
                /* (x0+1,y0) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x0 + 1, i4_y0, i4_xD + 1, i4_yD,
                                                                pu1_refarray_luma, DYADIC_REF_W_Y);

                pu1_tmp_dst = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);

                /* (x0,y0), ..., (x0,y0+6) and   */
                /* (x0+1,y0+1), ..., (x0+1,y0+7) */
                for(i4_y = i4_y0; i4_y < i4_y0 + 7; i4_y++)
                {
                    u1_filled_samp = isvc_diagonal_construct_dyadic(
                        i4_x0, i4_y, i4_xD, i4_yD, pu1_refarray_luma, DYADIC_REF_W_Y);

                    pu1_tmp_dst += DYADIC_REF_W_Y;
                    pu1_tmp_dst[i4_x0 + 1] = u1_filled_samp;
                    i4_yD++;
                }

                /* (x0,y0+7) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x0, i4_y0 + 7, i4_xD, i4_yD,
                                                                pu1_refarray_luma, DYADIC_REF_W_Y);
            }

            /* For Cb and Cr */
            for(i4_y = i4_yc0; i4_y < i4_yc0 + 4; i4_y++)
            {
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_xc0, i4_y, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cb, DYADIC_REF_W_C);
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_xc0, i4_y, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cr, DYADIC_REF_W_C);
                i4_c_yD++;
            }
        }

        if(!(u1_ny_avlblty & TOP_MASK))
        {
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;
            UWORD8 *pu1_tmp_dst;
            UWORD8 u1_filled_samp;

            i1_corner_samp_avlbl_flag = (u1_ny_avlblty & 2) >> 1;

            i4_y0 = 9 + (i4_top << 3) + (i4_top);
            i4_x0 = 2;
            i4_ref_xD = 1;
            if(i4_left > 0)
            {
                i4_x0 += 8;
                i4_ref_xD = 18;
            }

            i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);

            i4_xD = i4_x0 - i4_ref_xD;
            i4_yD = i4_y0 - i4_ref_yD;

            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;

            i4_c_ref_xD = i4_ref_xD >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            i4_c_xD = i4_xc0 - i4_c_ref_xD;
            i4_c_yD = i4_yc0 - i4_c_ref_yD;

            if(!i1_corner_samp_avlbl_flag)
            {
                isvc_corner_samp_dyadic(i4_x0, i4_y0, i4_xD, i4_yD, pu1_refarray_luma,
                                        pu1_refarray_cb, pu1_refarray_cr);
            }

            /* Call the diagonal construction for the 2 rows */
            if(i4_top == i4_left)
            {
                /* if top * left = 1 */
                /* (x0,y0) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x0, i4_y0, i4_xD, i4_yD,
                                                                pu1_refarray_luma, DYADIC_REF_W_Y);

                pu1_tmp_dst = pu1_refarray_luma + ((i4_y0 + 1) * DYADIC_REF_W_Y);

                /* (x0+1,y0), ..., (x0+7,y0) and */
                /* (x0,y0+1), ..., (x0+6,y0+1)   */
                for(i4_x = i4_x0 + 1; i4_x < i4_x0 + 8; i4_x++)
                {
                    i4_xD++;
                    u1_filled_samp = isvc_diagonal_construct_dyadic(
                        i4_x, i4_y0, i4_xD, i4_yD, pu1_refarray_luma, DYADIC_REF_W_Y);
                    pu1_tmp_dst[i4_x - 1] = u1_filled_samp;
                }

                /* (x0+7,y0+1) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(
                    i4_x0 + 7, i4_y0 + 1, i4_xD, i4_yD + 1, pu1_refarray_luma, DYADIC_REF_W_Y);
            }
            else
            {
                /* top * left = -1 */
                /* (x0,y0+1) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x0, i4_y0 + 1, i4_xD, i4_yD + 1,
                                                                pu1_refarray_luma, DYADIC_REF_W_Y);

                pu1_tmp_dst = pu1_refarray_luma + ((i4_y0 + 1) * DYADIC_REF_W_Y);

                /* (x0,y0), ..., (x0,y0+6) and   */
                /* (x0+1,y0+1), ..., (x0+1,y0+7) */
                for(i4_x = i4_x0; i4_x < i4_x0 + 7; i4_x++)
                {
                    u1_filled_samp = isvc_diagonal_construct_dyadic(
                        i4_x, i4_y0, i4_xD, i4_yD, pu1_refarray_luma, DYADIC_REF_W_Y);

                    pu1_tmp_dst[i4_x + 1] = u1_filled_samp;
                    i4_xD++;
                }

                /* (x0+7,y0) */
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x0 + 7, i4_y0, i4_xD, i4_yD,
                                                                pu1_refarray_luma, DYADIC_REF_W_Y);
            }

            /* For Cb and Cr */
            for(i4_x = i4_xc0; i4_x < i4_xc0 + 4; i4_x++)
            {
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x, i4_yc0, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cb, DYADIC_REF_W_C);
                u1_filled_samp = isvc_diagonal_construct_dyadic(i4_x, i4_yc0, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cr, DYADIC_REF_W_C);
                i4_c_xD++;
            }
        }
    }

    if(!(u1_ny_avlblty & TOPLEFT_MASK))
    {
        UWORD8 *pu1_tmp_dst1, *pu1_tmp_dst2;
        UWORD8 *pu1_tmp_src1, *pu1_tmp_src2;

        if(u1_ny_avlblty & LEFT_MASK)
        {
            /* (mb_x+left,mb_y) available, (mb_x,mb_y+top) unavailable */
            i4_x0 = 9 + (i4_left << 3) + i4_left;
            i4_y0 = 9 + (i4_top << 3) + i4_top;
            i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);

            /* Copy (x0,ref_yD), (x0+1,ref_yD) to  */
            /* (x0,y0), (x0+1,y0), and (x0,y0+1), (x0+1,y0+1) */
            pu1_tmp_src1 = pu1_refarray_luma + (i4_ref_yD * DYADIC_REF_W_Y);
            pu1_tmp_dst1 = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);
            pu1_tmp_dst2 = pu1_tmp_dst1 + DYADIC_REF_W_Y;

            pu1_tmp_dst1[i4_x0] = pu1_tmp_src1[i4_x0];
            pu1_tmp_dst2[i4_x0] = pu1_tmp_src1[i4_x0];
            pu1_tmp_dst1[i4_x0 + 1] = pu1_tmp_src1[i4_x0 + 1];
            pu1_tmp_dst2[i4_x0 + 1] = pu1_tmp_src1[i4_x0 + 1];

            /* Cb and Cr copy */
            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            pu1_tmp_src1 = pu1_refarray_cb + (i4_c_ref_yD * DYADIC_REF_W_C);
            pu1_tmp_dst1 = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);
            pu1_tmp_src2 = pu1_refarray_cr + (i4_c_ref_yD * DYADIC_REF_W_C);
            pu1_tmp_dst2 = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);

            pu1_tmp_dst1[i4_xc0] = pu1_tmp_src1[i4_xc0];
            pu1_tmp_dst2[i4_xc0] = pu1_tmp_src2[i4_xc0];
        }
        else if(u1_ny_avlblty & TOP_MASK)
        {
            /* (mb_x+left,mb_y) unavailable,
               (mb_x,mb_y+top) available */
            i4_x0 = 9 + (i4_left << 3) + i4_left;
            i4_y0 = 9 + (i4_top << 3) + i4_top;
            i4_ref_xD = i4_x0 - i4_left - (i4_left >> 1);

            /* Copy (ref_xD,y0) to (x0,y0) and (x0+1,y0) */
            /* copy (ref_xD,y0+1) to (x0,y0+1) and (x0+1,y0+1) */
            pu1_tmp_src1 = pu1_refarray_luma + (i4_y0 * DYADIC_REF_W_Y);
            pu1_tmp_dst1 = pu1_tmp_src1;
            pu1_tmp_src2 = pu1_tmp_src1 + DYADIC_REF_W_Y;
            pu1_tmp_dst2 = pu1_tmp_src2;

            pu1_tmp_dst1[i4_x0] = pu1_tmp_src1[i4_ref_xD];
            pu1_tmp_dst1[i4_x0 + 1] = pu1_tmp_src1[i4_ref_xD];
            pu1_tmp_dst2[i4_x0] = pu1_tmp_src2[i4_ref_xD];
            pu1_tmp_dst2[i4_x0 + 1] = pu1_tmp_src2[i4_ref_xD];

            /* Copy Cb and Cr */
            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;
            i4_c_ref_xD = i4_ref_xD >> 1;

            pu1_tmp_src1 = pu1_refarray_cb + (i4_yc0 * DYADIC_REF_W_C);
            pu1_tmp_dst1 = pu1_tmp_src1;
            pu1_tmp_src2 = pu1_refarray_cr + (i4_yc0 * DYADIC_REF_W_C);
            pu1_tmp_dst2 = pu1_tmp_src2;

            pu1_tmp_dst1[i4_xc0] = pu1_tmp_src1[i4_c_ref_xD];
            pu1_tmp_dst2[i4_xc0] = pu1_tmp_src2[i4_c_ref_xD];
        }
        else if(u1_ny_avlblty & (TOP_MASK | LEFT_MASK))
        {
            /* (mb_x+left,mb_y) available,
               (mb_x,mb_y+top) available */
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;

            i4_y0 = 9 + (i4_top << 3) + i4_top;
            i4_x0 = 9 + (i4_left << 3) + i4_left;

            i4_ref_xD = i4_x0 - i4_left - (i4_left >> 1);
            i4_ref_yD = i4_y0 - i4_top - (i4_top >> 1);

            i4_xD = i4_x0 - i4_ref_xD;
            i4_yD = i4_y0 - i4_ref_yD;

            i4_xc0 = i4_x0 >> 1;
            i4_yc0 = i4_y0 >> 1;

            i4_c_ref_xD = i4_ref_xD >> 1;
            i4_c_ref_yD = i4_ref_yD >> 1;

            i4_c_xD = i4_xc0 - i4_c_ref_xD;
            i4_c_yD = i4_yc0 - i4_c_ref_yD;

            /* Call diagonal construction for luma */
            for(i4_y = i4_y0; i4_y < i4_y0 + 2; i4_y++)
            {
                for(i4_x = i4_x0; i4_x < i4_x0 + 2; i4_x++)
                {
                    isvc_diagonal_construct_dyadic(i4_x, i4_y, i4_xD, i4_yD, pu1_refarray_luma,
                                                   DYADIC_REF_W_Y);
                    i4_xD++;
                }
                i4_yD++;
                i4_xD -= 2;
            }

            /* Call diagonal construction for chroma */
            isvc_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD, pu1_refarray_cb,
                                           DYADIC_REF_W_C);

            isvc_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD, pu1_refarray_cr,
                                           DYADIC_REF_W_C);
        }
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_get_ref_layer_mbtype                               */
/*                                                                           */
/*  Description   : This function is used to find the mb type of the         */
/*                    corresponding MB in the reference layer                */
/*                                                                           */
/*  Inputs        : pv_intra_samp_ctxt : intra samp context                  */
/*                  pi1_ref_mb_modes : ref mb modes buffer pointer           */
/*                  i4_ref_mode_stride : mb mode buffer stride               */
/*                  i4_x_ref : reference location X                          */
/*                  i4_y_ref : reference location Y                          */
/*                  pi4_mb_type : pointer to store the mb type               */
/*                  i4_chroma_flag : chroma flag                             */
/*  Globals       : none                                                     */
/*  Processing    : it derives the bit corresponding to reference MB and     */
/*                  stores the mbtype as INTRA if the bit is set             */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         26 06 2009   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
static WORD8 isvc_get_ref_layer_mbtype(WORD8 *pi1_ref_mb_modes, WORD32 *pi4_mb_type,
                                       WORD8 i1_curr_slice_id, WORD8 i1_cons_intr_samp_flag)
{
    WORD8 i1_intra_slice_id;
    WORD8 i1_mb_mode;

    i1_mb_mode = *pi1_ref_mb_modes;
    i1_mb_mode = (i1_mb_mode < 0) ? i1_mb_mode : SVC_EXTRACT_MB_MODE(*pi1_ref_mb_modes);

    if(i1_mb_mode <= SVC_INTER_MB)
    {
        *pi4_mb_type = SVC_INTER_MB;
        i1_intra_slice_id = -1;
    }
    else
    {
        *pi4_mb_type = SVC_INTRA_MB;
        i1_intra_slice_id = i1_mb_mode;

        if(1 == i1_cons_intr_samp_flag)
        {
            if(i1_mb_mode != i1_curr_slice_id)
            {
                *pi4_mb_type = SVC_INTER_MB;
            }
        }
    }
    return i1_intra_slice_id;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_fill_non_ava_pixel                                  */
/*                                                                           */
/*  Description   :  This function does the core pixel level processing      */
/*                    while filling the non available pixel                  */
/*                                                                           */
/*  Inputs        : pv_intra_samp_ctxt : intra sampling context              */
/*                  i4_refarray_wd : width of the reference array            */
/*                  i4_refarray_ht : height of the reference array           */
/*                  ps_mb_coord  : current mb coord structure                */
/*                  i4_chroma_flag : chroam processing flag                  */
/*  Globals       : none                                                     */
/*  Processing    : based on the map buffer values the non available pixels  */
/*                   are filled using border extension algorithm             */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         26 06 2009   vijayakumar          creation                        */
/*         07 03 2011   A.D.Almeida          Optimized the filling pixels    */
/*                                                                           */
/*****************************************************************************/
static void isvc_fill_non_avail_pixel(intra_samp_lyr_ctxt *ps_lyr_ctxt, UWORD8 *pu1_refarray_1,
                                      UWORD8 *pu1_refarray_2, WORD32 i4_refarray_stride,
                                      WORD32 i4_chroma_flag, UWORD8 u1_avail_map[4][4])
{
    WORD32 i4_x, i4_y;
    WORD32 i4_corner_pixel_available;

    seg_lookup_desc_t *ps_segments_x;
    seg_lookup_desc_t *ps_segments_y;
    seg_description_t *ps_seg_desc_x, *ps_seg_desc_y;
    seg_description_t *ps_seg_x_tmp, *ps_seg_y_tmp;
    UWORD8 u1_num_sgmts_x, u1_num_sgmts_y;

    WORD32 i4_x_offset;
    WORD32 i4_y_offset;
    WORD32 i4_refmb_wd;
    WORD32 i4_refmb_ht;
    WORD32 i4_xr_index, i4_yr_index;
    WORD32 i4_j, i4_i;
    WORD32 i4_cur_x;
    UWORD32 u4_lookup_4bit, u4_lookup_5bit, u4_4thbit;
    WORD32 i4_pad_size;

    WORD32 i4_x_min;
    WORD32 i4_y_min;
    WORD32 i4_x_start_pos, i4_y_start_pos;

    UWORD8 *pu1_ref_idx_x, *pu1_ref_idx_y;

    PF_INTRA_SAMP_PADDING *pf_intra_samp_padding;
    PF_INTRA_SAMP_PADDING **pf_intra_samp_lookup;

    i4_x_offset = ps_lyr_ctxt->ps_offsets->i4_abscissa;
    i4_y_offset = ps_lyr_ctxt->ps_offsets->i4_ordinate;

    i4_refmb_wd = (MB_SIZE >> i4_chroma_flag) - 1;
    i4_refmb_ht = (MB_SIZE >> i4_chroma_flag) - 1;

    if(0 == i4_chroma_flag)
    {
        pf_intra_samp_lookup = gpf_lookup_fxns_luma;
    }
    else
    {
        pf_intra_samp_lookup = gpf_lookup_fxns_chroma;
    }

    i4_x_min = ps_lyr_ctxt->i2_x_min_pos;
    i4_y_min = ps_lyr_ctxt->i2_y_min_pos;

    i4_pad_size = 2 >> i4_chroma_flag;
    i4_x_start_pos = (i4_x_min - i4_pad_size);
    i4_y_start_pos = (i4_y_min - i4_pad_size);

    i4_xr_index = (i4_x_start_pos + i4_x_offset) & i4_refmb_wd;
    i4_yr_index = (i4_y_start_pos + i4_y_offset) & i4_refmb_ht;

    ps_segments_x = (ps_lyr_ctxt->as_seg_lookup_horz + i4_xr_index);
    ps_segments_y = (ps_lyr_ctxt->as_seg_lookup_vert + i4_yr_index);

    u1_num_sgmts_x = ps_segments_x->u1_num_segments;
    u1_num_sgmts_y = ps_segments_y->u1_num_segments;

    ps_seg_desc_x = ps_segments_x->s_segments;
    ps_seg_desc_y = ps_segments_y->s_segments;

    pu1_ref_idx_x = &(ps_lyr_ctxt->au1_refarray_x_idx[0]);
    pu1_ref_idx_y = &(ps_lyr_ctxt->au1_refarray_y_idx[0]);

    i4_cur_x = pu1_ref_idx_x[i4_x_start_pos];

    u4_4thbit = ps_segments_x->u4_start_pos;

    for(i4_j = 0; i4_j < u1_num_sgmts_y; i4_j++)
    {
        UWORD8 i4_idx_a, i4_idx_b;
        UWORD8 u1_seg_ht, u1_seg_wd;
        UWORD8 u1_mb_adjoin_x, u1_mb_adjoin_y;
        WORD8 i1_nearst_mb_bdry_x, i1_nearst_mb_bdry_y;
        UWORD32 u4_num_valid_segs;
        WORD32 i4_idx_a_plus_ny, i4_idx_b_plus_nx, i4_index;
        WORD8 i1_yd_index, i1_xd_index;

        ps_seg_y_tmp = &ps_seg_desc_y[i4_j];

        i4_y = i4_y_start_pos + ps_seg_y_tmp->u1_seg_off;
        u1_seg_ht = ps_seg_y_tmp->u1_seg_dim;
        i1_yd_index = ps_seg_y_tmp->i1_dist_idx;
        i1_nearst_mb_bdry_y = ps_seg_y_tmp->i1_nearst_mb_bdry;
        u1_mb_adjoin_y = ps_seg_y_tmp->u1_mb_adjoin;

        i4_idx_a = pu1_ref_idx_y[i4_y];

        i4_idx_a_plus_ny = (i4_idx_a + i1_nearst_mb_bdry_y);

        /* Pack the availabilities of the next three horizontal MBs in 3bit
           format and 4th bit indicating if the start position is greater
           than the mb_width/2
         */
        u4_lookup_4bit = u4_4thbit | u1_avail_map[i4_idx_a][i4_cur_x + 2] << 2 |
                         u1_avail_map[i4_idx_a][i4_cur_x + 1] << 1 |
                         u1_avail_map[i4_idx_a][i4_cur_x];

        u4_num_valid_segs = gu4_valid_segs_lookup[u4_lookup_4bit];

        i4_i = CLZ(~u4_num_valid_segs);
        u4_num_valid_segs <<= (i4_i + 1);

        for(; i4_i < u1_num_sgmts_x; i4_i++)
        {
            ps_seg_x_tmp = &ps_seg_desc_x[i4_i];

            i4_x = i4_x_start_pos + ps_seg_x_tmp->u1_seg_off;
            i4_idx_b = pu1_ref_idx_x[i4_x];

            u1_seg_wd = ps_seg_x_tmp->u1_seg_dim;
            i1_xd_index = ps_seg_x_tmp->i1_dist_idx;
            i1_nearst_mb_bdry_x = ps_seg_x_tmp->i1_nearst_mb_bdry;
            u1_mb_adjoin_x = ps_seg_x_tmp->u1_mb_adjoin;

            i4_idx_b_plus_nx = (i4_idx_b + i1_nearst_mb_bdry_x);

            /* Find the avalability of (x,y-Yd),(x-Xd,y),(x-Xd,y-Yd) and pack
                it to 3 bits.
             */
            u4_lookup_5bit = u1_avail_map[i4_idx_a_plus_ny][i4_idx_b_plus_nx] << 2 |
                             u1_avail_map[i4_idx_a_plus_ny][i4_idx_b] << 1 |
                             u1_avail_map[i4_idx_a][i4_idx_b_plus_nx] | u1_mb_adjoin_x |
                             u1_mb_adjoin_y;

            i4_corner_pixel_available = u1_avail_map[i4_idx_a_plus_ny][i4_idx_b_plus_nx];

            /* Use a function pointer table based on lookup to compute
                Left,Top,Bottom,Right,Diagonal padding.
             */
            pf_intra_samp_padding = pf_intra_samp_lookup[u4_lookup_5bit];

            if(pf_intra_samp_padding != NULL)
            {
                pf_intra_samp_padding(i4_x, i4_y, i1_xd_index, i1_yd_index, u1_seg_wd, u1_seg_ht,
                                      pu1_refarray_1, pu1_refarray_2, i4_refarray_stride,
                                      u1_mb_adjoin_x, u1_mb_adjoin_y, i4_corner_pixel_available);
            }

            /* increment to the next unavailable segment */
            i4_index = CLZ(~u4_num_valid_segs);
            u4_num_valid_segs <<= (i4_index + 1);
            i4_i += i4_index;
        }
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_intra_resamp_generate_segment_lookup                */
/*                                                                           */
/*  Description   : This function generates segment lookup used to derive    */
/*                  segments which have to be be intra resampled             */
/*                                                                           */
/*  Inputs        : pv_lookup_table : look up table                          */
/*                  i4_dimension    : dimension of the block which is used in*/
/*                  resampling process.                                      */
/*                  i4_mb_size  : size of the mb                             */
/*  Globals       : None                                                     */
/*  Processing    : This function generates segment lookup used to derive    */
/*                  segments which have to be be intra resampled             */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues       : None                                                      */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 03 2011   A.D.Almeida     Creation                             */
/*                                                                           */
void isvc_intra_resamp_generate_segment_lookup(seg_lookup_desc_t *ps_seg_lookup_table,
                                               WORD32 i4_dimension, WORD32 i4_mb_size,
                                               WORD32 i4_shift_val)
{
    WORD32 i4_x;
    WORD32 i4_position, i4_dist_prev_mb, i4_dist_next_mb;
    UWORD8 u1_seg_dim;
    UWORD8 u1_num_sgmts;
    WORD32 i4_block_size = i4_mb_size >> 1;
    UWORD8 u1_offset = 0;
    seg_lookup_desc_t *ps_segments;
    seg_description_t *ps_seg_desc;

    memset(ps_seg_lookup_table, 0, i4_mb_size * sizeof(seg_lookup_desc_t));

    for(i4_x = 0; i4_x < i4_mb_size; i4_x++)
    {
        ps_segments = &ps_seg_lookup_table[i4_x];
        ps_seg_desc = ps_segments->s_segments;
        i4_position = i4_x;

        if(i4_x >= i4_block_size)
        {
            /* set the fourth bit so that later it can be directly OR ed */
            ps_segments->u4_start_pos = 8;
        }
        else
        {
            ps_segments->u4_start_pos = 0;
        }

        u1_num_sgmts = 0;
        u1_offset = 0;

        while(i4_position < (i4_x + i4_dimension))
        {
            /* check and fill the nearest mb boundry flag */
            if((i4_position & (i4_mb_size - 1)) < i4_block_size)
            {
                ps_seg_desc->i1_nearst_mb_bdry = -1;
            }
            else
            {
                ps_seg_desc->i1_nearst_mb_bdry = 1;
            }

            /* find the distance from the previous MB for start of segment*/
            i4_dist_prev_mb = (i4_position & (i4_mb_size - 1));

            ps_seg_desc->i1_dist_idx =
                ((i4_dist_prev_mb >= i4_mb_size >> 1) ? (i4_mb_size - i4_dist_prev_mb)
                                                      : -(i4_dist_prev_mb + 1));

            /* find the size of the segment */
            u1_seg_dim = (i4_block_size - (i4_position & (i4_block_size - 1)));
            i4_position += u1_seg_dim;
            if(i4_position > (i4_x + i4_dimension))
            {
                i4_position = (i4_x + i4_dimension);
                u1_seg_dim = (i4_position & (i4_block_size - 1));
            }

            /* find the distance from the next MB for end of segment */
            i4_dist_next_mb = (i4_position & (i4_mb_size - 1));

            ps_seg_desc->u1_seg_dim = u1_seg_dim;
            ps_seg_desc->u1_seg_off = u1_offset;

            /* check if the segment has a adjoining MB edge */
            if(i4_dist_prev_mb == 0)
            {
                if(0 == u1_num_sgmts)
                {
                    ps_seg_desc->u1_mb_adjoin = 0;
                }
                else
                {
                    ps_seg_desc->u1_mb_adjoin = 1 << i4_shift_val;
                }
            }
            else if(i4_dist_next_mb == 0)
            {
                if(i4_position == (i4_x + i4_dimension))
                {
                    ps_seg_desc->u1_mb_adjoin = 0;
                }
                else
                {
                    ps_seg_desc->u1_mb_adjoin = 1 << i4_shift_val;
                }
            }
            else
            {
                ps_seg_desc->u1_mb_adjoin = 0;
            }

            u1_offset += u1_seg_dim;
            u1_num_sgmts++;
            ps_seg_desc++;
        }

        /* fill the number of segments for this position */
        ps_segments->u1_num_segments = u1_num_sgmts;
    }
}

static void isvc_reflayer_construction(void *pv_intra_samp_ctxt, UWORD8 *pu1_inp_1,
                                       WORD32 i4_inp_stride, WORD32 i4_refarray_stride,
                                       mem_element_t *ps_ref_mb_mode_map, WORD32 i4_chroma_flag)
{
    WORD32 i4_x, i4_y;

    intra_sampling_ctxt_t *ps_ctxt;
    intra_samp_lyr_ctxt *ps_lyr_ctxt;
    WORD8 *pi1_ref_mb_modes, *pi1_ref_mb_modes_bkp_1;
    WORD32 i4_ref_mode_stride;
    WORD32 i4_element_size;
    WORD32 i4_dummy;
    WORD32 i4_mb_ht, i4_mb_wd;

    /* 4x4 mb grid buffer to store the mb availablity */
    UWORD8 u1_map_buf[BLK_SIZE][BLK_SIZE];
    WORD32 i4_ref_wd;
    WORD32 i4_ref_ht;
    WORD32 i4_x_offset;
    WORD32 i4_y_offset;
    WORD32 i4_refarray_wd;
    WORD32 i4_refarray_ht;
    WORD32 i4_mb_type;
    WORD8 i1_cons_intr_samp_flag;
    WORD8 i1_slice_id = 0;
    WORD32 i4_mb_wd_sft, i4_mb_ht_sft;

    WORD32 i4_unfill_check;
    UWORD8 *pu1_refarray_1, *pu1_refarray_2;

    UNUSED(i4_dummy);
    memset(&u1_map_buf[0][0], 0, 16);

    ps_ctxt = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];
    pi1_ref_mb_modes = (WORD8 *) ps_ref_mb_mode_map->pv_buffer;
    i4_ref_mode_stride = ps_ref_mb_mode_map->i4_num_element_stride;
    i4_element_size = ps_ref_mb_mode_map->i4_element_size;

    /* get the condtrained intra sampling flag */
    i1_cons_intr_samp_flag = ps_lyr_ctxt->i1_constrained_intra_rsmpl_flag;

    ASSERT(NULL != pi1_ref_mb_modes);

    {
        WORD32 i4_base_width = ps_lyr_ctxt->i4_ref_width;
        WORD32 i4_base_height = ps_lyr_ctxt->i4_ref_height;

        i4_ref_wd = i4_base_width >> i4_chroma_flag;
        i4_ref_ht = i4_base_height >> i4_chroma_flag;

        i4_mb_wd_sft = (MB_WIDTH_SHIFT - i4_chroma_flag);
        i4_mb_ht_sft = (MB_HEIGHT_SHIFT - i4_chroma_flag);
    }

    i4_x_offset = ps_lyr_ctxt->ps_offsets->i4_abscissa;
    i4_y_offset = ps_lyr_ctxt->ps_offsets->i4_ordinate;
    i4_refarray_wd = ps_lyr_ctxt->ps_ref_array_dims->i4_abscissa;
    i4_refarray_ht = ps_lyr_ctxt->ps_ref_array_dims->i4_ordinate;

    i4_mb_wd = (MB_SIZE >> i4_chroma_flag);
    i4_mb_ht = (MB_SIZE >> i4_chroma_flag);

    if(1 == i1_cons_intr_samp_flag)
    {
        WORD32 i4_x_min, i4_x_max;
        WORD32 i4_y_min, i4_y_max;

        i4_x_min = ps_lyr_ctxt->i2_x_min_pos;
        i4_x_max = ps_lyr_ctxt->i2_x_max_pos;
        i4_y_min = ps_lyr_ctxt->i2_y_min_pos;
        i4_y_max = ps_lyr_ctxt->i2_y_max_pos;

        i4_mb_type = SVC_INTER_MB;
        {
            WORD32 i4_x_ref;
            WORD32 i4_y_ref;
            WORD32 i4_mb_x, i4_mb_y;

            /* derive local varaibles */
            i4_y_ref = (i4_y_min + 1) + i4_y_offset;
            i4_x_ref = (i4_x_min + 1) + i4_x_offset;

            i4_mb_x = (i4_x_ref >> i4_mb_wd_sft);
            i4_mb_y = (i4_y_ref >> i4_mb_ht_sft);

            pi1_ref_mb_modes = (WORD8 *) ps_ref_mb_mode_map->pv_buffer;

            /* get the location of the byte which has the current mb mode */
            pi1_ref_mb_modes += (i4_mb_y * i4_ref_mode_stride * i4_element_size);
            pi1_ref_mb_modes += (i4_mb_x * i4_element_size);
        }

        for(i4_y = (i4_y_min + 1); i4_y <= (i4_y_max - 1);)
        {
            WORD32 i4_x_ref;
            WORD32 i4_y_ref;
            WORD32 i4_distleftX, i4_rangeX;
            WORD32 i4_disttopY, i4_rangeY;

            i4_y_ref = (i4_y + i4_y_offset);
            i4_disttopY = (i4_y_ref) & (i4_mb_ht - 1);
            i4_rangeY = (i4_mb_ht - i4_disttopY);

            pi1_ref_mb_modes_bkp_1 = pi1_ref_mb_modes;

            for(i4_x = (i4_x_min + 1); i4_x <= (i4_x_max - 1);)
            {
                i4_x_ref = (i4_x + i4_x_offset);
                i4_distleftX = (i4_x_ref) & (i4_mb_wd - 1);
                i4_rangeX = (i4_mb_wd - i4_distleftX);

                /* get the referecne layer mb type */
                i1_slice_id =
                    isvc_get_ref_layer_mbtype(pi1_ref_mb_modes_bkp_1, &i4_mb_type, i1_slice_id, 0);
                if(SVC_INTRA_MB == i4_mb_type)
                {
                    break;
                }
                i4_x += i4_rangeX;
                pi1_ref_mb_modes_bkp_1 += i4_element_size;
            }

            if(SVC_INTRA_MB == i4_mb_type)
            {
                break;
            }

            i4_y += i4_rangeY;
            pi1_ref_mb_modes += (i4_ref_mode_stride * i4_element_size);
        }
    }
    else
    {
        i1_slice_id = -1;
    }

    i4_unfill_check = 0;

    /* --------------------------------------------------------------------- */
    /* Copying the data from recon buffer to refSample Array.
     */
    /* NOTE: The copying of the data from recon buffer to refSample Array    */
    /*       can be optimized by bring in data at N-MB level,thus taking	 */
    /*		 advantage of the overlapping data which now gets copied every
     * MB*/
    /* --------------------------------------------------------------------- */
    {
        WORD32 i4_x_ref_start, i4_x_ref_end;
        WORD32 i4_y_ref_start, i4_y_ref_end;
        WORD32 i4_rangeW, i4_rangeH;
        WORD32 i4_offset;
        UWORD8 *pu1_src, *pu1_dst;
        UWORD8 *pu1_dst1, *pu1_dst2;

        /* Copy (refW x refH) dimension into reference sample array */
        i4_x_ref_start = MAX(0, MIN((i4_ref_wd - 1), i4_x_offset));
        i4_x_ref_end = MAX(0, MIN((i4_ref_wd - 1), (i4_refarray_wd - 1) + i4_x_offset));
        i4_y_ref_start = MAX(0, MIN((i4_ref_ht - 1), i4_y_offset));
        i4_y_ref_end = MAX(0, MIN((i4_ref_ht - 1), (i4_refarray_ht - 1) + i4_y_offset));

        /* find the actual data to be copied */
        i4_rangeW = (i4_x_ref_end - i4_x_ref_start + 1);
        i4_rangeH = (i4_y_ref_end - i4_y_ref_start + 1);

        /* get the reconbuffer pointer and ref sample array pointer */
        i4_offset =
            (i4_x_ref_start - i4_x_offset) + ((i4_y_ref_start - i4_y_offset) * i4_refarray_stride);

        if(0 == i4_chroma_flag)
        {
            pu1_refarray_1 = ps_ctxt->pu1_refarray_buffer;
            pu1_refarray_2 = NULL;

            pu1_src = pu1_inp_1;
            pu1_dst = pu1_refarray_1 + i4_offset;

            /* Copy luma data into refsample array */
            isvc_copy_data(pu1_src, i4_inp_stride, pu1_dst, i4_refarray_stride, i4_rangeW,
                           i4_rangeH);
        }
        else
        {
            pu1_refarray_1 = ps_ctxt->pu1_refarray_buffer;
            pu1_refarray_2 = ps_ctxt->pu1_refarray_cb;

            pu1_src = pu1_inp_1;
            pu1_dst1 = pu1_refarray_1 + i4_offset;

            pu1_dst2 = pu1_refarray_2 + i4_offset;

            isvc_copy_data_semiplanr(pu1_src, i4_inp_stride, pu1_dst1, pu1_dst2, i4_refarray_stride,
                                     i4_rangeW, i4_rangeH);
        }
    }
    {
        WORD32 i4_i, i4_j;
        UWORD8 *pu1_ref_idx_x, *pu1_ref_idx_y;

        WORD32 i4_x_ref;
        WORD32 i4_y_ref;
        WORD32 i4_mb_x, i4_mb_y;

        i4_y_ref = i4_y_offset;
        i4_x_ref = i4_x_offset;

        i4_mb_x = (i4_x_ref >> i4_mb_wd_sft);
        i4_mb_y = (i4_y_ref >> i4_mb_ht_sft);

        pi1_ref_mb_modes = (WORD8 *) ps_ref_mb_mode_map->pv_buffer;

        pi1_ref_mb_modes += (i4_mb_y * i4_ref_mode_stride * i4_element_size);
        pi1_ref_mb_modes += (i4_mb_x * i4_element_size);

        pu1_ref_idx_x = &(ps_lyr_ctxt->au1_refarray_x_idx[0]);
        pu1_ref_idx_y = &(ps_lyr_ctxt->au1_refarray_y_idx[0]);

        i4_j = 0;
        for(i4_y = 0; i4_y < i4_refarray_ht;)
        {
            WORD32 i4_x_ref;
            WORD32 i4_y_ref;
            WORD32 i4_distleftX, i4_rangeX;
            WORD32 i4_disttopY, i4_rangeY;

            i4_y_ref = i4_y + i4_y_offset;
            i4_disttopY = (i4_y_ref) & (i4_mb_ht - 1);
            i4_rangeY = (i4_mb_ht - i4_disttopY);

            memset(pu1_ref_idx_y, i4_j, i4_rangeY);
            pu1_ref_idx_y += i4_rangeY;

            i4_i = 0;
            pi1_ref_mb_modes_bkp_1 = pi1_ref_mb_modes;
            for(i4_x = 0; i4_x < i4_refarray_wd;)
            {
                i4_x_ref = i4_x + i4_x_offset;
                i4_distleftX = (i4_x_ref) & (i4_mb_wd - 1);
                i4_rangeX = (i4_mb_wd - i4_distleftX);

                if(0 == i4_j)
                {
                    memset(pu1_ref_idx_x, i4_i, i4_rangeX);
                    pu1_ref_idx_x += i4_rangeX;
                }

                isvc_get_ref_layer_mbtype(pi1_ref_mb_modes_bkp_1, &i4_mb_type, i1_slice_id,
                                          i1_cons_intr_samp_flag);

                if(SVC_INTRA_MB == i4_mb_type)
                {
                    u1_map_buf[i4_j][i4_i] = 1;
                    i4_dummy = 1;
                }
                else
                {
                    i4_unfill_check = 1;
                }

                i4_x = i4_x + i4_rangeX;
                i4_i++;
                pi1_ref_mb_modes_bkp_1 += i4_element_size;
            }
            i4_j++;
            i4_y = i4_y + i4_rangeY;
            pi1_ref_mb_modes += (i4_ref_mode_stride * i4_element_size);
        }
        ASSERT(1 == i4_dummy);
    }

    if(i4_unfill_check == 1)
    {
        isvc_fill_non_avail_pixel(ps_lyr_ctxt, pu1_refarray_1, pu1_refarray_2, i4_refarray_stride,
                                  i4_chroma_flag, u1_map_buf);
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_interpolate_base_luma_dyadic                       */
/*                                                                           */
/*  Description   : This function takes the reference array buffer & performs*/
/*                  intra resampling for dyadic scaling ratios               */
/*  Inputs        : pu1_inp_buf : ptr to the 12x12 reference sample buffer   */
/*                  pi2_tmp_filt_buf : ptr to the 12x16 buffer to hold the   */
/*                  vertically interpolated data                             */
/*                  pu1_out_buf : output buffer pointer                      */
/*                  i4_out_stride : output buffer stride                     */
/*  Globals       : none                                                     */
/*  Processing    : it does the interpolation in vertical direction followed */
/*                  by horizontal direction                                  */
/*  Outputs       : resampled pixels                                         */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 12 2010   Nithya          creation                             */
/*                                                                           */
/*****************************************************************************/
void isvc_interpolate_base_luma_dyadic(UWORD8 *pu1_inp_buf, WORD16 *pi2_tmp_filt_buf,
                                       UWORD8 *pu1_out_buf, WORD32 i4_out_stride)
{
    WORD32 i4_x, i4_y;
    WORD32 i4_coeff_0, i4_coeff_1, i4_coeff_2, i4_coeff_3;
    WORD32 i4_samp_0, i4_samp_1, i4_samp_2, i4_samp_3;
    WORD32 i4_rslt_1, i4_rslt_2;
    WORD32 i4_filt_stride, i4_src_stride;
    UWORD8 *pu1_inp, *pu1_out;
    WORD16 *pi2_tmp;

    /* Filter coefficient values for phase 4 */
    i4_coeff_0 = -3;
    i4_coeff_1 = 28;
    i4_coeff_2 = 8;
    i4_coeff_3 = -1;

    i4_filt_stride = 12;
    i4_src_stride = DYADIC_REF_W_Y;

    pu1_inp = pu1_inp_buf;
    pi2_tmp = pi2_tmp_filt_buf;
    pu1_out = pu1_out_buf;

    /* Vertical interpolation */
    for(i4_x = 0; i4_x < 12; i4_x++)
    {
        /* y = 0, y_phase = 12 */
        i4_samp_0 = pu1_inp[i4_x];
        pu1_inp += i4_src_stride;
        i4_samp_1 = pu1_inp[i4_x];
        pu1_inp += i4_src_stride;
        i4_samp_2 = pu1_inp[i4_x];
        pu1_inp += i4_src_stride;
        i4_samp_3 = pu1_inp[i4_x];
        pu1_inp += i4_src_stride;

        /* since y_phase 12 for y = 0 */
        i4_rslt_1 = i4_samp_0 * i4_coeff_3;
        i4_rslt_1 += i4_samp_1 * i4_coeff_2;
        i4_rslt_1 += i4_samp_2 * i4_coeff_1;
        i4_rslt_1 += i4_samp_3 * i4_coeff_0;

        pi2_tmp[i4_x] = i4_rslt_1;
        pi2_tmp += i4_filt_stride;

        for(i4_y = 1; i4_y < 15; i4_y += 2)
        {
            i4_samp_0 = i4_samp_1;
            i4_samp_1 = i4_samp_2;
            i4_samp_2 = i4_samp_3;
            i4_samp_3 = pu1_inp[i4_x];

            /* y_phase is 4 for odd values of y */
            /* and 12 for even values of y    */
            i4_rslt_1 = i4_samp_0 * i4_coeff_0;
            i4_rslt_1 += i4_samp_1 * i4_coeff_1;
            i4_rslt_1 += i4_samp_2 * i4_coeff_2;
            i4_rslt_1 += i4_samp_3 * i4_coeff_3;

            i4_rslt_2 = i4_samp_0 * i4_coeff_3;
            i4_rslt_2 += i4_samp_1 * i4_coeff_2;
            i4_rslt_2 += i4_samp_2 * i4_coeff_1;
            i4_rslt_2 += i4_samp_3 * i4_coeff_0;

            /* Storing the results */
            pi2_tmp[i4_x] = i4_rslt_1;
            pi2_tmp += i4_filt_stride;
            pi2_tmp[i4_x] = i4_rslt_2;

            /* Incrementing the pointers */
            pi2_tmp += i4_filt_stride;
            pu1_inp += i4_src_stride;
        }

        /* y = 15, y_phase = 4 */
        i4_samp_0 = i4_samp_1;
        i4_samp_1 = i4_samp_2;
        i4_samp_2 = i4_samp_3;
        i4_samp_3 = pu1_inp[i4_x];

        i4_rslt_1 = i4_samp_0 * i4_coeff_0;
        i4_rslt_1 += i4_samp_1 * i4_coeff_1;
        i4_rslt_1 += i4_samp_2 * i4_coeff_2;
        i4_rslt_1 += i4_samp_3 * i4_coeff_3;

        pi2_tmp[i4_x] = i4_rslt_1;
        pu1_inp = pu1_inp_buf;
        pi2_tmp = pi2_tmp_filt_buf;
    }

    /* Horizontal interpolation */
    for(i4_y = 0; i4_y < 16; i4_y++)
    {
        /* x = 0, x_phase = 12 */
        i4_samp_0 = *pi2_tmp++;
        i4_samp_1 = *pi2_tmp++;
        i4_samp_2 = *pi2_tmp++;
        i4_samp_3 = *pi2_tmp++;

        /* since x_phase 12 for x = 0 */
        i4_rslt_1 = i4_samp_0 * i4_coeff_3;
        i4_rslt_1 += i4_samp_1 * i4_coeff_2;
        i4_rslt_1 += i4_samp_2 * i4_coeff_1;
        i4_rslt_1 += i4_samp_3 * i4_coeff_0;
        i4_rslt_1 += 512;

        i4_rslt_1 >>= 10;
        pu1_out[0] = CLIPUCHAR(i4_rslt_1);

        for(i4_x = 1; i4_x < 15; i4_x += 2)
        {
            i4_samp_0 = i4_samp_1;
            i4_samp_1 = i4_samp_2;
            i4_samp_2 = i4_samp_3;
            i4_samp_3 = *pi2_tmp++;

            /* x_phase is 4 for odd values of x */
            /* and 12 for even values of x    */
            i4_rslt_1 = i4_samp_0 * i4_coeff_0;
            i4_rslt_1 += i4_samp_1 * i4_coeff_1;
            i4_rslt_1 += i4_samp_2 * i4_coeff_2;
            i4_rslt_1 += i4_samp_3 * i4_coeff_3;
            i4_rslt_1 += 512;

            i4_rslt_2 = i4_samp_0 * i4_coeff_3;
            i4_rslt_2 += i4_samp_1 * i4_coeff_2;
            i4_rslt_2 += i4_samp_2 * i4_coeff_1;
            i4_rslt_2 += i4_samp_3 * i4_coeff_0;
            i4_rslt_2 += 512;

            i4_rslt_1 >>= 10;
            i4_rslt_2 >>= 10;

            pu1_out[i4_x] = CLIPUCHAR(i4_rslt_1);
            pu1_out[i4_x + 1] = CLIPUCHAR(i4_rslt_2);
        }

        /* x = 15 */
        i4_samp_0 = i4_samp_1;
        i4_samp_1 = i4_samp_2;
        i4_samp_2 = i4_samp_3;
        i4_samp_3 = *pi2_tmp++;

        i4_rslt_1 = i4_samp_0 * i4_coeff_0;
        i4_rslt_1 += i4_samp_1 * i4_coeff_1;
        i4_rslt_1 += i4_samp_2 * i4_coeff_2;
        i4_rslt_1 += i4_samp_3 * i4_coeff_3;
        i4_rslt_1 += 512;

        i4_rslt_1 >>= 10;
        pu1_out[i4_x] = CLIPUCHAR(i4_rslt_1);
        pu1_out += i4_out_stride;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_vert_interpol_chroma_dyadic                        */
/*                                                                           */
/*  Description   : This function takes the reference array buffer & performs*/
/*                  vertical intra resampling for dyadic scaling ratios  for */
/*                  chroma for the following ref_lyr_chroma_phase_y_plus1 and*/
/*                  chroma_phase_y_plus1:                                    */
/*                  ref_lyr    cur_lyr                                       */
/*                    0      0                                               */
/*                    1      0                                               */
/*                    1      1                                               */
/*                    1      2                                               */
/*                    2      1                                               */
/*                    2      2                                               */
/*  Inputs         : pu1_inp_buf : ptr to the 6x6 reference sample buffer    */
/*                   pi2_tmp_filt_buf : ptr to the 6x8 buffer to hold the    */
/*                   vertically interpolated data                            */
/*                   i4_phase_0 : y phase for even values of y               */
/*                   i4_phase_1 : y phase for odd values of y                */
/*  Globals       : none                                                     */
/*  Processing    : it does the interpolation in vertical direction          */
/*  Outputs       : vertically resampled samples                             */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 12 2010   Nithya          creation                             */
/*                                                                           */
/*****************************************************************************/
void isvc_vert_interpol_chroma_dyadic(UWORD8 *pu1_inp_buf, WORD16 *pi2_tmp_filt_buf,
                                      WORD32 i4_phase_0, WORD32 i4_phase_1)
{
    WORD32 i4_x, i4_y;
    WORD32 i4_coeff_0, i4_coeff_1, i4_coeff_2, i4_coeff_3;
    WORD32 i4_samp_0, i4_samp_1;
    WORD32 i4_rslt_1, i4_rslt_2;
    WORD32 i4_filt_stride, i4_src_stride;
    UWORD8 *pu1_inp;
    WORD16 *pi2_tmp;

    i4_coeff_0 = 16 - i4_phase_0;
    i4_coeff_1 = i4_phase_0;
    i4_coeff_2 = 16 - i4_phase_1;
    i4_coeff_3 = i4_phase_1;

    pu1_inp = pu1_inp_buf;
    pi2_tmp = pi2_tmp_filt_buf;
    i4_filt_stride = 6;
    i4_src_stride = DYADIC_REF_W_C;

    /* Vertical interpolation */
    for(i4_x = 0; i4_x < 6; i4_x++)
    {
        /* y = 0, y_phase = phase_0 */
        i4_samp_0 = pu1_inp[i4_x];
        pu1_inp += i4_src_stride;
        i4_samp_1 = pu1_inp[i4_x];
        pu1_inp += i4_src_stride;

        /* since y_phase = phase_0 for y = 0 */
        i4_rslt_1 = i4_samp_0 * i4_coeff_0;
        i4_rslt_1 += i4_samp_1 * i4_coeff_1;

        pi2_tmp[i4_x] = i4_rslt_1;
        pi2_tmp += i4_filt_stride;

        for(i4_y = 1; i4_y < 7; i4_y += 2)
        {
            i4_samp_0 = i4_samp_1;
            i4_samp_1 = pu1_inp[i4_x];

            /* y_phase is phase_1 for odd values of y */
            /* and phase_0 for even values of y      */
            i4_rslt_1 = i4_samp_0 * i4_coeff_2;
            i4_rslt_1 += i4_samp_1 * i4_coeff_3;

            i4_rslt_2 = i4_samp_0 * i4_coeff_0;
            i4_rslt_2 += i4_samp_1 * i4_coeff_1;

            pi2_tmp[i4_x] = i4_rslt_1;
            pi2_tmp += i4_filt_stride;
            pi2_tmp[i4_x] = i4_rslt_2;
            pi2_tmp += i4_filt_stride;
            pu1_inp += i4_src_stride;
        }

        /* y = 7, y_phase = phase_1 */
        i4_samp_0 = i4_samp_1;
        i4_samp_1 = pu1_inp[i4_x];

        i4_rslt_1 = i4_samp_0 * i4_coeff_2;
        i4_rslt_1 += i4_samp_1 * i4_coeff_3;

        pi2_tmp[i4_x] = i4_rslt_1;

        pu1_inp = pu1_inp_buf;
        pi2_tmp = pi2_tmp_filt_buf;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvc_horz_interpol_chroma_dyadic                        */
/*                                                                           */
/*  Description   : This function takes the reference array buffer & performs*/
/*                  horizontal intra resampling for dyadic scaling ratios for*/
/*                  chroma with following ref_lyr_chroma_phase_x_plus1_flag  */
/*                  and chroma_phase_x_plus1_flag:                           */
/*                  ref_lyr    cur_lyr                                       */
/*                    0      0                                               */
/*                    1      0                                               */
/*                    1      1                                               */
/*  Inputs        : pi2_tmp_filt_buf : ptr to the 6x8 buffer containing the  */
/*                  vertically interpolated data                             */
/*                  pu1_out_buf : pointer to the output buffer               */
/*                  i4_out_stride : output buffer stride                     */
/*                  i4_phase_0 : x phase for even values of x                */
/*                  i4_phase_1 : x phase for odd values of x                 */
/*  Globals       : none                                                     */
/*  Processing    : it does the interpolation in vertical direction          */
/*  Outputs       : resampled samples                                        */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 12 2010   Nithya          creation                   */
/*                                                                           */
/*****************************************************************************/
void isvc_horz_interpol_chroma_dyadic(WORD16 *pi2_tmp_filt_buf, UWORD8 *pu1_out_buf,
                                      WORD32 i4_out_stride, WORD32 i4_phase_0, WORD32 i4_phase_1)
{
    WORD32 i4_x, i4_y;
    WORD32 i4_coeff_0, i4_coeff_1, i4_coeff_2, i4_coeff_3;
    WORD32 i4_samp_0, i4_samp_1;
    WORD32 i4_rslt_1, i4_rslt_2;
    WORD32 i4_dst_stride;
    UWORD8 *pu1_out;
    WORD16 *pi2_tmp;

    i4_coeff_0 = 16 - i4_phase_0;
    i4_coeff_1 = i4_phase_0;
    i4_coeff_2 = 16 - i4_phase_1;
    i4_coeff_3 = i4_phase_1;

    pu1_out = pu1_out_buf;
    pi2_tmp = pi2_tmp_filt_buf;
    i4_dst_stride = i4_out_stride;

    /* Horizontal interpolation */
    for(i4_y = 0; i4_y < 8; i4_y++)
    {
        /* x = 0, x_phase = phase_0 */
        i4_samp_0 = *pi2_tmp++;
        i4_samp_1 = *pi2_tmp++;

        /* since x_phase = phase_0 for x = 0 */
        i4_rslt_1 = i4_samp_0 * i4_coeff_0;
        i4_rslt_1 += i4_samp_1 * i4_coeff_1;

        /* Round to 8-bit value */
        i4_rslt_1 += 128;
        i4_rslt_1 >>= 8;

        pu1_out[0] = i4_rslt_1;

        for(i4_x = 1; i4_x < 7; i4_x += 2)
        {
            i4_samp_0 = i4_samp_1;
            i4_samp_1 = *pi2_tmp++;

            /* x_phase is phase_1 for odd values of x */
            /* and phase_0 for even values of x      */
            i4_rslt_1 = i4_samp_0 * i4_coeff_2;
            i4_rslt_1 += i4_samp_1 * i4_coeff_3;

            i4_rslt_2 = i4_samp_0 * i4_coeff_0;
            i4_rslt_2 += i4_samp_1 * i4_coeff_1;

            /* Rounding to 8-bit values */
            i4_rslt_1 += 128;
            i4_rslt_1 >>= 8;
            i4_rslt_2 += 128;
            i4_rslt_2 >>= 8;

            pu1_out[2 * i4_x] = i4_rslt_1;
            pu1_out[2 * (i4_x + 1)] = i4_rslt_2;
        }

        /* y = 7, y_phase = phase_1 */
        i4_samp_0 = i4_samp_1;
        i4_samp_1 = *pi2_tmp++;

        /* since x_phase = phase_1 for x = 7 */
        i4_rslt_1 = i4_samp_0 * i4_coeff_2;
        i4_rslt_1 += i4_samp_1 * i4_coeff_3;

        /* Round to 8-bit value */
        i4_rslt_1 += 128;
        i4_rslt_1 >>= 8;

        pu1_out[2 * 7] = i4_rslt_1;
        pu1_out += i4_dst_stride;
    }
}

static void isvc_interpolate_intra_base(void *pv_intra_samp_ctxt, UWORD8 *pu1_out,
                                        WORD32 i4_out_stride, WORD32 i4_refarray_wd,
                                        WORD32 i4_chroma_flag, WORD32 i4_refarray_flag)
{
    intra_sampling_ctxt_t *ps_ctxt;
    intra_samp_lyr_ctxt *ps_lyr_ctxt;
    WORD32 i4_x, i4_y;
    UWORD8 *pu1_refarray;
    coordinates_t *ps_phase;

    WORD32 i4_temp_array_ht;
    WORD32 *pi4_interp_buff;
    WORD32 *pi4_interp_buff_temp;

    WORD32 i4_mb_wd;
    WORD32 i4_mb_ht;

    WORD32 i4_x_min, i4_x_max;

    ps_ctxt = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];

    if(0 == i4_refarray_flag)
    {
        pu1_refarray = ps_ctxt->pu1_refarray_buffer;
    }
    else
    {
        pu1_refarray = ps_ctxt->pu1_refarray_cb;
    }

    i4_mb_wd = MB_SIZE >> i4_chroma_flag;
    i4_mb_ht = MB_SIZE >> i4_chroma_flag;

    i4_x_min = ps_lyr_ctxt->i2_x_min_pos;
    i4_x_max = ps_lyr_ctxt->i2_x_max_pos;

    ps_phase = ps_lyr_ctxt->ps_phase;

    i4_temp_array_ht = i4_mb_ht;
    pi4_interp_buff = ps_ctxt->pi4_temp_interpolation_buffer;
    pi4_interp_buff_temp = pi4_interp_buff;

    for(i4_y = 0; i4_y < i4_temp_array_ht; i4_y++)
    {
        for(i4_x = (i4_x_min - 1); i4_x <= (i4_x_max + 2); i4_x++)
        {
            WORD32 i4_y_ref = ps_lyr_ctxt->pi4_ref_array_positions_y[i4_y];
            WORD32 i4_y_phase =
                ps_phase[(ps_lyr_ctxt->ps_mb_pos->i4_ordinate * i4_mb_ht + i4_y) % 3].i4_ordinate;
            UWORD8 *pu1_refarray_temp = pu1_refarray + i4_x + (i4_y_ref * i4_refarray_wd);

            if(0 == i4_chroma_flag)
            {
                *(pi4_interp_buff + i4_x) =
                    (g_ai1_interp_filter_luma[i4_y_phase]) *
                        (*(pu1_refarray_temp - i4_refarray_wd)) +

                    (g_ai1_interp_filter_luma[16 + i4_y_phase]) * (*(pu1_refarray_temp)) +

                    (g_ai1_interp_filter_luma[32 + i4_y_phase]) *
                        (*(pu1_refarray_temp + i4_refarray_wd)) +

                    (g_ai1_interp_filter_luma[48 + i4_y_phase]) *
                        (*(pu1_refarray_temp + (2 * i4_refarray_wd)));
            }
            else
            {
                *(pi4_interp_buff + i4_x) =
                    (g_au1_interp_filter_chroma[i4_y_phase]) * (*(pu1_refarray_temp)) +
                    (g_au1_interp_filter_chroma[16 + i4_y_phase]) *
                        (*(pu1_refarray_temp + i4_refarray_wd));
            }
        }

        pi4_interp_buff = pi4_interp_buff + i4_refarray_wd;
    }

    pi4_interp_buff = pi4_interp_buff_temp;

    for(i4_y = 0; i4_y < i4_temp_array_ht; i4_y++)
    {
        for(i4_x = 0; i4_x < i4_mb_wd; i4_x++)
        {
            WORD32 i4_x_ref = ps_lyr_ctxt->pi4_ref_array_positions_y[i4_x];
            WORD32 i4_x_phase =
                ps_phase[(ps_lyr_ctxt->ps_mb_pos->i4_abscissa * MAX_REF_ARR_WD_HT + i4_x) % 3]
                    .i4_ordinate;

            pi4_interp_buff_temp = pi4_interp_buff + i4_x_ref;

            if(0 == i4_chroma_flag)
            {
                *(pu1_out + i4_x + (i4_y * i4_out_stride)) = CLIPUCHAR(
                    ((g_ai1_interp_filter_luma[i4_x_phase]) * (*(pi4_interp_buff_temp - 1)) +
                     (g_ai1_interp_filter_luma[16 + i4_x_phase]) * (*(pi4_interp_buff_temp)) +
                     (g_ai1_interp_filter_luma[32 + i4_x_phase]) * (*(pi4_interp_buff_temp + 1)) +
                     (g_ai1_interp_filter_luma[48 + i4_x_phase]) * (*(pi4_interp_buff_temp + 2)) +
                     512) >>
                    10);
            }
            else
            {
                *(pu1_out + (2 * i4_x) + (i4_y * i4_out_stride)) = CLIPUCHAR(
                    ((g_au1_interp_filter_chroma[i4_x_phase]) * (*(pi4_interp_buff_temp)) +
                     (g_au1_interp_filter_chroma[16 + i4_x_phase]) * (*(pi4_interp_buff_temp + 1)) +
                     512) >>
                    10);
            }
        }

        pi4_interp_buff = pi4_interp_buff + i4_refarray_wd;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name :  isvc_intra_samp_mb_dyadic                              */
/*                                                                           */
/*  Description   : MB level function which performs the intra resampling    */
/*                  of data of an MB (luma and chroma inclusive) for dyadic  */
/*                  scaling ratios                                           */
/*                                                                           */
/*  Inputs        : pv_intra_samp_ctxt : intra sampling context              */
/*                  ps_ref_luma : reference layer luma data buffer desc      */
/*                  ps_ref_chroma : reference layer chroma data buffer desc  */
/*                  ps_ref_mb_mode_map : ref layer mb mode map buff desc     */
/*                  ps_curr_luma : current layer out luma buffer desc        */
/*                  ps_curr_chroma : current layer out chroma buffer desc    */
/*                  x,y : current mb coorinate                               */
/*  Globals       : none                                                     */
/*  Processing    : it calls the reference layer construction followed by    */
/*                   interpolation function for luma and cb and cr           */
/*  Outputs       : inter resampled data of current MB                       */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         07 12 2010   Nithya          creation                             */
/*                                                                           */
/*****************************************************************************/
void isvc_intra_samp_mb_dyadic(void *pv_intra_samp_ctxt, mem_element_t *ps_ref_luma,
                               mem_element_t *ps_ref_chroma, mem_element_t *ps_ref_mb_mode_map,
                               mem_element_t *ps_curr_luma, mem_element_t *ps_curr_chroma,
                               UWORD16 u2_mb_x, UWORD16 u2_mb_y,
                               WORD32 i4_scaled_ref_layer_left_offset,
                               WORD32 i4_scaled_ref_layer_top_offset)
{
    UWORD8 *pu1_inp_luma, *pu1_inp_chroma;
    UWORD8 *pu1_out_luma, *pu1_out_chroma;
    UWORD8 *pu1_out_cb, *pu1_out_cr;
    UWORD8 *pu1_refarray_luma, *pu1_refarray_cb, *pu1_refarray_cr;
    WORD16 *pi2_tmp_filt_buf;
    WORD32 i4_inp_luma_stride, i4_inp_chroma_stride;
    WORD32 i4_out_luma_stride, i4_out_chroma_stride;
    UWORD16 u2_mb_x_ref, u2_mb_y_ref;
    intra_sampling_ctxt_t *ps_ctxt;
    intra_samp_lyr_ctxt *ps_lyr_ctxt;
    WORD32 i4_scaled_mb_x, i4_scaled_mb_y;
    WORD32 i4_top, i4_left;

    ps_ctxt = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];

    i4_scaled_mb_x = u2_mb_x - (i4_scaled_ref_layer_left_offset >> 4);
    i4_scaled_mb_y = u2_mb_y - (i4_scaled_ref_layer_top_offset >> 4);

    if(i4_scaled_mb_x & 0x1)
    {
        i4_left = 1;
    }
    else
    {
        i4_left = -1;
    }
    if(i4_scaled_mb_y & 0x1)
    {
        i4_top = 1;
    }
    else
    {
        i4_top = -1;
    }

    u2_mb_x_ref = (i4_scaled_mb_x >> 1);
    u2_mb_y_ref = (i4_scaled_mb_y >> 1);

    pu1_inp_luma = (UWORD8 *) ps_ref_luma->pv_buffer;
    pu1_inp_chroma = (UWORD8 *) ps_ref_chroma->pv_buffer;

    i4_inp_luma_stride = ps_ref_luma->i4_num_element_stride;
    i4_inp_chroma_stride = ps_ref_chroma->i4_num_element_stride;

    /* ------- Constructing refSampleArray ----------------------- */
    isvc_reflayer_construction_dyadic(pv_intra_samp_ctxt, ps_ref_mb_mode_map, pu1_inp_luma,
                                      pu1_inp_chroma, i4_inp_luma_stride, i4_inp_chroma_stride,
                                      i4_top, i4_left, u2_mb_x_ref, u2_mb_y_ref);

    /* --------------------------------------------------------------------- */
    /* LUMA INTERPOLATION                                     */
    /* --------------------------------------------------------------------- */
    pu1_refarray_luma = ps_ctxt->pu1_refarray_buffer;
    if(1 == i4_top)
    {
        pu1_refarray_luma += (DYADIC_REF_W_Y << 3);
    }
    if(1 == i4_left)
    {
        pu1_refarray_luma += 8;
    }
    pu1_out_luma = (UWORD8 *) ps_curr_luma->pv_buffer;
    i4_out_luma_stride = ps_curr_luma->i4_num_element_stride;
    pi2_tmp_filt_buf = (WORD16 *) ps_ctxt->pi4_temp_interpolation_buffer;

    ps_lyr_ctxt->pf_interpolate_luma(pu1_refarray_luma, pi2_tmp_filt_buf, pu1_out_luma,
                                     i4_out_luma_stride);

    /* --------------------------------------------------------------------- */
    /* CHROMA INTERPOLATION                                   */
    /* --------------------------------------------------------------------- */
    pu1_out_chroma = (UWORD8 *) ps_curr_chroma->pv_buffer;
    i4_out_chroma_stride = ps_curr_chroma->i4_num_element_stride;

    /* CB */
    pu1_out_cb = pu1_out_chroma;
    pu1_refarray_cb = ps_ctxt->pu1_refarray_cb;

    if(1 == i4_top)
    {
        pu1_refarray_cb += (DYADIC_REF_W_C << 2);
    }
    if(1 == i4_left)
    {
        pu1_refarray_cb += 4;
    }

    /* Vertical interpolation */
    ps_lyr_ctxt->pf_vert_interpol_chroma(pu1_refarray_cb, pi2_tmp_filt_buf,
                                         ps_lyr_ctxt->i4_y_phase_0, ps_lyr_ctxt->i4_y_phase_1);

    /* Horizontal interpolation */
    ps_lyr_ctxt->pf_horz_interpol_chroma(pi2_tmp_filt_buf, pu1_out_cb, i4_out_chroma_stride,
                                         ps_lyr_ctxt->i4_x_phase_0, ps_lyr_ctxt->i4_x_phase_1);

    /* CR */
    pu1_out_cr = pu1_out_chroma + 1;
    pu1_refarray_cr = ps_ctxt->pu1_refarray_cr;

    if(1 == i4_top)
    {
        pu1_refarray_cr += (DYADIC_REF_W_C << 2);
    }
    if(1 == i4_left)
    {
        pu1_refarray_cr += 4;
    }

    /* Vertical interpolation */
    ps_lyr_ctxt->pf_vert_interpol_chroma(pu1_refarray_cr, pi2_tmp_filt_buf,
                                         ps_lyr_ctxt->i4_y_phase_0, ps_lyr_ctxt->i4_y_phase_1);

    /* Horizontal interpolation */
    ps_lyr_ctxt->pf_horz_interpol_chroma(pi2_tmp_filt_buf, pu1_out_cr, i4_out_chroma_stride,
                                         ps_lyr_ctxt->i4_x_phase_0, ps_lyr_ctxt->i4_x_phase_1);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name :  isvc_intra_samp_mb                                     */
/*                                                                           */
/*  Description   : MB level function which performs the intra resampling    */
/*                  of data of an MB (luma and chroma inclusive)             */
/*                                                                           */
/*  Inputs        : pv_intra_samp_ctxt : intra sampling context              */
/*                  ps_ref_luma : reference layer luma data buffer desc      */
/*                  ps_ref_chroma : reference layer chroma data buffer desc  */
/*                  ps_ref_mb_mode_map : ref layer mb mode map buff desc     */
/*                  ps_curr_luma : current layer out luma buffer desc        */
/*                  ps_curr_chroma : current layer out chroma buffer desc    */
/*                  x,y : current mb coorinate                       */
/*  Globals       : none                                                     */
/*  Processing    : it calls the reference layer construction followed by    */
/*                   interpolation function for luma and cb and cr           */
/*  Outputs       : inter resampled data of current MB                       */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         07 12 2010   Nithya          creation               */
/*                                                                           */
/*****************************************************************************/
void isvc_intra_samp_mb(void *pv_intra_samp_ctxt_luma, void *pv_intra_samp_ctxt_chroma,
                        mem_element_t *ps_ref_luma, mem_element_t *ps_ref_chroma,
                        mem_element_t *ps_ref_mb_mode_map, mem_element_t *ps_curr_luma,
                        mem_element_t *ps_curr_chroma)
{
    UWORD8 *pu1_inp_luma, *pu1_inp_chroma;
    UWORD8 *pu1_out_luma, *pu1_out_chroma;
    UWORD8 *pu1_out_cb, *pu1_out_cr;
    WORD32 i4_inp_luma_stride, i4_inp_chroma_stride;
    WORD32 i4_out_luma_stride, i4_out_chroma_stride;
    WORD32 i4_chroma_flag, i4_refarray_stride;

    intra_sampling_ctxt_t *ps_ctxt_luma;
    intra_sampling_ctxt_t *ps_ctxt_chroma;

    ps_ctxt_luma = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt_luma;
    ps_ctxt_chroma = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt_chroma;

    i4_refarray_stride = ps_ctxt_luma->i4_refarray_stride;

    pu1_inp_luma = (UWORD8 *) ps_ref_luma->pv_buffer;
    pu1_inp_chroma = (UWORD8 *) ps_ref_chroma->pv_buffer;

    i4_inp_luma_stride = ps_ref_luma->i4_num_element_stride;
    i4_inp_chroma_stride = ps_ref_chroma->i4_num_element_stride;

    pu1_out_luma = (UWORD8 *) ps_curr_luma->pv_buffer;
    i4_out_luma_stride = ps_curr_luma->i4_num_element_stride;

    i4_chroma_flag = 0;

    /* ------- Constructing refSampleArray ----------------------- */
    isvc_reflayer_construction(pv_intra_samp_ctxt_luma, pu1_inp_luma, i4_inp_luma_stride,
                               i4_refarray_stride, ps_ref_mb_mode_map, i4_chroma_flag);

    /* ---- Interpolation process for Intra_Base prediction	 ------ */
    isvc_interpolate_intra_base(pv_intra_samp_ctxt_luma, pu1_out_luma, i4_out_luma_stride,
                                i4_refarray_stride, i4_chroma_flag, 0);

    pu1_out_chroma = (UWORD8 *) ps_curr_chroma->pv_buffer;
    i4_out_chroma_stride = ps_curr_chroma->i4_num_element_stride;

    pu1_out_cb = pu1_out_chroma;
    pu1_out_cr = pu1_out_cb + 1;

    i4_refarray_stride = ps_ctxt_chroma->i4_refarray_stride;

    i4_chroma_flag = 1;

    /* ------- Constructing refSampleArray ----------------------- */
    isvc_reflayer_construction(pv_intra_samp_ctxt_chroma, pu1_inp_chroma, i4_inp_chroma_stride,
                               i4_refarray_stride, ps_ref_mb_mode_map, i4_chroma_flag);

    /* ---- Cb Interpolation process for Intra_Base prediction	 ------ */
    isvc_interpolate_intra_base(pv_intra_samp_ctxt_chroma, pu1_out_cb, i4_out_chroma_stride,
                                i4_refarray_stride, i4_chroma_flag, 0);

    /* ---- Cr Interpolation process for Intra_Base prediction	 ------ */
    isvc_interpolate_intra_base(pv_intra_samp_ctxt_chroma, pu1_out_cr, i4_out_chroma_stride,
                                i4_refarray_stride, i4_chroma_flag, 1);
}