xref: /aosp_15_r20/external/libavc/decoder/svc/isvcd_resamp_svc.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
 *
 * @author
 *  Kishore
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */

#include <assert.h>
#include <string.h>

#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_bitstrm.h"
#include "ih264d_defs.h"
#include "ih264d_debug.h"
#include "ih264d_structs.h"
#include "ih264d_defs.h"
#include "ih264d_parse_cavlc.h"
#include "ih264d_mb_utils.h"
#include "ih264d_deblocking.h"
#include "ih264d_dpb_manager.h"
#include "ih264d_mvpred.h"
#include "ih264d_inter_pred.h"
#include "ih264d_process_pslice.h"
#include "ih264d_error_handler.h"
#include "ih264d_cabac.h"
#include "ih264d_debug.h"
#include "ih264d_tables.h"
#include "ih264d_parse_slice.h"
#include "ih264d_utils.h"
#include "ih264d_parse_islice.h"
#include "ih264d_process_bslice.h"
#include "ih264d_process_intra_mb.h"
#include "isvcd_resamp_svc.h"
#include "ih264_debug.h"

/*****************************************************************************/
/*                                                                           */
/*  Function Name :  svcd_get_ceil_log2                                      */
/*                                                                           */
/*  Description   : this function returns the CeilLog2 of the given number   */
/*                                                                           */
/*                                                                           */
/*  Inputs        : i4_input : input number                                  */
/*  Globals       : none                                                     */
/*  Processing    : it calculate the bits and returns it                     */
/*                                                                           */
/*  Outputs       : none                                                     */
/*  Returns       : ceil of log to base 2                                    */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         05 04 2009   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
WORD32 svcd_get_ceil_log2(WORD32 i4_input)
{
    WORD32 i4_bits = 0;

    /* check for negative number */
    ASSERT(i4_input >= 0);

    i4_input--;
    while(i4_input > 0)
    {
        i4_bits++;
        i4_input >>= 1;
    } /* endof while input > 0 loop */
    return (i4_bits);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_2d_memset                                           */
/*                                                                           */
/*  Description   : Function performs 2D memset operation                    */
/*                                                                           */
/*                                                                           */
/*  Inputs        : 1. Buffer pointer                                        */
/*                  2. width                                                 */
/*                  3. Height                                                */
/*                  4. Stride                                                */
/*                  5. value                                                 */
/*  Globals       : None                                                     */
/*  Processing    : calls memset fucntion                                    */
/*                                                                           */
/*  Outputs       : Updates the buffer                                       */
/*  Returns       : status                                                   */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         24 06 2009   Kishore      Draft                                   */
/*                                                                           */
/*****************************************************************************/
void svcd_2d_memset(void *pv_buf, WORD32 i4_width, WORD32 i4_ht, WORD32 i4_stride, WORD32 i4_val)
{
    WORD32 i4_y;
    UWORD8 *pu1_buf;

    pu1_buf = (UWORD8 *) pv_buf;

    for(i4_y = 0; i4_y < i4_ht; i4_y++)
    {
        memset(pu1_buf, i4_val, i4_width);

        /* Increment the pointer */
        pu1_buf += i4_stride;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_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                        */
/*                                                                           */
/*****************************************************************************/
void svcd_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);

    /* loop for copy all the lines requried */
    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;
    }
    return;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_copy_data_semiplanr                                 */
/*                                                                           */
/*  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                   */
/*                  i4_src_stride : source buffer stride                     */
/*                  pu1_dst1 : pointer to the destination buffer 1           */
/*                  pu1_dst2 : pointer to the destination buffer 2           */
/*                  i4_dst_stride : destination buffer stride                */
/*                  i4_num_bytes : number of bytes to be copied              */
/*                  i4_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                        */
/*                                                                           */
/*****************************************************************************/
void svcd_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;

    if(NULL == pu1_src) ||(NULL == pu1_dst1) ||(NULL == pu1_dst2)){return;}

    /* loop for copy all the lines requried */
    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;
    }
    return;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_get_ref_layer_avlblty_dyadic                        */
/*                                                                           */
/*  Description   : This function is used to find the mb type of the         */
/*                  corresponding MB in the reference layer for dyadic cases */
/*                                                                           */
/*  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_ref_mb_x : reference MB location X                    */
/*                  i4_ref_mb_y : reference MB location Y                    */
/*                  pi4_mb_type : pointer to store the mb type               */
/*                  i1_curr_slice_id : slice id of current MB                */
/*                  i1_cons_intr_samp_flag :constrained intra resampling 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                        */
/*                                                                           */
/*****************************************************************************/
void svcd_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)
{
    inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms;
    WORD8 i1_mb_mode;

    /* get the location of the byte which has the current 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);
    ps_inter_lyr_mb_prms = (inter_lyr_mb_prms_t *) pi1_ref_mb_modes;
    i1_mb_mode = ps_inter_lyr_mb_prms->i1_mb_mode;

    if(0 > i1_mb_mode)
    {
        /* INTER */
        *pi4_avlblty = 0;
    }
    else
    {
        /* INTRA */
        *pi4_avlblty = 1;
    }

    /* if constrained intra flag is 1 then check for same slice id */
    if(1 == i1_cons_intr_samp_flag)
    {
        if(1 == *pi4_avlblty)
        {
            /* check for different slice idc */
            if(i1_mb_mode != i1_curr_slice_id)
            {
                /* store the mode as not available for upsampling */
                *pi4_avlblty = 0;
            }
        }
    }
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_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                             */
/*                                                                           */
/*****************************************************************************/
UWORD8 svcd_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 : svcd_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                             */
/*                                                                           */
/*****************************************************************************/
void svcd_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 : svcd_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                             */
/*                                                                           */
/*****************************************************************************/
void svcd_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)
{
    /* Index variables */
    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;

    /* --------------------------------------------------------------------- */
    /* Context and reference layer related variables                         */
    /* --------------------------------------------------------------------- */
    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;

    /* --------------------------------------------------------------------- */
    /* Temp Variables for Mapping context                                    */
    /* --------------------------------------------------------------------- */
    WORD32 i4_ref_wd_in_mbs;
    WORD32 i4_ref_ht_in_mbs;
    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;

    /* --------------------------------------------------------------------- */
    /* Local Pointer Declaration for arrays in Mapping context               */
    /* --------------------------------------------------------------------- */
    UWORD8 *pu1_refarray_luma;
    UWORD8 *pu1_refarray_cb, *pu1_refarray_cr;

    /* --------------------------------------------------------------------- */
    /* Derivation of local variables                                         */
    /* --------------------------------------------------------------------- */
    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 constrained intra resampling flag                             */
    /* --------------------------------------------------------------------- */
    i1_cons_intr_samp_flag = ps_lyr_ctxt->i1_constrained_intra_rsmpl_flag;

    ASSERT(NULL != pi1_ref_mb_modes);

    i4_ref_wd_in_mbs = ps_lyr_ctxt->i4_ref_width >> 4;
    i4_ref_ht_in_mbs = ps_lyr_ctxt->i4_ref_height >> 4;
    pu1_refarray_luma = ps_ctxt->pu1_refarray_buffer;
    pu1_refarray_cb = ps_ctxt->pu1_refarray_cb;
    pu1_refarray_cr = ps_ctxt->pu1_refarray_cr;

    /* --------------------------------------------------------------------- */
    /* Get the coordinates of the reference layer MB                         */
    /* --------------------------------------------------------------------- */
    i4_mbaddr_x = u2_mb_x;
    i4_mbaddr_y = u2_mb_y;

    /* --------------------------------------------------------------------- */
    /* Getting the size of the valid area of ref array to be brought in      */
    /* --------------------------------------------------------------------- */
    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;

    /* --------------------------------------------------------------------- */
    /* Derivation of ref slice MB idc                                        */
    /* --------------------------------------------------------------------- */
    if(1 == i1_cons_intr_samp_flag)
    {
        inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms;
        WORD8 *pi1_ref_mb_mode_tmp;
        WORD8 i1_mb_mode;

        /* get the location of the byte which has the current 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);
        ps_inter_lyr_mb_prms = (inter_lyr_mb_prms_t *) pi1_ref_mb_mode_tmp;
        i1_mb_mode = ps_inter_lyr_mb_prms->i1_mb_mode;

        /* The reference layer MB should be intra */
        ASSERT(i1_mb_mode >= 0);
        i1_slice_id = i1_mb_mode;
    }
    else
    {
        /* set to non valid value */
        i1_slice_id = -1;
    }

    /* --------------------------------------------------------------------- */
    /* Bring in the reference array                                          */
    /* --------------------------------------------------------------------- */
    {
        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;
        svcd_copy_data(pu1_src, i4_src_stride, pu1_dst, i4_dst_stride, i4_refarray_wd_luma,
                       i4_refarray_ht_luma);
        // Semi planar
        i4_src_stride = i4_inp_chroma_stride;
        i4_dst_stride = DYADIC_REF_W_C;
        pu1_src = pu1_inp_chroma;
        svcd_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);
    }

    /* --------------------------------------------------------------------- */
    /* Get the availability of 5 neighboring MBs                             */
    /* --------------------------------------------------------------------- */
    {
        /* mb_x + left, mb_y + top */
        svcd_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 */
        svcd_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 */
        svcd_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 */
        svcd_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 */
        svcd_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);
    }

    /* --------------------------------------------------------------------- */
    /* Filling the unavailable samples, if any                               */
    /* --------------------------------------------------------------------- */
    if(0x7 == u1_ny_avlblty)
    {
        /* All are available, exit */
        return;
    }

    if(!(u1_ny_avlblty & 0x7))
    {
        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 & 0x5))
    {
        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 & 0x3))
    {
        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 & 0x4))
    {
        if(!(u1_ny_avlblty & 0x8))
        {
            /* (mb_x-left,mb_y+top) not available */
            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];

        } /* if (mb_x-left,mb_y+top) not available */
        else
        {
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;
            UWORD8 u1_filled_samp;

            svcd_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)
            {
                svcd_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++)
                {
                    u1_filled_samp = svcd_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 */
            u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD,
                                                            pu1_refarray_cb, DYADIC_REF_W_C);

            u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD,
                                                            pu1_refarray_cr, DYADIC_REF_W_C);
        }
    }

    if(!(u1_ny_avlblty & 0x2))
    {
        if(!(u1_ny_avlblty & 0x10))
        {
            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];

        } /* if (mb_x+left,mb_y-top) not available */
        else
        {
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;
            UWORD8 u1_filled_samp;

            svcd_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)
            {
                svcd_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++)
                {
                    u1_filled_samp = svcd_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 */
            u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD,
                                                            pu1_refarray_cb, DYADIC_REF_W_C);

            u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD,
                                                            pu1_refarray_cr, DYADIC_REF_W_C);
        }
    }

    if(u1_ny_avlblty & 1)
    {
        if(!(u1_ny_avlblty & 2))
        {
            /* (mb_x+left,mb_y) is unavailable */
            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)
            {
                svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_diagonal_construct_dyadic(i4_xc0, i4_y, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cb, DYADIC_REF_W_C);
                u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_y, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cr, DYADIC_REF_W_C);
                i4_c_yD++;
            }

        } /* (mb_x+left,mb_y) is unavailable */

        if(!(u1_ny_avlblty & 4))
        {
            /* (mb_x,mb_y+top) is unavailable */
            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)
            {
                svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_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 = svcd_diagonal_construct_dyadic(i4_x, i4_yc0, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cb, DYADIC_REF_W_C);
                u1_filled_samp = svcd_diagonal_construct_dyadic(i4_x, i4_yc0, i4_c_xD, i4_c_yD,
                                                                pu1_refarray_cr, DYADIC_REF_W_C);
                i4_c_xD++;
            }

        } /* (mb_x,mb_y+top) is unavailable */
    }     /* if (mb_x+left,mb_y+top) not available */
    else
    {
        UWORD8 *pu1_tmp_dst1, *pu1_tmp_dst2;
        UWORD8 *pu1_tmp_src1, *pu1_tmp_src2;

        if(0x02 == (u1_ny_avlblty & 0x6))
        {
            /* (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];

        } /* if (mb_x+left,mb_y) available, (mb_x,mb_y+top) unavailable */
        else if(0x04 == (u1_ny_avlblty & 0x6))
        {
            /* (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];

        } /* if (mb_x+left,mb_y) unavailable, (mb_x,mb_y+top) available */
        else if(0x6 == (u1_ny_avlblty & 0x6))
        {
            /* (mb_x+left,mb_y) available, (mb_x,mb_y+top) available */
            WORD32 i4_xD, i4_yD;
            WORD32 i4_c_xD, i4_c_yD;
            UWORD8 u1_filled_samp;

            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++)
                {
                    u1_filled_samp = svcd_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 */
            u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD,
                                                            pu1_refarray_cb, DYADIC_REF_W_C);

            u1_filled_samp = svcd_diagonal_construct_dyadic(i4_xc0, i4_yc0, i4_c_xD, i4_c_yD,
                                                            pu1_refarray_cr, DYADIC_REF_W_C);

        } /* if (mb_x+left,mb_y) available, (mb_x,mb_y+top) available */
    }     /* (mb_x+left,mb_y+top) available */
    return;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_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 svcd_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;

        /* Store the output */
        pi2_tmp[i4_x] = i4_rslt_1;

        /* Increment the output ptr */
        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;
        } /* End of loop over y */

        /* 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;

        /* Store the output */
        pi2_tmp[i4_x] = i4_rslt_1;

        /* Reinitializing the ptrs */
        pu1_inp = pu1_inp_buf;
        pi2_tmp = pi2_tmp_filt_buf;
    } /* End of loop over x */

    /* 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;

        /* Store the output */
        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;

            /* Store the output */
            pu1_out[i4_x] = CLIPUCHAR(i4_rslt_1);
            pu1_out[i4_x + 1] = CLIPUCHAR(i4_rslt_2);
        } /* End of loop over x */

        /* 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;

        /* Store the output */
        pu1_out[i4_x] = CLIPUCHAR(i4_rslt_1);

        /* Increment the output ptr */
        pu1_out += i4_out_stride;
    } /* End of loop over y */

} /* svcd_interpolate_base_luma_dyadic */

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_vert_interpol_chroma_dyadic_1                       */
/*                                                                           */
/*  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 svcd_vert_interpol_chroma_dyadic_1(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 = 8 - i4_phase_0;
    i4_coeff_1 = i4_phase_0;
    i4_coeff_2 = 8 - 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;

        /* Store the output */
        pi2_tmp[i4_x] = i4_rslt_1;

        /* Increment the output ptr */
        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;

            /* 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;

        } /* End of loop over y */

        /* 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;

        /* Store the output */
        pi2_tmp[i4_x] = i4_rslt_1;

        /* Reinitializing the ptrs */
        pu1_inp = pu1_inp_buf;
        pi2_tmp = pi2_tmp_filt_buf;
    } /* End of loop over x */
} /* svcd_vert_interpol_chroma_dyadic_1 */

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_vert_interpol_chroma_dyadic_2                       */
/*                                                                           */
/*  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           1                                    */
/*                          0           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 svcd_vert_interpol_chroma_dyadic_2(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 = 8 - i4_phase_0;
    i4_coeff_1 = i4_phase_0;
    i4_coeff_2 = 8 - i4_phase_1;
    i4_coeff_3 = i4_phase_1;

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

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

        for(i4_y = 0; i4_y < 8; 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_0;
            i4_rslt_1 += i4_samp_1 * i4_coeff_1;

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

            /* 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;

        } /* End of loop over y */

        /* Reinitializing the ptrs */
        pu1_inp = pu1_inp_buf + i4_src_stride;
        pi2_tmp = pi2_tmp_filt_buf;
    } /* End of loop over x */
} /* svcd_vert_interpol_chroma_dyadic_2 */

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_vert_interpol_chroma_dyadic_3                       */
/*                                                                           */
/*  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                                  */
/*                          2           0                                    */
/*  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)  */
/*         13 12 2010   Nithya          creation                             */
/*                                                                           */
/*****************************************************************************/
void svcd_vert_interpol_chroma_dyadic_3(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 = 8 - i4_phase_0;
    i4_coeff_1 = i4_phase_0;
    i4_coeff_2 = 8 - i4_phase_1;
    i4_coeff_3 = i4_phase_1;

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

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

        for(i4_y = 0; i4_y < 8; 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_0;
            i4_rslt_1 += i4_samp_1 * i4_coeff_1;

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

            /* 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;

        } /* End of loop over y */

        /* Reinitializing the ptrs */
        pu1_inp = pu1_inp_buf;
        pi2_tmp = pi2_tmp_filt_buf;
    } /* End of loop over x */
} /* svcd_vert_interpol_chroma_dyadic_3 */

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_horz_interpol_chroma_dyadic_1                       */
/*                                                                           */
/*  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 svcd_horz_interpol_chroma_dyadic_1(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_filt_stride, i4_dst_stride;
    UWORD8 *pu1_out;
    WORD16 *pi2_tmp;

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

    pu1_out = pu1_out_buf;
    pi2_tmp = pi2_tmp_filt_buf;
    i4_filt_stride = 6;
    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 += 32;
        i4_rslt_1 >>= 6;

        /* Store the output */
        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 += 32;
            i4_rslt_1 >>= 6;
            i4_rslt_2 += 32;
            i4_rslt_2 >>= 6;

            /* Storing the results */
            pu1_out[2 * i4_x] = i4_rslt_1;
            pu1_out[2 * (i4_x + 1)] = i4_rslt_2;

        } /* End of loop over y */

        /* 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 += 32;
        i4_rslt_1 >>= 6;

        /* Store the output */
        pu1_out[2 * 7] = i4_rslt_1;

        /* Incrementing the output ptr */
        pu1_out += i4_dst_stride;
    } /* End of loop over x */
} /* svcd_horz_interpol_chroma_dyadic_1 */

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_horz_interpol_chroma_dyadic_2                       */
/*                                                                           */
/*  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           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 svcd_horz_interpol_chroma_dyadic_2(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_filt_stride, i4_dst_stride;
    UWORD8 *pu1_out;
    WORD16 *pi2_tmp;

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

    pu1_out = pu1_out_buf;
    pi2_tmp = pi2_tmp_filt_buf + 1;
    i4_filt_stride = 6;
    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_1 = *pi2_tmp++;

        for(i4_x = 0; i4_x < 8; 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_0;
            i4_rslt_1 += i4_samp_1 * i4_coeff_1;

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

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

            /* Storing the results */
            pu1_out[2 * i4_x] = i4_rslt_1;
            pu1_out[2 * (i4_x + 1)] = i4_rslt_2;

        } /* End of loop over x */

        /* Incrementing the ptrs */
        pi2_tmp += 1;
        pu1_out += i4_dst_stride;
    } /* End of loop over y */
} /* svcd_horz_interpol_chroma_dyadic_2 */

/*****************************************************************************/
/*                                                                           */
/*  Function Name :  svcd_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 svcd_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, void *pv_dec)
{
    /* --------------------------------------------------------------------- */
    /* I/O buffer params                                                     */
    /* --------------------------------------------------------------------- */
    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;
    dec_struct_t *ps_dec = (dec_struct_t *) pv_dec;
    dec_slice_params_t *ps_slice = ps_dec->ps_cur_slice;
    dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;

    /* --------------------------------------------------------------------- */
    /* Intra resampling ctxt pointers                                        */
    /* --------------------------------------------------------------------- */
    intra_sampling_ctxt_t *ps_ctxt;
    intra_samp_lyr_ctxt *ps_lyr_ctxt;
    res_prms_t *ps_res_prms;

    /* --------------------------------------------------------------------- */
    /* reference and current layer MB coordinates                            */
    /* --------------------------------------------------------------------- */
    WORD32 i4_scaled_mb_x, i4_scaled_mb_y;
    WORD32 i4_top, i4_left;

    ps_svc_slice_params = &ps_slice->s_svc_slice_params;
    /* --------------------------------------------------------------------- */
    /* Pointer derivation                                                    */
    /* --------------------------------------------------------------------- */
    ps_ctxt = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];
    ps_res_prms = ps_ctxt->ps_res_prms;

    /* --------------------------------------------------------------------- */
    /* MB coordinate derivation                                              */
    /* --------------------------------------------------------------------- */
    i4_scaled_mb_x = u2_mb_x - (ps_svc_slice_params->i4_scaled_ref_layer_left_offset >> 4);
    // (ps_res_prms->s_ref_lyr_scaled_offset.i2_left >> 4); SVC_DEC_EXT_REVIEW
    i4_scaled_mb_y = u2_mb_y - (ps_svc_slice_params->i4_scaled_ref_layer_top_offset >> 4);
    //(ps_res_prms->s_ref_lyr_scaled_offset.i2_top >> 4); SVC_DEC_EXT_REVIEW

    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);

    /* --------------------------------------------------------------------- */
    /* Reference Array Consrtuction - luma and chroma                        */
    /* --------------------------------------------------------------------- */

    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 ----------------------- */
    svcd_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;

    svcd_interpolate_base_luma_dyadic(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;  // << 1; SVC_DEC_REVIEW_INTRA_RESAMPLE

    /* 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_chroma_interpol(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_chroma_interpol(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;
    // (i4_out_chroma_stride >> 1); SVC_DEC_REVIEW_INTRA_RESAMPLE
    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_chroma_interpol(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_chroma_interpol(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);
    return;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_residual_chroma_dyadic_alt                          */
/*                                                                           */
/*  Description   : this fucntion does the upsampling of chroma residuals for*/
/*                  Dyadic cases and specific chroma phase cases             */
/*                                                                           */
/*  Inputs        : pv_residual_samp_ctxt : Residual upsampling context      */
/*                  pu1_inp_data : input 8 bit data pointer                  */
/*                  i4_inp_data_stride : input buffer stride                 */
/*                  pi2_out_res : output 16 bit buffer pointer               */
/*                  i4_out_res_stride : Output buffer stride                 */
/*                  pu1_inp_bitmap : input packed sign bit data pointer      */
/*                  i4_inp_bitmap_stride : sign bit buffer stride            */
/*                  i4_start_bit_pos : bit position in the byte of packed    */
/*                                      sign values                          */
/*  Globals       : none                                                     */
/*  Processing    : it does the upsampling with intial phase values          */
/*                                                                           */
/*  Outputs       : Upsampled residuals for chroma                           */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         25 09 2010   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
void svcd_residual_chroma_dyadic_alt(void *pv_residual_samp_ctxt, UWORD16 u2_mb_x, UWORD16 u2_mb_y,
                                     mem_element_t *ps_ref_mb_mode, UWORD8 *pu1_inp_data,
                                     WORD32 i4_inp_data_stride, WORD16 *pi2_out_res,
                                     WORD32 i4_out_res_stride, UWORD8 *pu1_inp_bitmap,
                                     WORD32 i4_inp_bitmap_stride, WORD32 i4_cr_flag)
{
    residual_sampling_ctxt_t *ps_ctxt;
    res_lyr_ctxt *ps_lyr_ctxt;
    ps_ctxt = (residual_sampling_ctxt_t *) pv_residual_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];
    /* ----------------- Processing ------------------------------- */
    {
        ref_pixel_map_t *ps_pos_phase;
        residual_samp_map_ctxt_t *ps_chroma_map;
        ref_mb_map_t *ps_x_off_len_chroma;
        ref_mb_map_t *ps_y_off_len_chroma;

        WORD32 i4_i;
        UWORD8 *pu1_ref_data_byte, *pu1_ref_sign_byte;
        WORD32 *pi4_ref_array;
        WORD32 i4_phase1, i4_phase2;
        WORD32 i4_start_bit_pos = 0;
        WORD32 i4_offset_x, i4_offset_y;
        WORD32 i4_chrm_horz_int_mode, i4_chrm_vert_int_mode;
        WORD32 i4_horz_intp_ctr = SUB_BLOCK_HEIGHT;

        ps_chroma_map = &ps_lyr_ctxt->s_chroma_map_ctxt;
        ps_x_off_len_chroma = ps_chroma_map->ps_x_offset_length;
        ps_y_off_len_chroma = ps_chroma_map->ps_y_offset_length;

        /* get the actual offset for the buffers */
        i4_offset_x = ps_x_off_len_chroma[u2_mb_x].i2_offset;
        i4_offset_y = ps_y_off_len_chroma[u2_mb_y].i2_offset;

        {
            UWORD8 u1_mask;
            WORD32 i4_mb_x, i4_mb_y;
            WORD32 i4_chrm_nnz;
            WORD32 i4_num_element_stride;
            inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms, *ps_inter_lyr_mb_prms_curr;

            u1_mask = (SVCD_TRUE == i4_cr_flag) ? 0xF0 : 0x0F;

            /* Top Left */
            i4_mb_x = i4_offset_x >> 3;
            i4_mb_y = i4_offset_y >> 3;

            /* get the location of the byte which has the current mb mode */
            ps_inter_lyr_mb_prms = ps_ref_mb_mode->pv_buffer;
            i4_num_element_stride = ps_ref_mb_mode->i4_num_element_stride;

            ps_inter_lyr_mb_prms_curr = ps_inter_lyr_mb_prms + i4_mb_x;
            ps_inter_lyr_mb_prms_curr += i4_mb_y * i4_num_element_stride;

            i4_chrm_nnz = ps_inter_lyr_mb_prms_curr->u1_chroma_nnz & u1_mask;

            /* Top Right */
            i4_mb_x = (i4_offset_x + 4) >> 3;

            ps_inter_lyr_mb_prms_curr = ps_inter_lyr_mb_prms + i4_mb_x;
            ps_inter_lyr_mb_prms_curr += i4_mb_y * i4_num_element_stride;

            i4_chrm_nnz |= ps_inter_lyr_mb_prms_curr->u1_chroma_nnz & u1_mask;

            /* Bottom Left */
            i4_mb_x = i4_offset_x >> 3;
            i4_mb_y = (i4_offset_y + 4) >> 3;

            ps_inter_lyr_mb_prms_curr = ps_inter_lyr_mb_prms + i4_mb_x;
            ps_inter_lyr_mb_prms_curr += i4_mb_y * i4_num_element_stride;

            i4_chrm_nnz |= ps_inter_lyr_mb_prms_curr->u1_chroma_nnz & u1_mask;

            /* Bottom Right */
            i4_mb_x = (i4_offset_x + 4) >> 3;

            ps_inter_lyr_mb_prms_curr = ps_inter_lyr_mb_prms + i4_mb_x;
            ps_inter_lyr_mb_prms_curr += i4_mb_y * i4_num_element_stride;

            i4_chrm_nnz |= ps_inter_lyr_mb_prms_curr->u1_chroma_nnz & u1_mask;

            if(0 == i4_chrm_nnz)
            {
                return;
            }
        }

        i4_chrm_horz_int_mode = ps_lyr_ctxt->i4_chrm_horz_int_mode;
        i4_chrm_vert_int_mode = ps_lyr_ctxt->i4_chrm_vert_int_mode;

        if(0 == i4_chrm_horz_int_mode)
        {
            if(i4_offset_x >= 0)
            {
                pu1_inp_data++;
                if(0 == ((i4_offset_x + 1) & 7))
                {
                    pu1_inp_bitmap++;
                }
            }
        }

        if(0 == i4_chrm_vert_int_mode)
        {
            if(i4_offset_y >= 0)
            {
                pu1_inp_data += i4_inp_data_stride;
                pu1_inp_bitmap += i4_inp_bitmap_stride;
            }
        }
        else
        {
            /* extra additional row of interpolation required for this case */
            i4_horz_intp_ctr++;
        }

        /* set the appropriate bit pos */
        if(1 == (u2_mb_x & 1))
        {
            i4_start_bit_pos = 4;
        }

        /* ----------- Horizontal Interpolation ---------------- */
        pu1_ref_data_byte = pu1_inp_data;
        pu1_ref_sign_byte = pu1_inp_bitmap;
        ps_pos_phase = ps_lyr_ctxt->s_chroma_map_ctxt.ps_x_pos_phase;

        pi4_ref_array = (WORD32 *) ps_ctxt->pi2_refarray_buffer;
        i4_phase1 = ps_pos_phase[0].i2_phase;
        i4_phase2 = (i4_phase1 + 8) & 0x0F;

        /* interchange the phase values for corner case */
        if(1 == i4_chrm_horz_int_mode)
        {
            WORD32 i4_temp;
            i4_temp = i4_phase1;
            i4_phase1 = i4_phase2;
            i4_phase2 = i4_temp;
        }

        for(i4_i = 0; i4_i < i4_horz_intp_ctr; i4_i++)
        {
            WORD16 i2_coeff1, i2_coeff2;
            UWORD8 u1_sign;
            UWORD8 u1_sign_byte = *pu1_ref_sign_byte;

            i2_coeff1 = (WORD16) (pu1_ref_data_byte[0]);
            u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_start_bit_pos);

            /* if signed number */
            if(u1_sign)
            {
                i2_coeff1 |= 0xFF00;
            }

            if(0 == i4_chrm_horz_int_mode)
            {
                /* populate the first inter sample */
                *pi4_ref_array++ = i2_coeff1 << 4;
            }

            {
                /* unroll count 1 */
                i2_coeff2 = (WORD16) (pu1_ref_data_byte[1]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, (i4_start_bit_pos + 1));

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff2 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((16 - i4_phase2) * i2_coeff1 + i4_phase2 * i2_coeff2);

                *pi4_ref_array++ = ((16 - i4_phase1) * i2_coeff1 + i4_phase1 * i2_coeff2);

                /* unroll count 2 */
                i2_coeff1 = (WORD16) (pu1_ref_data_byte[2]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, (i4_start_bit_pos + 2));

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff1 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((16 - i4_phase2) * i2_coeff2 + i4_phase2 * i2_coeff1);

                *pi4_ref_array++ = ((16 - i4_phase1) * i2_coeff2 + i4_phase1 * i2_coeff1);

                /* unroll count 3 */
                i2_coeff2 = (WORD16) (pu1_ref_data_byte[3]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, (i4_start_bit_pos + 3));

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff2 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((16 - i4_phase2) * i2_coeff1 + i4_phase2 * i2_coeff2);

                *pi4_ref_array++ = ((16 - i4_phase1) * i2_coeff1 + i4_phase1 * i2_coeff2);
            }

            /* populate the last inter sample */
            *pi4_ref_array++ = i2_coeff2 << 4;

            if(1 == i4_chrm_horz_int_mode)
            {
                WORD32 i4_bit_pos = i4_start_bit_pos + 4;

                if(8 == i4_bit_pos)
                {
                    u1_sign_byte = *(pu1_ref_sign_byte + 1);
                    i4_bit_pos = 0;
                }

                i2_coeff1 = (WORD16) (pu1_ref_data_byte[4]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff1 |= 0xFF00;
                }

                /* populate the last inter sample */
                *pi4_ref_array++ = i2_coeff1 << 4;
            }

            /* vertical loop updates */
            pu1_ref_data_byte = pu1_inp_data + ((i4_i + 1) * i4_inp_data_stride);
            pu1_ref_sign_byte += i4_inp_bitmap_stride;
        }

        /* ----------- Vertical Interpolation ---------------- */
        pi4_ref_array = (WORD32 *) ps_ctxt->pi2_refarray_buffer;
        ps_pos_phase = ps_lyr_ctxt->s_chroma_map_ctxt.ps_y_pos_phase;
        i4_phase1 = ps_pos_phase[0].i2_phase;
        i4_phase2 = (i4_phase1 + 8) & 0x0F;

        /* interchange the phase values for corner case */
        if(0 != i4_chrm_vert_int_mode)
        {
            WORD32 i4_temp;
            i4_temp = i4_phase1;
            i4_phase1 = i4_phase2;
            i4_phase2 = i4_temp;
        }

        for(i4_i = 0; i4_i < BLOCK_WIDTH; i4_i++)
        {
            WORD16 *pi2_out;
            WORD32 *pi4_ref_array_temp;
            WORD32 i4_horz_samp_1, i4_horz_samp_2;
            pi2_out = pi2_out_res;
            pi4_ref_array_temp = pi4_ref_array;

            /* populate the first inter sample */
            i4_horz_samp_1 = *pi4_ref_array_temp;
            pi4_ref_array_temp += BLOCK_WIDTH;

            if(1 != i4_chrm_vert_int_mode)
            {
                *pi2_out = (i4_horz_samp_1 + 8) >> 4;
                pi2_out += i4_out_res_stride;
            }

            if(2 == i4_chrm_vert_int_mode)
            {
                i4_horz_samp_1 = *pi4_ref_array_temp;
                pi4_ref_array_temp += BLOCK_WIDTH;
                *pi2_out = (i4_horz_samp_1 + 8) >> 4;
                pi2_out += i4_out_res_stride;
            }

            {
                /* unroll count 1 */
                i4_horz_samp_2 = *pi4_ref_array_temp;
                pi4_ref_array_temp += BLOCK_WIDTH;

                /* populate 2 samples based on current coeffs */
                *pi2_out =
                    ((16 - i4_phase2) * i4_horz_samp_1 + i4_phase2 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 2 */
                *pi2_out =
                    ((16 - i4_phase1) * i4_horz_samp_1 + i4_phase1 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 3 */
                i4_horz_samp_1 = *pi4_ref_array_temp;
                pi4_ref_array_temp += BLOCK_WIDTH;

                /* populate 2 samples based on current coeffs */
                *pi2_out =
                    ((16 - i4_phase2) * i4_horz_samp_2 + i4_phase2 * i4_horz_samp_1 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 4 */
                *pi2_out =
                    ((16 - i4_phase1) * i4_horz_samp_2 + i4_phase1 * i4_horz_samp_1 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 5 */
                i4_horz_samp_2 = *pi4_ref_array_temp;

                /* populate 2 samples based on current coeffs */
                *pi2_out =
                    ((16 - i4_phase2) * i4_horz_samp_1 + i4_phase2 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 6 */
                *pi2_out =
                    ((16 - i4_phase1) * i4_horz_samp_1 + i4_phase1 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;
            }

            if(2 != i4_chrm_vert_int_mode)
            {
                /* populate the last inter sample */
                *pi2_out = (i4_horz_samp_2 + 8) >> 4;

                if(1 == i4_chrm_vert_int_mode)
                {
                    pi2_out += i4_out_res_stride;
                    pi4_ref_array_temp += BLOCK_WIDTH;
                    i4_horz_samp_1 = *pi4_ref_array_temp;

                    /* populate the last inter sample */
                    *pi2_out = (i4_horz_samp_1 + 8) >> 4;
                }
            }

            /* horizontal loop updates */
            pi4_ref_array++;
            pi2_out_res++;
        }
    }
    return;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_residual_chroma_dyadic                              */
/*                                                                           */
/*  Description   : this fucntion does the upsampling of chroma residuals for*/
/*                  Dyadic cases                                             */
/*                                                                           */
/*  Inputs        : pv_residual_samp_ctxt : Residual upsampling context      */
/*                  pu1_inp_data : input 8 bit data pointer                  */
/*                  i4_inp_data_stride : input buffer stride                 */
/*                  pi2_out_res : output 16 bit buffer pointer               */
/*                  i4_out_res_stride : Output buffer stride                 */
/*                  pu1_inp_bitmap : input packed sign bit data pointer      */
/*                  i4_inp_bitmap_stride : sign bit buffer stride            */
/*                  i4_start_bit_pos : bit position in the byte of packed    */
/*                                      sign values                          */
/*  Globals       : none                                                     */
/*  Processing    : it does the upsampling with intial phase values          */
/*                                                                           */
/*  Outputs       : Upsampled residuals for chroma                           */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         25 09 2010   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
void svcd_residual_chroma_dyadic(void *pv_residual_samp_ctxt, UWORD8 *pu1_inp_data,
                                 WORD32 i4_inp_data_stride, WORD16 *pi2_out_res,
                                 WORD32 i4_out_res_stride, UWORD8 *pu1_inp_bitmap,
                                 WORD32 i4_inp_bitmap_stride, WORD32 i4_start_bit_pos)
{
    residual_sampling_ctxt_t *ps_ctxt;
    res_lyr_ctxt *ps_lyr_ctxt;
    ps_ctxt = (residual_sampling_ctxt_t *) pv_residual_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];
    /* ----------------- Processing ------------------------------- */
    {
        WORD32 i4_i;
        UWORD8 *pu1_ref_data_byte, *pu1_ref_sign_byte;
        WORD32 *pi4_ref_array;
        ref_pixel_map_t *ps_pos_phase;
        WORD32 i4_phase1, i4_phase2;

        pu1_ref_data_byte = pu1_inp_data;
        pu1_ref_sign_byte = pu1_inp_bitmap;
        ps_pos_phase = ps_lyr_ctxt->s_chroma_map_ctxt.ps_x_pos_phase;

        /* ----------- Horizontal Interpolation ---------------- */
        pi4_ref_array = (WORD32 *) ps_ctxt->pi2_refarray_buffer;
        i4_phase1 = ps_pos_phase[0].i2_phase;
        i4_phase2 = (i4_phase1 + 8) & 0x0F;

        for(i4_i = 0; i4_i < SUB_BLOCK_HEIGHT; i4_i++)
        {
            WORD16 i2_coeff1, i2_coeff2;
            UWORD8 u1_sign;
            UWORD8 u1_sign_byte = *pu1_ref_sign_byte;

            i2_coeff1 = (WORD16) (pu1_ref_data_byte[0]);
            u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_start_bit_pos);

            /* if signed number */
            if(u1_sign)
            {
                i2_coeff1 |= 0xFF00;
            }

            /* populate the first inter sample */
            *pi4_ref_array++ = i2_coeff1 << 4;

            {
                /* unroll count 1 */
                i2_coeff2 = (WORD16) (pu1_ref_data_byte[1]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, (i4_start_bit_pos + 1));

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff2 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((16 - i4_phase2) * i2_coeff1 + i4_phase2 * i2_coeff2);

                /* unroll count 2 */
                *pi4_ref_array++ = ((16 - i4_phase1) * i2_coeff1 + i4_phase1 * i2_coeff2);

                /* unroll count 3 */
                i2_coeff1 = (WORD16) (pu1_ref_data_byte[2]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, (i4_start_bit_pos + 2));

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff1 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((16 - i4_phase2) * i2_coeff2 + i4_phase2 * i2_coeff1);

                /* unroll count 4 */
                *pi4_ref_array++ = ((16 - i4_phase1) * i2_coeff2 + i4_phase1 * i2_coeff1);

                /* unroll count 5 */
                i2_coeff2 = (WORD16) (pu1_ref_data_byte[3]);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, (i4_start_bit_pos + 3));

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff2 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((16 - i4_phase2) * i2_coeff1 + i4_phase2 * i2_coeff2);

                /* unroll count 6 */
                *pi4_ref_array++ = ((16 - i4_phase1) * i2_coeff1 + i4_phase1 * i2_coeff2);
            }

            /* populate the last inter sample */
            *pi4_ref_array++ = i2_coeff2 << 4;

            /* vertical loop uopdates */
            pu1_ref_data_byte = pu1_inp_data + ((i4_i + 1) * i4_inp_data_stride);
            pu1_ref_sign_byte += i4_inp_bitmap_stride;
        }

        /* ----------- Vertical Interpolation ---------------- */
        pi4_ref_array = (WORD32 *) ps_ctxt->pi2_refarray_buffer;
        ps_pos_phase = ps_lyr_ctxt->s_chroma_map_ctxt.ps_y_pos_phase;
        i4_phase1 = ps_pos_phase[0].i2_phase;
        i4_phase2 = (i4_phase1 + 8) & 0x0F;

        for(i4_i = 0; i4_i < BLOCK_WIDTH; i4_i++)
        {
            WORD16 *pi2_out;
            WORD32 *pi4_ref_array_temp;
            WORD32 i4_horz_samp_1, i4_horz_samp_2;
            pi2_out = pi2_out_res;
            pi4_ref_array_temp = pi4_ref_array;

            /* populate the first inter sample */
            i4_horz_samp_1 = *pi4_ref_array_temp;
            pi4_ref_array_temp += BLOCK_WIDTH;
            *pi2_out = (i4_horz_samp_1 + 8) >> 4;
            pi2_out += i4_out_res_stride;

            {
                /* unroll count 1 */
                i4_horz_samp_2 = *pi4_ref_array_temp;
                pi4_ref_array_temp += BLOCK_WIDTH;

                /* populate 2 samples based on current coeffs */
                *pi2_out =
                    ((16 - i4_phase2) * i4_horz_samp_1 + i4_phase2 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 2 */
                *pi2_out =
                    ((16 - i4_phase1) * i4_horz_samp_1 + i4_phase1 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 3 */
                i4_horz_samp_1 = *pi4_ref_array_temp;
                pi4_ref_array_temp += BLOCK_WIDTH;

                /* populate 2 samples based on current coeffs */
                *pi2_out =
                    ((16 - i4_phase2) * i4_horz_samp_2 + i4_phase2 * i4_horz_samp_1 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 4 */
                *pi2_out =
                    ((16 - i4_phase1) * i4_horz_samp_2 + i4_phase1 * i4_horz_samp_1 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 5 */
                i4_horz_samp_2 = *pi4_ref_array_temp;

                /* populate 2 samples based on current coeffs */
                *pi2_out =
                    ((16 - i4_phase2) * i4_horz_samp_1 + i4_phase2 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;

                /* unroll count 6 */
                *pi2_out =
                    ((16 - i4_phase1) * i4_horz_samp_1 + i4_phase1 * i4_horz_samp_2 + 128) >> 8;
                pi2_out += i4_out_res_stride;
            }

            /* populate the last inter sample */
            *pi2_out = (i4_horz_samp_2 + 8) >> 4;

            /* horizontal loop updates */
            pi4_ref_array++;
            pi2_out_res++;
        }
    }
    return;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_residual_luma_dyadic                                */
/*                                                                           */
/*  Description   : this fucntion does the upsampling of luma residuals for  */
/*                  Dyadic cases                                             */
/*                                                                           */
/*  Inputs        : pv_residual_samp_ctxt : Residual upsampling context      */
/*                  pu1_inp_data : input 8 bit data pointer                  */
/*                  i4_inp_data_stride : input buffer stride                 */
/*                  pi2_out_res : output 16 bit buffer pointer               */
/*                  i4_out_res_stride : Output buffer stride                 */
/*                  pu1_inp_bitmap : input packed sign bit data pointer      */
/*                  i4_inp_bitmap_stride : sign bit buffer stride            */
/*                  ps_ref_mb_mode : reference mb mode pointer of base layer */
/*                  ps_coord : mb co-ordinate pointer                        */
/*  Globals       : none                                                     */
/*  Processing    : it does the upsampling with fixed phase values and       */
/*                  reference layer transform size                           */
/*  Outputs       : Upsampled residuals for luma                             */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         25 09 2010   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
void svcd_residual_luma_dyadic(void *pv_residual_samp_ctxt, UWORD8 *pu1_inp_data,
                               WORD32 i4_inp_data_stride, WORD16 *pi2_out_res,
                               WORD32 i4_out_res_stride, UWORD8 *pu1_inp_bitmap,
                               WORD32 i4_inp_bitmap_stride, mem_element_t *ps_ref_mb_mode,
                               UWORD16 u2_mb_x, UWORD16 u2_mb_y, WORD32 i4_ref_nnz,
                               WORD32 i4_ref_tx_size)

{
    WORD16 *pi2_refarray_buffer;
    WORD32 i4_start_bit_pos = 0;
    WORD32 i4_blk_ctr;
    residual_sampling_ctxt_t *ps_ctxt;

    ps_ctxt = (residual_sampling_ctxt_t *) pv_residual_samp_ctxt;
    pi2_refarray_buffer = ps_ctxt->pi2_refarray_buffer;

    /* based on transform size the counter and interpolation width and */
    /* height are intialised as follows                                */

    if((i4_ref_tx_size) && (0 != i4_ref_nnz))
    {
        UWORD8 *pu1_ref_data_byte, *pu1_ref_sign_byte;
        WORD32 *pi4_ref_array;
        WORD32 i4_i, i4_j;

        pu1_ref_data_byte = pu1_inp_data;
        pu1_ref_sign_byte = pu1_inp_bitmap;

        /* ----------- Horizontal Interpolation ---------------- */
        pi4_ref_array = (WORD32 *) pi2_refarray_buffer;

        for(i4_i = 0; i4_i < BLOCK_HEIGHT; i4_i++)
        {
            WORD16 i2_coeff1, i2_coeff2;
            UWORD8 u1_sign;
            WORD32 i4_bit_pos = i4_start_bit_pos;
            UWORD8 u1_sign_byte = *pu1_ref_sign_byte;

            i2_coeff1 = (WORD16) (*pu1_ref_data_byte++);
            u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

            /* if signed number */
            if(u1_sign)
            {
                i2_coeff1 |= 0xFF00;
            }

            /* populate the first inter sample */
            *pi4_ref_array++ = i2_coeff1 << 2;

            for(i4_j = 0; i4_j < 14; i4_j += 2)
            {
                i4_bit_pos++;
                i2_coeff2 = (WORD16) (*pu1_ref_data_byte++);
                u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

                /* if signed number */
                if(u1_sign)
                {
                    i2_coeff2 |= 0xFF00;
                }

                /* populate 2 samples based on current coeffs */
                *pi4_ref_array++ = ((i2_coeff1 << 1) + (i2_coeff1) + (i2_coeff2));

                *pi4_ref_array++ = ((i2_coeff2 << 1) + (i2_coeff2) + (i2_coeff1));

                /* store the coeff 2 to coeff 1 */
                /* (used in next iteration)     */
                i2_coeff1 = i2_coeff2;
            }

            /* populate the last inter sample */
            *pi4_ref_array++ = i2_coeff1 << 2;

            /* vertical loop uopdates */
            pu1_ref_data_byte = pu1_inp_data + ((i4_i + 1) * i4_inp_data_stride);
            pu1_ref_sign_byte += i4_inp_bitmap_stride;
        }

        /* ----------- Vertical Interpolation ---------------- */
        pi4_ref_array = (WORD32 *) pi2_refarray_buffer;

        for(i4_i = 0; i4_i < MB_WIDTH; i4_i++)
        {
            WORD32 *pi4_ref_array_temp;
            WORD16 *pi2_out;
            WORD32 i4_horz_samp_1, i4_horz_samp_2;

            pi4_ref_array_temp = pi4_ref_array;
            pi2_out = pi2_out_res;
            i4_horz_samp_1 = *pi4_ref_array_temp;

            /* populate the first inter sample */
            *pi2_out = (i4_horz_samp_1 + 2) >> 2;
            pi2_out += i4_out_res_stride;

            for(i4_j = 0; i4_j < 14; i4_j += 2)
            {
                pi4_ref_array_temp += MB_WIDTH;
                i4_horz_samp_2 = *pi4_ref_array_temp;

                /* populate 2 samples based on current coeffs */
                *pi2_out = ((i4_horz_samp_1 << 1) + (i4_horz_samp_1) + (i4_horz_samp_2) + 8) >> 4;
                pi2_out += i4_out_res_stride;

                *pi2_out = ((i4_horz_samp_2 << 1) + (i4_horz_samp_2) + (i4_horz_samp_1) + 8) >> 4;
                pi2_out += i4_out_res_stride;

                /* store the coeff 2 to coeff 1 */
                /* (used in next iteration)     */
                i4_horz_samp_1 = i4_horz_samp_2;
            }

            /* populate the first inter sample */
            *pi2_out = (i4_horz_samp_1 + 2) >> 2;

            /* horizontal loop updates */
            pi4_ref_array++;
            pi2_out_res++;
        }
    }
    else
    {
        /* ----------------------------------------------------------------- */
        /* LOOP over number of blocks                                        */
        /* ----------------------------------------------------------------- */
        for(i4_blk_ctr = 0; i4_blk_ctr < 4; i4_blk_ctr++)
        {
            UWORD8 *pu1_ref_data_byte, *pu1_ref_sign_byte;
            WORD32 *pi4_ref_array;
            WORD32 i4_i;

            /* if reference layer is not coded then no processing */
            if(0 != (i4_ref_nnz & 0x1))
            {
                pu1_ref_data_byte = pu1_inp_data;
                pu1_ref_sign_byte = pu1_inp_bitmap;

                /* ----------- Horizontal Interpolation ---------------- */
                pi4_ref_array = (WORD32 *) pi2_refarray_buffer;

                for(i4_i = 0; i4_i < SUB_BLOCK_HEIGHT; i4_i++)
                {
                    WORD16 i2_coeff1, i2_coeff2;
                    UWORD8 u1_sign;
                    WORD32 i4_bit_pos = i4_start_bit_pos;
                    UWORD8 u1_sign_byte = *pu1_ref_sign_byte;
                    ;

                    i2_coeff1 = (WORD16) (*pu1_ref_data_byte++);
                    u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

                    /* if signed number */
                    if(u1_sign)
                    {
                        i2_coeff1 |= 0xFF00;
                    }

                    /* populate the first inter sample */
                    *pi4_ref_array++ = i2_coeff1 << 2;

                    {
                        /* unroll count 1 */
                        i4_bit_pos++;
                        i2_coeff2 = (WORD16) (*pu1_ref_data_byte++);
                        u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

                        /* if signed number */
                        if(u1_sign)
                        {
                            i2_coeff2 |= 0xFF00;
                        }

                        /* populate 2 samples based on current coeffs */
                        *pi4_ref_array++ = ((i2_coeff1 << 1) + (i2_coeff1) + (i2_coeff2));

                        *pi4_ref_array++ = ((i2_coeff2 << 1) + (i2_coeff2) + (i2_coeff1));

                        /* unroll count 2 */
                        i4_bit_pos++;
                        i2_coeff1 = (WORD16) (*pu1_ref_data_byte++);
                        u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

                        /* if signed number */
                        if(u1_sign)
                        {
                            i2_coeff1 |= 0xFF00;
                        }

                        /* populate 2 samples based on current coeffs */
                        *pi4_ref_array++ = ((i2_coeff2 << 1) + (i2_coeff2) + (i2_coeff1));

                        *pi4_ref_array++ = ((i2_coeff1 << 1) + (i2_coeff1) + (i2_coeff2));

                        /* unroll count 3 */
                        i4_bit_pos++;
                        i2_coeff2 = (WORD16) (*pu1_ref_data_byte++);
                        u1_sign = (UWORD8) GET_BIT(u1_sign_byte, i4_bit_pos);

                        /* if signed number */
                        if(u1_sign)
                        {
                            i2_coeff2 |= 0xFF00;
                        }

                        /* populate 2 samples based on current coeffs */
                        *pi4_ref_array++ = ((i2_coeff1 << 1) + (i2_coeff1) + (i2_coeff2));

                        *pi4_ref_array++ = ((i2_coeff2 << 1) + (i2_coeff2) + (i2_coeff1));
                    }

                    /* populate the last inter sample */
                    *pi4_ref_array++ = i2_coeff2 << 2;

                    /* vertical loop uopdates */
                    pu1_ref_data_byte = pu1_inp_data + ((i4_i + 1) * i4_inp_data_stride);
                    pu1_ref_sign_byte += i4_inp_bitmap_stride;
                }

                /* ----------- Vertical Interpolation ---------------- */
                pi4_ref_array = (WORD32 *) pi2_refarray_buffer;

                for(i4_i = 0; i4_i < BLOCK_WIDTH; i4_i++)
                {
                    WORD32 *pi4_ref_array_temp;
                    WORD16 *pi2_out;
                    WORD32 i4_horz_samp_1, i4_horz_samp_2;

                    pi4_ref_array_temp = pi4_ref_array;
                    pi2_out = pi2_out_res;
                    i4_horz_samp_1 = *pi4_ref_array_temp;

                    /* populate the first inter sample */
                    *pi2_out = (i4_horz_samp_1 + 2) >> 2;
                    pi2_out += i4_out_res_stride;

                    {
                        /* unroll loop count 1 */
                        pi4_ref_array_temp += BLOCK_WIDTH;
                        i4_horz_samp_2 = *pi4_ref_array_temp;

                        /* populate 2 samples based on current coeffs */
                        *pi2_out =
                            ((i4_horz_samp_1 << 1) + (i4_horz_samp_1) + (i4_horz_samp_2) + 8) >> 4;
                        pi2_out += i4_out_res_stride;

                        *pi2_out =
                            ((i4_horz_samp_2 << 1) + (i4_horz_samp_2) + (i4_horz_samp_1) + 8) >> 4;
                        pi2_out += i4_out_res_stride;

                        /* unroll loop count 2 */
                        pi4_ref_array_temp += BLOCK_WIDTH;
                        i4_horz_samp_1 = *pi4_ref_array_temp;

                        /* populate 2 samples based on current coeffs */
                        *pi2_out =
                            ((i4_horz_samp_2 << 1) + (i4_horz_samp_2) + (i4_horz_samp_1) + 8) >> 4;
                        pi2_out += i4_out_res_stride;

                        *pi2_out =
                            ((i4_horz_samp_1 << 1) + (i4_horz_samp_1) + (i4_horz_samp_2) + 8) >> 4;
                        pi2_out += i4_out_res_stride;

                        /* unroll loop count 3 */
                        pi4_ref_array_temp += BLOCK_WIDTH;
                        i4_horz_samp_2 = *pi4_ref_array_temp;

                        /* populate 2 samples based on current coeffs */
                        *pi2_out =
                            ((i4_horz_samp_1 << 1) + (i4_horz_samp_1) + (i4_horz_samp_2) + 8) >> 4;
                        pi2_out += i4_out_res_stride;

                        *pi2_out =
                            ((i4_horz_samp_2 << 1) + (i4_horz_samp_2) + (i4_horz_samp_1) + 8) >> 4;
                        pi2_out += i4_out_res_stride;
                    }

                    /* populate the last inter sample */
                    *pi2_out = (i4_horz_samp_2 + 2) >> 2;

                    /* horizontal loop updates */
                    pi4_ref_array++;
                    pi2_out_res++;
                }
            }
            else
            {
                pi2_out_res += BLOCK_WIDTH;
            }

            /* Block level loop updates */
            if(1 == i4_blk_ctr)
            {
                i4_start_bit_pos = 0;
                pu1_inp_data -= SUB_BLOCK_WIDTH;
                pu1_inp_data += (i4_inp_data_stride * SUB_BLOCK_HEIGHT);
                pi2_out_res -= MB_WIDTH;
                pi2_out_res += (i4_out_res_stride * BLOCK_HEIGHT);
                pu1_inp_bitmap += (i4_inp_bitmap_stride * SUB_BLOCK_HEIGHT);
                i4_ref_nnz >>= 2;
            }
            else
            {
                pu1_inp_data += SUB_BLOCK_WIDTH;
                i4_start_bit_pos = SUB_BLOCK_WIDTH;
            }

            i4_ref_nnz >>= 1;
        } /* end of loop over all the blocks */
    }
    return;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_residual_samp_mb_dyadic                             */
/*                                                                           */
/*  Description   : MB level function whcih perform the residual resampling  */
/*                  of data of an MB (luma and chroma insclusive)            */
/*                  for Dyadic cases                                         */
/*  Inputs        : pv_residual_samp_ctxt : residual sampling context        */
/*                  ps_ref_luma : reference layer luma data buffer desc      */
/*                  ps_ref_chroma : reference layer chroma data buffer desc  */
/*                  ps_ref_luma_bitmap : ref layer luma bit map buffer desc  */
/*                  ps_ref_chroma_bitmap : ref layer chroma bit map buff des */
/*                  ps_ref_mb_mode : ref layer mb mode map buff desc         */
/*                  ps_out_luma : current layer out luma buffer desc         */
/*                  ps_out_chroma : current layer out chroma buffer desc     */
/*                  x,y : current mb coorinate                       */
/*  Globals       : none                                                     */
/*  Processing    : it calls the reference layer construction followed by    */
/*                   interplaotion 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)  */
/*         26 06 2009   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
void svcd_residual_samp_mb_dyadic(void *pv_residual_samp_ctxt, mem_element_t *ps_ref_luma,
                                  mem_element_t *ps_ref_chroma, mem_element_t *ps_ref_luma_bitmap,
                                  mem_element_t *ps_ref_chroma_bitmap,
                                  mem_element_t *ps_ref_mb_mode, mem_element_t *ps_out_luma,
                                  mem_element_t *ps_out_chroma, UWORD16 u2_mb_x, UWORD16 u2_mb_y)
{
    residual_sampling_ctxt_t *ps_ctxt;
    res_lyr_ctxt *ps_lyr_ctxt;
    /* --------------------------------------------------------------------- */
    /* I/O buffer params                                                     */
    /* --------------------------------------------------------------------- */
    UWORD8 *pu1_inp;
    UWORD8 *pu1_inp_bitmap;
    WORD16 *pi2_out;
    WORD32 i4_inp_stride;
    WORD32 i4_inp_bitmap_stride;
    WORD32 i4_out_stride;
    WORD32 i4_bit_pos = 0;
    WORD32 i4_luma_nnz;
    WORD32 i4_chroma_nnz;
    WORD32 i4_tx_size;

    ps_ctxt = (residual_sampling_ctxt_t *) pv_residual_samp_ctxt;
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id];

    /* --------------------------------------------------------------------- */
    /* LUMA PROCESSING                                                       */
    /* --------------------------------------------------------------------- */
    pu1_inp = (UWORD8 *) ps_ref_luma->pv_buffer;
    pu1_inp_bitmap = (UWORD8 *) ps_ref_luma_bitmap->pv_buffer;
    pi2_out = (WORD16 *) ps_out_luma->pv_buffer;

    i4_inp_stride = ps_ref_luma->i4_num_element_stride;
    i4_inp_bitmap_stride = ps_ref_luma_bitmap->i4_num_element_stride;
    i4_out_stride = ps_out_luma->i4_num_element_stride;

    /* set the output buffer to 0 since not all block will be upsampled */
    svcd_2d_memset(pi2_out, (MB_WIDTH << 1), MB_HEIGHT, (i4_out_stride << 1), 0);

    {
        WORD32 i4_offset_x, i4_offset_y;
        residual_samp_map_ctxt_t *ps_luma_map;
        ref_mb_map_t *ps_x_off_len_luma;
        ref_mb_map_t *ps_y_off_len_luma;

        ps_luma_map = &ps_lyr_ctxt->s_luma_map_ctxt;
        ps_x_off_len_luma = ps_luma_map->ps_x_offset_length;
        ps_y_off_len_luma = ps_luma_map->ps_y_offset_length;

        /* get the actual offset for the buffers */
        i4_offset_x = ps_x_off_len_luma[u2_mb_x].i2_offset;
        i4_offset_y = ps_y_off_len_luma[u2_mb_y].i2_offset;

        {
            inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms;
            WORD32 i4_mb_x, i4_mb_y;
            UWORD16 u2_luma_mask = 0x0033;
            UWORD8 u1_chrm_mask = 0x11;
            WORD32 i4_luma_rt_sft_amt = 0;
            WORD32 i4_chrm_rt_sft_amt = 0;

            i4_mb_x = ((i4_offset_x + 1) >> MB_WIDTH_SHIFT);
            i4_mb_y = ((i4_offset_y + 1) >> MB_HEIGHT_SHIFT);

            /* get the location of the byte which has the current mb mode */
            ps_inter_lyr_mb_prms = (inter_lyr_mb_prms_t *) ps_ref_mb_mode->pv_buffer;
            ps_inter_lyr_mb_prms += i4_mb_x;
            ps_inter_lyr_mb_prms += i4_mb_y * ps_ref_mb_mode->i4_num_element_stride;

            /* get the approp block in base layer in horz direction */
            if(0 != ((i4_offset_x + 1) & 15))
            {
                u2_luma_mask <<= 2;
                i4_luma_rt_sft_amt += 2;

                u1_chrm_mask <<= 1;
                i4_chrm_rt_sft_amt += 1;
            }
            /* get the approp block in base layer in vert direction */
            if(0 != ((i4_offset_y + 1) & 15))
            {
                u2_luma_mask <<= 8;
                i4_luma_rt_sft_amt += 8;

                u1_chrm_mask <<= 2;
                i4_chrm_rt_sft_amt += 2;
            }

            /* extract the nnz and store it */
            i4_luma_nnz = (ps_inter_lyr_mb_prms->u2_luma_nnz & u2_luma_mask) >> i4_luma_rt_sft_amt;

            i4_chroma_nnz =
                (ps_inter_lyr_mb_prms->u1_chroma_nnz & u1_chrm_mask) >> i4_chrm_rt_sft_amt;

            i4_tx_size = GET_BIT(ps_inter_lyr_mb_prms->i1_mb_mode, 1);
        }

        /* since in dyadic case the window width and height will be 10x10   */
        /* and the window start offsets will be always 1 column left and    */
        /* 1 row above the block boundary. so the pointer and the required  */
        /* positions are appropriately modified                             */
        if(i4_offset_x >= 0)
        {
            pu1_inp++;
            pu1_inp_bitmap++;
        }

        if(i4_offset_y >= 0)
        {
            pu1_inp += i4_inp_stride;
            pu1_inp_bitmap += i4_inp_bitmap_stride;
        }

        svcd_residual_luma_dyadic(pv_residual_samp_ctxt, pu1_inp, i4_inp_stride, pi2_out,
                                  i4_out_stride, pu1_inp_bitmap, i4_inp_bitmap_stride,
                                  ps_ref_mb_mode, u2_mb_x, u2_mb_y, i4_luma_nnz, i4_tx_size);
    }

    /* --------------------------------------------------------------------- */
    /* CHROMA PROCESSING                                                     */
    /* --------------------------------------------------------------------- */
    /* CB */
    pu1_inp = (UWORD8 *) ps_ref_chroma->pv_buffer;
    pu1_inp_bitmap = (UWORD8 *) ps_ref_chroma_bitmap->pv_buffer;
    pi2_out = (WORD16 *) ps_out_chroma->pv_buffer;

    i4_inp_stride = ps_ref_chroma->i4_num_element_stride << 1;
    i4_inp_bitmap_stride = ps_ref_chroma_bitmap->i4_num_element_stride << 1;
    i4_out_stride = ps_out_chroma->i4_num_element_stride << 1;

    /* set the output buffer to 0 since not all block will be upsampled */
    svcd_2d_memset(pi2_out, (BLOCK_WIDTH << 1), MB_HEIGHT, (i4_out_stride), 0);

    /* choose the appropriate chroma processing routine */
    if(SVCD_FALSE == ps_lyr_ctxt->i4_chrm_alt_proc)
    {
        WORD32 i4_offset_x, i4_offset_y;
        residual_samp_map_ctxt_t *ps_chroma_map;
        ref_mb_map_t *ps_x_off_len_chroma;
        ref_mb_map_t *ps_y_off_len_chroma;

        ps_chroma_map = &ps_lyr_ctxt->s_chroma_map_ctxt;
        ps_x_off_len_chroma = ps_chroma_map->ps_x_offset_length;
        ps_y_off_len_chroma = ps_chroma_map->ps_y_offset_length;

        /* get the actual offset for the buffers */
        i4_offset_x = ps_x_off_len_chroma[u2_mb_x].i2_offset;
        i4_offset_y = ps_y_off_len_chroma[u2_mb_y].i2_offset;

        /* since in dyadic case the window width and height will be 6x6     */
        /* and the window start offsets will be always 1 column left and    */
        /* 1 row above the block boundary. so the pointer and the required  */
        /* positions are appropriately modified                             */
        if(i4_offset_x >= 0)
        {
            pu1_inp++;
            if(0 == ((i4_offset_x + 1) & 7))
            {
                pu1_inp_bitmap++;
            }
            else
            {
                i4_bit_pos = 4;
            }
        }

        if(i4_offset_y >= 0)
        {
            pu1_inp += i4_inp_stride;
            pu1_inp_bitmap += i4_inp_bitmap_stride;
        }

        if(0 != (i4_chroma_nnz & 0x01))
        {
            svcd_residual_chroma_dyadic(pv_residual_samp_ctxt, pu1_inp, i4_inp_stride, pi2_out,
                                        i4_out_stride, pu1_inp_bitmap, i4_inp_bitmap_stride,
                                        i4_bit_pos);
        }
    }
    else
    {
        svcd_residual_chroma_dyadic_alt(pv_residual_samp_ctxt, u2_mb_x, u2_mb_y, ps_ref_mb_mode,
                                        pu1_inp, i4_inp_stride, pi2_out, i4_out_stride,
                                        pu1_inp_bitmap, i4_inp_bitmap_stride, SVCD_FALSE);
    }

    /* CR */
    pu1_inp += (i4_inp_stride >> 1);
    pu1_inp_bitmap += (i4_inp_bitmap_stride >> 1);
    pi2_out += (i4_out_stride >> 1);

    if(SVCD_FALSE == ps_lyr_ctxt->i4_chrm_alt_proc)
    {
        if(0 != (i4_chroma_nnz & 0x10))
        {
            svcd_residual_chroma_dyadic(pv_residual_samp_ctxt, pu1_inp, i4_inp_stride, pi2_out,
                                        i4_out_stride, pu1_inp_bitmap, i4_inp_bitmap_stride,
                                        i4_bit_pos);
        }
    }
    else
    {
        svcd_residual_chroma_dyadic_alt(pv_residual_samp_ctxt, u2_mb_x, u2_mb_y, ps_ref_mb_mode,
                                        pu1_inp, i4_inp_stride, pi2_out, i4_out_stride,
                                        pu1_inp_bitmap, i4_inp_bitmap_stride, SVCD_TRUE);
    }
    return;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svc_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 svc_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;
            }

            /* Updations */
            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;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_intra_samp_populate_list                            */
/*                                                                           */
/*  Description   : This is a seq or frame level init function which fills   */
/*                  all offsets, projected locations arrays based on         */
/*                  the two resolutions  and cropping parameters             */
/*  Inputs        : refer ot doxygen comments below                          */
/*  Globals       : none                                                     */
/*  Processing    : it projects the locations and computes the values        */
/*                                                                           */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         26 06 2009   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
void svcd_intra_samp_populate_list(intra_samp_map_ctxt_t *ps_map_ctxt, res_prms_t *ps_curr_res_prms,
                                   res_prms_t *ps_ref_res_prms, WORD32 i4_chroma_flag,
                                   dec_struct_t *ps_dec)
{
    /* --------------------------------------------------------------------- */
    /* Local variables required for finding the mapping between the layers   */
    /* --------------------------------------------------------------------- */
    WORD32 i4_shift_x, i4_shift_y, i4_scale_x, i4_scale_y, i4_offset_x, i4_offset_y;
    WORD32 i4_add_x, i4_add_y, i4_delta_x, i4_delta_y, i4_refphase_x, i4_refphase_y;
    WORD32 i4_phase_x, i4_phase_y, i4_sub_wd, i4_sub_ht, i4_mb_wd, i4_mb_ht;
    WORD32 i4_horz_dim, i4_vert_dim, i4_tmp;

    /* --------------------------------------------------------------------- */
    /* Local Pointer Declaration for arrays in Mapping context               */
    /* --------------------------------------------------------------------- */
    ref_mb_map_t *ps_x_off_len, *ps_y_off_len;
    WORD32 i4_ref_wd, i4_ref_ht, i4_scaled_wd, i4_scaled_ht, i4_curr_lyr_width, i4_curr_lyr_height;

    /* --------------------------------------------------------------------- */
    /* Local Flag Declaration                                                */
    /* --------------------------------------------------------------------- */
    WORD32 i4_ref_layer_field_pic_flag, i4_field_pic_flag, i4_frame_mbs_only_flag;
    WORD32 i4_ref_layer_frame_Mbs_only_flag, i4_field_Mb_flag, i4_bot_field_flag;

    /* --------------------------------------------------------------------- */
    /* Cropping Parameters Declaration                                       */
    /* --------------------------------------------------------------------- */
    WORD32 i4_scaled_ref_layer_left_offset, i4_scaled_ref_layer_top_offset;
    WORD32 i4_scaled_ref_layer_right_offset, i4_scaled_ref_layer_bottom_offset;
    dec_seq_params_t *ps_sps;
    ps_sps = ps_dec->ps_cur_sps;

    /* --------------------------------------------------------------------- */
    /* Hardcoding flag information  (assuming no field support)              */
    /* --------------------------------------------------------------------- */
    i4_ref_layer_field_pic_flag = SVCD_FALSE;
    i4_field_pic_flag = SVCD_FALSE;
    i4_frame_mbs_only_flag = SVCD_TRUE;
    i4_field_Mb_flag = SVCD_FALSE;
    i4_bot_field_flag = SVCD_FALSE;
    i4_ref_layer_frame_Mbs_only_flag = SVCD_TRUE;
    i4_horz_dim = 0;
    i4_vert_dim = 0;

    /* --------------------------------------------------------------------- */
    /* Pointer and Paramater are intialized - Chroma and Luma                */
    /* --------------------------------------------------------------------- */
    {
        WORD32 i4_base_width;
        WORD32 i4_base_height;
        WORD32 i4_ref_layer_chroma_phase_x_plus1_flag;
        WORD32 i4_ref_layer_chroma_phase_y_plus1;
        WORD32 i4_chroma_phase_x_plus1_flag;
        WORD32 i4_chroma_phase_y_plus1;

        /* ------------------------------------------------------------- */
        /* HARD CODED FOR 420                                            */
        /* ------------------------------------------------------------- */
        WORD32 i4_sub_wd_chroma = 2;
        WORD32 i4_sub_ht_chroma = 2;

        i4_base_width = ps_ref_res_prms->i4_res_width;
        i4_base_height = ps_ref_res_prms->i4_res_height;

        i4_ref_layer_chroma_phase_x_plus1_flag =
            ps_curr_res_prms->i1_ref_lyr_chroma_phase_x_plus1_flag;
        i4_ref_layer_chroma_phase_y_plus1 = ps_curr_res_prms->i1_ref_lyr_chroma_phase_y_plus1;
        i4_chroma_phase_x_plus1_flag = ps_sps->s_sps_svc_ext.u1_chroma_phase_x_plus1_flag;
        i4_chroma_phase_y_plus1 = ps_sps->s_sps_svc_ext.u1_chroma_phase_y_plus1;
        i4_scaled_ref_layer_bottom_offset = ps_curr_res_prms->s_ref_lyr_scaled_offset.i2_bot;
        i4_scaled_ref_layer_left_offset = ps_curr_res_prms->s_ref_lyr_scaled_offset.i2_left;
        i4_scaled_ref_layer_top_offset = ps_curr_res_prms->s_ref_lyr_scaled_offset.i2_top;
        i4_scaled_ref_layer_right_offset = ps_curr_res_prms->s_ref_lyr_scaled_offset.i2_rt;

        /* ----------------------------------------------------------------- */
        /* Computing Effective Frame Dimensions                              */
        /* ------------------------------------------------------------------*/
        i4_ref_wd = (i4_base_width >> i4_chroma_flag);
        i4_ref_ht = (i4_base_height >> i4_chroma_flag) * (1 + i4_ref_layer_field_pic_flag);

        i4_scaled_wd = ps_curr_res_prms->u2_scaled_ref_width;
        i4_scaled_ht = ps_curr_res_prms->u2_scaled_ref_height;

        i4_scaled_wd = (i4_scaled_wd >> i4_chroma_flag);
        i4_scaled_ht = (i4_scaled_ht >> i4_chroma_flag) * (1 + i4_field_pic_flag);

        if(1 == i4_chroma_flag)
        {
            i4_refphase_x = i4_ref_layer_chroma_phase_x_plus1_flag - 1;
            i4_refphase_y = i4_ref_layer_chroma_phase_y_plus1 - 1;
            i4_phase_x = i4_chroma_phase_x_plus1_flag - 1;
            i4_phase_y = i4_chroma_phase_y_plus1 - 1;
            i4_sub_wd = i4_sub_wd_chroma;
            i4_sub_ht = i4_sub_ht_chroma;
            i4_mb_wd = MB_WIDTH >> 1;
            i4_mb_ht = MB_HEIGHT >> 1;
        }
        else
        {
            i4_refphase_x = 0;
            i4_refphase_y = 0;
            i4_phase_x = 0;
            i4_phase_y = 0;
            i4_sub_wd = 1;
            i4_sub_ht = 1;
            i4_mb_wd = MB_WIDTH;
            i4_mb_ht = MB_HEIGHT;
        }
    }

    /* --------------------------------------------------------------------- */
    /* Derive shift x and y based on level idd                               */
    /* --------------------------------------------------------------------- */
    if(ps_sps->u1_level_idc <= 30)
    {
        i4_shift_x = 16;
        i4_shift_y = 16;
    }
    else
    {
        i4_shift_x = 31 - svcd_get_ceil_log2(i4_ref_wd);
        i4_shift_y = 31 - svcd_get_ceil_log2(i4_ref_ht);
    }

    /* --------------------------------------------------------------------- */
    /* The following condition is not true in our case for time being        */
    /* --------------------------------------------------------------------- */
    if((SVCD_FALSE == i4_frame_mbs_only_flag) || (SVCD_FALSE == i4_ref_layer_frame_Mbs_only_flag))
    {
        i4_phase_y = i4_phase_y + 4 * i4_bot_field_flag;

        if(1 == i4_ref_layer_frame_Mbs_only_flag)
            i4_refphase_y = (2 * i4_refphase_y) + 2;
        else
            i4_refphase_y = i4_refphase_y + (4 * i4_bot_field_flag);
    }

    /* --------------------------------------------------------------------- */
    /* Dx and Dy Computation - Ratio of the base and enhance layer width     */
    /* --------------------------------------------------------------------- */
    i4_scale_x = ((i4_ref_wd << i4_shift_x) + (i4_scaled_wd >> 1)) / (i4_scaled_wd);
    i4_scale_y = ((i4_ref_ht << i4_shift_y) + (i4_scaled_ht >> 1)) / (i4_scaled_ht);

    i4_offset_x = i4_scaled_ref_layer_left_offset / i4_sub_wd;
    i4_add_x = (((i4_ref_wd * (2 + i4_phase_x)) << (i4_shift_x - 2)) + (i4_scaled_wd >> 1)) /
                   i4_scaled_wd +
               (1 << (i4_shift_x - 5));
    i4_delta_x = 4 * (2 + i4_refphase_x);

    if((SVCD_TRUE == i4_frame_mbs_only_flag) && (SVCD_TRUE == i4_ref_layer_frame_Mbs_only_flag))
    {
        i4_offset_y = i4_scaled_ref_layer_top_offset / i4_sub_ht;
        i4_add_y = (((i4_ref_ht * (2 + i4_phase_y)) << (i4_shift_y - 2)) + (i4_scaled_ht >> 1)) /
                       i4_scaled_ht +
                   (1 << (i4_shift_y - 5));
        i4_delta_y = 4 * (2 + i4_refphase_y);
    }
    else
    {
        i4_offset_y = i4_scaled_ref_layer_top_offset / (2 * i4_sub_ht);
        i4_add_y = (((i4_ref_ht * (2 + i4_phase_y)) << (i4_shift_y - 3)) + (i4_scaled_ht >> 1)) /
                       i4_scaled_ht +
                   (1 << (i4_shift_y - 5));
        i4_delta_y = 2 * (2 + i4_refphase_y);
    }

    /* --------------------------------------------------------------------- */
    /* Intializing Local Pointers   - Chroma and Luma                        */
    /* --------------------------------------------------------------------- */

    ps_x_off_len = ps_map_ctxt->ps_x_offset_length;
    ps_y_off_len = ps_map_ctxt->ps_y_offset_length;

    i4_curr_lyr_width = ps_curr_res_prms->i4_res_width >> i4_chroma_flag;
    i4_curr_lyr_height = ps_curr_res_prms->i4_res_height >> i4_chroma_flag;

    /* --------------------------------------------------------------------- */
    /* Dyadic Scaling Ratios Handling                                        */
    /* --------------------------------------------------------------------- */
    if(1 == ps_curr_res_prms->u1_dyadic_flag)
    {
        WORD32 i4_refarray_wd, i4_x_offset;
        WORD32 i4_refarray_ht, i4_y_offset;
        WORD32 i4_crp_wd_lt, i4_crp_ht_top;
        WORD32 i4_crp_wd_rt, i4_crp_ht_bot;
        WORD32 i4_ref_lyr_wd, i4_ref_lyr_ht;
        WORD32 i4_ref_x, i4_ref_y;
        WORD32 i4_ofst;
        WORD32 i4_i, i4_j;

        /* Hard coded for dyadic case */
        i4_refarray_wd = 20 >> i4_chroma_flag;
        i4_ofst = -2 >> i4_chroma_flag;
        i4_crp_wd_lt = i4_scaled_ref_layer_left_offset >> i4_chroma_flag;
        i4_crp_wd_rt = i4_scaled_ref_layer_right_offset >> i4_chroma_flag;
        i4_ref_lyr_wd = (i4_curr_lyr_width >> 1);

        i4_ref_x = 0;
        for(i4_i = 0; i4_i < i4_curr_lyr_width; i4_i += (i4_mb_wd << 1))
        {
            i4_x_offset = MAX(i4_ofst, (i4_ref_x + i4_ofst));
            i4_x_offset = MIN(i4_x_offset, (i4_ref_lyr_wd - i4_ofst));
            ps_x_off_len->i2_offset = i4_x_offset;
            ps_x_off_len->i2_length = i4_refarray_wd;
            ps_x_off_len++;
            ps_x_off_len->i2_offset = i4_x_offset;
            ps_x_off_len->i2_length = i4_refarray_wd;
            ps_x_off_len++;
            if(i4_i >= i4_crp_wd_lt)
            {
                if(i4_i <= (i4_curr_lyr_width - i4_crp_wd_rt))
                {
                    i4_ref_x += i4_mb_wd;
                }
            }
        }

        i4_refarray_ht = 20 >> i4_chroma_flag;
        i4_crp_ht_top = i4_scaled_ref_layer_top_offset >> i4_chroma_flag;
        i4_crp_ht_bot = i4_scaled_ref_layer_bottom_offset >> i4_chroma_flag;
        i4_ref_lyr_ht = (i4_curr_lyr_height >> 1);

        i4_ref_y = 0;
        for(i4_j = 0; i4_j < i4_curr_lyr_height; i4_j += (i4_mb_ht << 1))
        {
            i4_y_offset = MAX(i4_ofst, (i4_ref_y + i4_ofst));
            i4_y_offset = MIN(i4_y_offset, (i4_ref_lyr_ht - i4_ofst));
            ps_y_off_len->i2_offset = i4_y_offset;
            ps_y_off_len->i2_length = i4_refarray_ht;
            ps_y_off_len++;
            ps_y_off_len->i2_offset = i4_y_offset;
            ps_y_off_len->i2_length = i4_refarray_ht;
            ps_y_off_len++;
            if(i4_j >= i4_crp_ht_top)
            {
                if(i4_j <= (i4_curr_lyr_height - i4_crp_ht_bot))
                {
                    i4_ref_y += i4_mb_ht;
                }
            }
        }

        /* No need to process further, return */
        return;
    } /* If dyadic path */

    /* Proposed Algo for Optimization */
    {
        WORD32 i4_max, i4_min;
        ref_min_max_map_t *ps_x_min_max;
        ref_min_max_map_t *ps_y_min_max;
        WORD32 i4_i, i4_j;

        ps_x_min_max = ps_map_ctxt->ps_x_min_max;
        ps_y_min_max = ps_map_ctxt->ps_y_min_max;
        /* ----------------------------------------------------------------- */
        /* Computation of offsetX refArrayW Xmin and Xmax Lists              */
        /* ----------------------------------------------------------------- */
        for(i4_i = 0; i4_i < i4_curr_lyr_width; i4_i = i4_i + i4_mb_wd)
        {
            WORD32 i4_refarray_wd, i4_xr_index;
            WORD32 i4_x_refmin16;
            WORD32 i4_x_refmax16;
            WORD32 i4_x_offset;

            i4_x_refmin16 = (WORD64) (((WORD64) (i4_i - i4_offset_x) * i4_scale_x + i4_add_x) >>
                                      (i4_shift_x - 4)) -
                            i4_delta_x;

            i4_x_refmax16 =
                (WORD64) (((WORD64) (i4_i + i4_mb_wd - 1 - i4_offset_x) * i4_scale_x + i4_add_x) >>
                          (i4_shift_x - 4)) -
                i4_delta_x;

            /* ------------------------------------------------------------- */
            /* Modified AC205                                                */
            /* Minimum width required - So adding 2 pixels on each side      */
            /* ------------------------------------------------------------- */
            i4_refarray_wd = ((i4_x_refmax16 + 15) >> 4) - (i4_x_refmin16 >> 4) + 1 + 4;

            /* ------------------------------------------------------------- */
            /* Setting the offset 2 pixels before                            */
            /* ------------------------------------------------------------- */
            i4_x_offset = (i4_x_refmin16 >> 4) - 2;

            /* ------------------------------------------------------------- */
            /* Modifying the values based on the location                    */
            /* ------------------------------------------------------------- */
            i4_min = i4_x_offset;
            i4_xr_index = i4_min - ((i4_min / i4_mb_wd) * i4_mb_wd);

            if(i4_xr_index < (i4_mb_wd >> 1))
            {
                i4_refarray_wd = i4_refarray_wd + (i4_mb_wd >> 1);
                i4_x_offset = i4_x_offset - (i4_mb_wd >> 1);
            }

            i4_max = ((i4_x_refmax16 + 15) >> 4) + 2;
            i4_xr_index = i4_max - ((i4_max / i4_mb_wd) * i4_mb_wd);

            if(i4_xr_index >= (i4_mb_wd >> 1)) i4_refarray_wd = i4_refarray_wd + (i4_mb_wd >> 1);

            /* ------------------------------------------------------------- */
            /* Filling the arrays with offset, min, max and refArray dim     */
            /* ------------------------------------------------------------- */
            ps_x_off_len->i2_offset = i4_x_offset;
            ps_x_off_len->i2_length = i4_refarray_wd;

            ps_x_min_max->i2_min_pos = (i4_x_refmin16 >> 4) - i4_x_offset;
            ps_x_min_max->i2_max_pos = ((i4_x_refmax16 + 15) >> 4) - i4_x_offset;

            i4_tmp = (WORD32) (ps_x_min_max->i2_max_pos - ps_x_min_max->i2_min_pos) +
                     (4 >> i4_chroma_flag);
            if(i4_tmp > i4_horz_dim)
            {
                i4_horz_dim = i4_tmp;
            }

            /* increment the pointer */
            ps_x_off_len++;
            ps_x_min_max++;

        } /* end of loop over scaled width */

        /* ----------------------------------------------------------------- */
        /* Computation of offsetY refArrayH Ymin and Ymax Lists              */
        /* ----------------------------------------------------------------- */
        for(i4_j = 0; i4_j < i4_curr_lyr_height; i4_j = i4_j + i4_mb_ht)
        {
            WORD32 i4_refarray_ht, i4_yr_index;
            WORD32 i4_y_refmin16;
            WORD32 i4_y_refmax16;
            WORD32 i4_y_offset;

            i4_y_refmin16 = (WORD64) (((WORD64) (i4_j - i4_offset_y) * i4_scale_y + i4_add_y) >>
                                      (i4_shift_y - 4)) -
                            i4_delta_y;

            i4_y_refmax16 =
                (WORD64) (((WORD64) (i4_j + i4_mb_ht - 1 - i4_offset_y) * i4_scale_y + i4_add_y) >>
                          (i4_shift_y - 4)) -
                i4_delta_y;

            /* ------------------------------------------------------------- */
            /* Modified AC205                                                */
            /* Minimum width required - So adding 2 pixels on each side      */
            /* ------------------------------------------------------------- */
            i4_refarray_ht = ((i4_y_refmax16 + 15) >> 4) - (i4_y_refmin16 >> 4) + 1 + 4;

            /* ------------------------------------------------------------- */
            /* Setting the offset 2 pixels before                            */
            /* ------------------------------------------------------------- */
            i4_y_offset = (i4_y_refmin16 >> 4) - 2;

            /* ------------------------------------------------------------- */
            /* Modifying the values based on the location                    */
            /* ------------------------------------------------------------- */
            i4_min = i4_y_offset;

            i4_yr_index = i4_min - ((i4_min / i4_mb_ht) * i4_mb_ht);

            if(i4_yr_index < (i4_mb_ht >> 1))
            {
                i4_refarray_ht = i4_refarray_ht + (i4_mb_ht >> 1);
                i4_y_offset = i4_y_offset - (i4_mb_ht >> 1);
            }

            i4_max = ((i4_y_refmax16 + 15) >> 4) + 2;
            i4_yr_index = i4_max - ((i4_max / i4_mb_ht) * i4_mb_ht);

            if(i4_yr_index >= (i4_mb_ht >> 1)) i4_refarray_ht = i4_refarray_ht + (i4_mb_ht >> 1);

            /* ------------------------------------------------------------- */
            /* Filling the arrays with offset, min, max and refArray dim     */
            /* ------------------------------------------------------------- */
            ps_y_off_len->i2_offset = i4_y_offset;
            ps_y_off_len->i2_length = i4_refarray_ht;

            ps_y_min_max->i2_min_pos = (i4_y_refmin16 >> 4) - i4_y_offset;
            ps_y_min_max->i2_max_pos = ((i4_y_refmax16 + 15) >> 4) - i4_y_offset;

            i4_tmp = (WORD32) (ps_y_min_max->i2_max_pos - ps_y_min_max->i2_min_pos) +
                     (4 >> i4_chroma_flag);
            if(i4_tmp > i4_vert_dim)
            {
                i4_vert_dim = i4_tmp;
            }

            /* increment the pointer */
            ps_y_off_len++;
            ps_y_min_max++;
        } /* end of loop over scaled height */
    }

    /* --------------------------------------------------------------------- */
    /* Computation of Xref and Xphase List as per standard                   */
    /* --------------------------------------------------------------------- */
    ps_x_off_len = ps_map_ctxt->ps_x_offset_length;
    ps_y_off_len = ps_map_ctxt->ps_y_offset_length;

    {
        ref_pixel_map_t *ps_x_pos_phase;
        WORD32 i4_xc;
        WORD32 i4_offset_x_index;

        ps_x_pos_phase = ps_map_ctxt->ps_x_pos_phase;

        for(i4_xc = 0; i4_xc < i4_curr_lyr_width; i4_xc++)
        {
            WORD32 i4_x_offset;
            WORD32 i4_x_ref16;

            i4_offset_x_index = i4_xc / i4_mb_wd;

            i4_x_offset = ps_x_off_len[i4_offset_x_index].i2_offset;

            i4_x_ref16 = (WORD64) (((WORD64) (i4_xc - i4_offset_x) * i4_scale_x + i4_add_x) >>
                                   (i4_shift_x - 4)) -
                         i4_delta_x;

            /* store the values */
            ps_x_pos_phase->i2_ref_pos = (i4_x_ref16 >> 4) - i4_x_offset;
            ps_x_pos_phase->i2_phase = i4_x_ref16 & 15;

            /* increment the pointer */
            ps_x_pos_phase++;

        } /* end of loop over scaled width */
    }

    /* --------------------------------------------------------------------- */
    /* Computation of Yref and Yphase List as per standard                   */
    /* --------------------------------------------------------------------- */
    {
        WORD32 i4_yc;
        ref_pixel_map_t *ps_y_pos_phase;

        ps_y_pos_phase = ps_map_ctxt->ps_y_pos_phase;

        for(i4_yc = 0; i4_yc < i4_curr_lyr_height; i4_yc++)
        {
            WORD32 i4_y_offset;
            WORD32 i4_y_ref16;
            WORD32 i4_offset_y_index;

            i4_offset_y_index = i4_yc / i4_mb_ht;

            i4_y_offset = ps_y_off_len[i4_offset_y_index].i2_offset;

            if((SVCD_FALSE == i4_frame_mbs_only_flag) ||
               (SVCD_FALSE == i4_ref_layer_frame_Mbs_only_flag))
            {
                i4_yc = i4_yc >> (1 - i4_field_Mb_flag);
            }

            i4_y_ref16 = (WORD64) (((WORD64) (i4_yc - i4_offset_y) * i4_scale_y + i4_add_y) >>
                                   (i4_shift_y - 4)) -
                         i4_delta_y;

            ps_y_pos_phase->i2_ref_pos = (i4_y_ref16 >> 4) - i4_y_offset;
            ps_y_pos_phase->i2_phase = i4_y_ref16 & 15;

            /* increment the pointer */
            ps_y_pos_phase++;

        } /* end of loop over scaled height */
    }

    /* --------------------------------------------------------------------- */
    /* Computation of Corresponding Diagonal Location                        */
    /* --------------------------------------------------------------------- */
    {
        WORD16 *pi2_xd_index;
        WORD16 *pi2_yd_index;
        WORD16 *pi2_ya_index;
        WORD32 i4_i, i4_j;

        pi2_xd_index = ps_map_ctxt->pi2_xd_index;
        pi2_yd_index = ps_map_ctxt->pi2_yd_index;
        pi2_ya_index = ps_map_ctxt->pi2_ya_index;

        for(i4_i = 0; i4_i < i4_mb_wd; i4_i++)
        {
            *(pi2_xd_index + i4_i) = ((i4_i >= i4_mb_wd >> 1) ? (i4_i - i4_mb_wd) : (i4_i + 1));

        } /* end of loop over MB width */

        for(i4_j = 0; i4_j < i4_mb_ht; i4_j++)
        {
            *(pi2_yd_index + i4_j) = ((i4_j >= i4_mb_ht >> 1) ? (i4_j - i4_mb_ht) : (i4_j + 1));

            *(pi2_ya_index + i4_j) =
                *(pi2_yd_index + i4_j) - ((i4_mb_ht >> 1 + 1) * (SIGN(*(pi2_yd_index + i4_j))));

        } /* end of loop over MB height */
    }

    /* generate the lookup to generate horizontal segments */
    svc_intra_resamp_generate_segment_lookup(ps_map_ctxt->ps_seg_lookup_horz, i4_horz_dim, i4_mb_wd,
                                             3);

    /* generate the lookup to generate vertical segments */
    svc_intra_resamp_generate_segment_lookup(ps_map_ctxt->ps_seg_lookup_vert, i4_vert_dim, i4_mb_ht,
                                             4);

    return;
} /* end of function "svcd_intra_samp_populate_list"*/

void svcd_intra_samp_populate_res_prms(void *pv_dec)

{
    dec_struct_t *ps_dec = (dec_struct_t *) pv_dec;
    res_prms_t *ps_curr_lyr_res_prms;
    ps_curr_lyr_res_prms = &ps_dec->s_res_prms;

    ps_curr_lyr_res_prms->i4_res_width = ps_dec->u2_pic_wd;
    ps_curr_lyr_res_prms->i4_res_height = ps_dec->u2_pic_ht;
    ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_left =
        ps_dec->ps_cur_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_left_offset << 1;
    ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_top =
        ps_dec->ps_cur_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_top_offset << 1;
    ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_rt =
        ps_dec->ps_cur_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_right_offset << 1;
    ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_bot =
        ps_dec->ps_cur_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_bottom_offset << 1;
    ps_curr_lyr_res_prms->u2_scaled_ref_width =
        (ps_dec->u2_frm_wd_in_mbs << 4) - (ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_left +
                                           ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_rt);

    ps_curr_lyr_res_prms->u2_scaled_ref_height =
        (ps_dec->u2_frm_ht_in_mbs << 4) - (ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_top +
                                           ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_bot);

    ps_curr_lyr_res_prms->u1_cropping_change_flag = 0;
    if(2 == ps_dec->ps_cur_sps->s_sps_svc_ext.u1_extended_spatial_scalability_idc)
    {
        ps_curr_lyr_res_prms->u1_cropping_change_flag = 1;

        ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_left =
            ps_dec->ps_cur_slice->s_svc_slice_params.i4_scaled_ref_layer_left_offset << 1;

        ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_top =
            ps_dec->ps_cur_slice->s_svc_slice_params.i4_scaled_ref_layer_top_offset << 1;
        ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_rt =
            ps_dec->ps_cur_slice->s_svc_slice_params.i4_scaled_ref_layer_right_offset << 1;
        ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_bot =
            ps_dec->ps_cur_slice->s_svc_slice_params.i4_scaled_ref_layer_bottom_offset << 1;
        ps_curr_lyr_res_prms->u2_scaled_ref_width =
            (ps_dec->u2_frm_wd_in_mbs << 4) -
            (ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_left +
             ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_rt);

        ps_curr_lyr_res_prms->u2_scaled_ref_height =
            (ps_dec->u2_frm_ht_in_mbs << 4) -
            (ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_top +
             ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_bot);
    }

    ps_curr_lyr_res_prms->u1_rstrct_res_change_flag = SVCD_TRUE;

    ps_curr_lyr_res_prms->u1_disable_inter_lyr_dblk_filter_idc =
        ps_dec->ps_cur_slice->s_svc_slice_params.u4_disable_inter_layer_deblk_filter_idc;
    ps_curr_lyr_res_prms->i1_inter_lyr_alpha_c0_offset =
        ps_dec->ps_cur_slice->s_svc_slice_params.i4_inter_layer_slice_alpha_c0_offset_div2;
    ps_curr_lyr_res_prms->i1_inter_lyr_beta_offset =
        ps_dec->ps_cur_slice->s_svc_slice_params.i4_inter_layer_slice_beta_offset_div2;
    ps_curr_lyr_res_prms->i1_constrained_intra_rsmpl_flag =
        ps_dec->ps_cur_slice->s_svc_slice_params.u1_constrained_intra_resampling_flag;
    ps_curr_lyr_res_prms->i1_ref_lyr_chroma_phase_x_plus1_flag =
        ps_dec->ps_cur_sps->s_sps_svc_ext.u1_seq_ref_layer_chroma_phase_x_plus1_flag;
    ps_curr_lyr_res_prms->i1_ref_lyr_chroma_phase_y_plus1 =
        ps_dec->ps_cur_sps->s_sps_svc_ext.u1_seq_ref_layer_chroma_phase_y_plus1;
    ps_curr_lyr_res_prms->u1_direct_8x8_inference_flag =
        ps_dec->ps_cur_sps->u1_direct_8x8_inference_flag;

    ps_curr_lyr_res_prms->u1_remap_req_flag = 1;
    ps_curr_lyr_res_prms->u1_dyadic_flag = ps_dec->u1_dyadic_flag;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : svcd_intra_samp_res_init                                 */
/*                                                                           */
/*  Description   : this function calculates the scale factors and initialise*/
/*                  the context structure                                    */
/*                                                                           */
/*  Inputs        : pv_intra_samp_ctxt: handle to private structure          */
/*                  ps_curr_lyr_res_prms: pointer to current resolution      */
/*                                               params                      */
/*                  ps_ref_lyr_res_prms : pointer to ref resolution params   */
/*  Globals       : none                                                     */
/*  Processing    : it stores the layer dimensions                           */
/*                                                                           */
/*  Outputs       : none                                                     */
/*  Returns       : none                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         26 06 2009   vijayakumar          creation                        */
/*                                                                           */
/*****************************************************************************/
void svcd_intra_samp_res_init(void *pv_intra_samp_ctxt, res_prms_t *ps_curr_lyr_res_prms,
                              ref_mb_map_t **pps_luma_map_horz, ref_mb_map_t **pps_chroma_map_horz,
                              ref_mb_map_t **pps_luma_map_vert, ref_mb_map_t **pps_chroma_map_vert,
                              void *pv_dec)

{
    intra_sampling_ctxt_t *ps_ctxt;
    intra_samp_lyr_ctxt *ps_lyr_ctxt;
    dec_seq_params_t *ps_sps;
    dec_struct_t *ps_dec = (dec_struct_t *) pv_dec;
    dec_struct_t *ps_dec_ref_layer;
    dec_slice_params_t *ps_slice = ps_dec->ps_cur_slice;
    dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
    ps_svc_slice_params = &ps_slice->s_svc_slice_params;
    ps_sps = ps_dec->ps_cur_sps;
    ps_dec_ref_layer = ps_dec->ps_dec_ref_layer;
    ps_ctxt = (intra_sampling_ctxt_t *) pv_intra_samp_ctxt;

    /* if called for base resolution store default values */
    if(SVCD_TRUE == ps_dec->u1_base_res_flag)
    {
        *pps_luma_map_horz = NULL;
        *pps_chroma_map_horz = NULL;
        *pps_luma_map_vert = NULL;
        *pps_chroma_map_vert = NULL;
        ps_ctxt->i4_res_lyr_id = -1;
        ps_ctxt->i4_ref_width = ps_dec->u2_pic_wd;
        ps_ctxt->i4_ref_height = ps_dec->u2_pic_ht;

        /* Note: The stride option is provided for bringing in data at NMB */
        /* level. Hence to set a NMB level stride refSample array buffer   */
        /* have to be increased                                            */
        ps_ctxt->i4_refarray_stride = REF_ARRAY_WIDTH;
        return;
    }

    /* derive the current sps */

    /* store the res id appropriately */
    ps_ctxt->i4_res_lyr_id = ps_dec->u1_layer_id - 1;

    /* store the resolution params */
    ps_ctxt->ps_res_prms = ps_curr_lyr_res_prms;

    /* get the current layer ctxt */
    ps_lyr_ctxt = &ps_ctxt->as_res_lyrs[ps_dec->u1_layer_id - 1];

    ps_ctxt->i4_res_lyr_id = ps_dec->u1_layer_id - 1;
    /* get the width and heights */
    ps_lyr_ctxt->i4_curr_width = ps_dec->u2_pic_wd;
    ps_lyr_ctxt->i4_curr_height = ps_dec->u2_pic_ht;
    ps_lyr_ctxt->i4_ref_width = ps_ctxt->i4_ref_width;
    ps_lyr_ctxt->i4_ref_height = ps_ctxt->i4_ref_height;
    ps_lyr_ctxt->i1_constrained_intra_rsmpl_flag =
        ps_svc_slice_params->u1_constrained_intra_resampling_flag;

    /* store the structure pointer containing projected locations */
    *pps_luma_map_horz = ps_lyr_ctxt->s_luma_map_ctxt.ps_x_offset_length;
    *pps_chroma_map_horz = ps_lyr_ctxt->s_chroma_map_ctxt.ps_x_offset_length;
    *pps_luma_map_vert = ps_lyr_ctxt->s_luma_map_ctxt.ps_y_offset_length;
    *pps_chroma_map_vert = ps_lyr_ctxt->s_chroma_map_ctxt.ps_y_offset_length;

    /* check for recomputation of mapping required */
    if(SVCD_TRUE == ps_curr_lyr_res_prms->u1_remap_req_flag)
    {
        res_prms_t s_ref_res_prms = {0};
        WORD32 i4_chroma_x_phase, i4_chroma_y_phase;
        WORD32 i4_ref_chroma_x_phase, i4_ref_chroma_y_phase;
        WORD32 i4_x_phase_0, i4_x_phase_1;
        WORD32 i4_y_phase_0, i4_y_phase_1;
        WORD32 i4_vert_flag;

        /* store the reference layer resolution width and height */
        s_ref_res_prms.i4_res_width = ps_ctxt->i4_ref_width;
        s_ref_res_prms.i4_res_height = ps_ctxt->i4_ref_height;

        /* call the frame level projections calculation function */
        svcd_intra_samp_populate_list(&ps_lyr_ctxt->s_luma_map_ctxt, ps_curr_lyr_res_prms,
                                      &s_ref_res_prms, 0, ps_dec);

        svcd_intra_samp_populate_list(&ps_lyr_ctxt->s_chroma_map_ctxt, ps_curr_lyr_res_prms,
                                      &s_ref_res_prms, 1, ps_dec);

        /* Compute the chroma xPhase and yPhase values */
        if(1 == ps_curr_lyr_res_prms->u1_dyadic_flag)
        {
            i4_ref_chroma_x_phase = ps_curr_lyr_res_prms->i1_ref_lyr_chroma_phase_x_plus1_flag;
            i4_ref_chroma_y_phase = ps_curr_lyr_res_prms->i1_ref_lyr_chroma_phase_y_plus1;
            i4_chroma_x_phase = ps_sps->s_sps_svc_ext.u1_chroma_phase_x_plus1_flag;
            i4_chroma_y_phase = ps_sps->s_sps_svc_ext.u1_chroma_phase_y_plus1;

            i4_x_phase_0 = i4_chroma_x_phase - (i4_ref_chroma_x_phase << 1);
            i4_x_phase_1 = (3 + i4_x_phase_0) & 0x7;
            i4_x_phase_0 += 7;
            i4_x_phase_0 &= 0x7;
            i4_y_phase_0 = i4_chroma_y_phase - (i4_ref_chroma_y_phase << 1);
            i4_y_phase_1 = (3 + i4_y_phase_0) & 0x7;
            i4_y_phase_0 += 7;
            i4_y_phase_0 &= 0x7;

            ps_lyr_ctxt->i4_x_phase_0 = i4_x_phase_0;
            ps_lyr_ctxt->i4_x_phase_1 = i4_x_phase_1;
            ps_lyr_ctxt->i4_y_phase_0 = i4_y_phase_0;
            ps_lyr_ctxt->i4_y_phase_1 = i4_y_phase_1;

            /* Choose the appropriate chroma interpolation functions */
            if((0 == i4_ref_chroma_x_phase) && (1 == i4_chroma_x_phase))
            {
                ps_lyr_ctxt->pf_horz_chroma_interpol = (&svcd_horz_interpol_chroma_dyadic_2);
            }
            else
            {
                ps_lyr_ctxt->pf_horz_chroma_interpol = (&svcd_horz_interpol_chroma_dyadic_1);
            }

            i4_vert_flag = 0;
            if(0 == i4_ref_chroma_y_phase)
            {
                if((1 == i4_chroma_y_phase) || (2 == i4_chroma_y_phase))
                {
                    i4_vert_flag = 1;
                }
            }
            else if((2 == i4_ref_chroma_y_phase) && (0 == i4_chroma_y_phase))
            {
                i4_vert_flag = 2;
            }

            if(1 == i4_vert_flag)
            {
                ps_lyr_ctxt->pf_vert_chroma_interpol = (&svcd_vert_interpol_chroma_dyadic_2);
            }
            else if(2 == i4_vert_flag)
            {
                ps_lyr_ctxt->pf_vert_chroma_interpol = (&svcd_vert_interpol_chroma_dyadic_3);
            }
            else
            {
                ps_lyr_ctxt->pf_vert_chroma_interpol = (&svcd_vert_interpol_chroma_dyadic_1);
            }
        }
    }
    else
    {
        /* should take false value */
        ASSERT(SVCD_FALSE == ps_curr_lyr_res_prms->u1_remap_req_flag);
    }

    /* Set the border values of ref_mb_modes to 0xFF */
    {
        inter_lyr_mb_prms_t *ps_tmp_prms, *ps_tmp_prms_2;
        inter_lyr_mb_prms_t *ps_ref_mb_prms;
        WORD32 i4_stride;
        WORD32 i4_ref_ht_in_mbs, i4_ref_wd_in_mbs;
        WORD32 i4_i;

        /* Derive the reference mb mode map */

        ps_ref_mb_prms = ps_dec_ref_layer->ps_inter_lyr_mb_prms_frm_start;
        i4_stride =
            ps_dec_ref_layer->u2_inter_lyr_mb_prms_stride;  // SVC_DEC_REVIEW_INTRA_RESAMPLE;

        i4_ref_ht_in_mbs = (ps_lyr_ctxt->i4_ref_height >> 4);
        i4_ref_wd_in_mbs = (ps_lyr_ctxt->i4_ref_width >> 4);

        /* Set the first border row to 0xFF */
        ps_tmp_prms = (ps_ref_mb_prms - 1 - i4_stride);

        for(i4_i = 0; i4_i < (i4_ref_wd_in_mbs + 2); i4_i++)
        {
            ps_tmp_prms->i1_mb_mode = (WORD8) 0xFF;
            ps_tmp_prms += 1;
        }

        /* Set the left and right border pixels of each row to 0 */
        ps_tmp_prms = ps_ref_mb_prms - 1;

        for(i4_i = 0; i4_i < i4_ref_ht_in_mbs; i4_i++)
        {
            ps_tmp_prms->i1_mb_mode = (WORD8) 0xFF;
            ps_tmp_prms_2 = ps_tmp_prms + (i4_ref_wd_in_mbs + 1);
            ps_tmp_prms_2->i1_mb_mode = (WORD8) 0xFF;
            ps_tmp_prms += i4_stride;
        }

        /* Set the last border row to 0xFF */
        for(i4_i = 0; i4_i < (i4_ref_wd_in_mbs + 2); i4_i++)
        {
            ps_tmp_prms->i1_mb_mode = (WORD8) 0xFF;
            ps_tmp_prms += 1;
        }
    }

    /* store the current layer width and height to context */
    ps_ctxt->i4_ref_width = ps_curr_lyr_res_prms->i4_res_width;
    ps_ctxt->i4_ref_height = ps_curr_lyr_res_prms->i4_res_height;

    return;
}