/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * 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.
 * -------------------------------------------------------------------
 */
/*
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    xpos = x half-pixel of (x,y) coordinates within a VOP; motion
           compensated coordinates; native data type
    ypos = y half-pixel of (x,y) coordinates within a VOP; motion
           compensated coordinates; native data type
    comp = pointer to 8-bit compensated prediction values within a VOP;
           computed by this module (i/o); full-pel resolution; 8-bit data
    c_prev = pointer to previous 8-bit prediction values within a VOP;
         values range from (0-255); full-pel resolution; 8-bit data
    sh_d = pointer to residual values used to compensate the predicted
           value; values range from (-512 to 511); full-pel resolution;
           native data type
    width = width of the VOP in pixels (x axis); full-pel resolution;
        native data type
    height = height of the VOP in pixels (y axis); full-pel resolution;
         native data type
    rnd1 = rounding value for case when one dimension uses half-pel
           resolution; native data type
    rnd2 = rounding value for case when two dimensions uses half-pel
           resolution; native data type

 Outputs:
    returns 1

 Local Stores/Buffers/Pointers Needed:
    None

 Global Stores/Buffers/Pointers Needed:
    None

 Pointers and Buffers Modified:
    comp = buffer contains newly computed compensated prediction values

 Local Stores Modified:
    None

 Global Stores Modified:
    None

------------------------------------------------------------------------------
 FUNCTION DESCRIPTION

 Summary:

 This function performs motion compensated prediction for the case where
 the motion vector points to a block outside the VOP. The function interpolates
 the pixels that are outside the VOP using the boundary pixels for the block.
 Once the values are interpolated, the pixel values are computed for a block
 in the current VOP. The prediction values are generated by averaging pixel
 values in the previous VOP; the block position in the previous frame is
 computed from the current block's motion vector. The computed pixel values
 are calculated by adding the prediction values to the block residual values.

 Details:

 First, this functions determines which VOP boundary(ies) the motion vector
 is outside, i.e., left, right, top, bottom. xpos is compared to the left and
 right boundaries; ypos is compared to the top and bottom boundaries. The number
 of block pixels inside the the boundary in the x and y directions are stored
 in endx and endy, respectively. If the entire block is inside the x or y
 boundary, the respectively end is set to 0.

 After the boundaries are tested, any pixels lying outside a boundary are
 interpolated from the boundary pixels. For example, if the block is outside the
 bottom boundary, boundary pixels alone the bottom of the VOP as used to
 interpolated those pixels lying outside the bottom boundary. The interpolation
 used is a simple column-wise or row-wise copy of the boundary pixels (inside the
 block) depending on which boundary the block is outside. In our example, each
 boundary pixel would be copied column-wise to the pixel beneath it. If the
 block was outside right boundary, the boundary pixels would be copied row-wise
 to the pixel to the right of it. If the block was outside both an x and y
 boundary, the boundary pixels would be copied row-wise for the portion of the
 block outside the x boundary, and column-wise for the portion of the block
 outside the y boundary. And so on.

 Once the pixel interpolation is complete, the motion compensated output values
 (comp[]) are calculed from the motion compensated prediction (pred[])values and
 the residual values (sh_d[]) of the current frame. The prediction values are
 generated by averaging pixel values in the previous VOP; the block position in
 the previous frame is computed from the current block's motion vector. The
 computed pixel values are calculated by adding the prediction values to the
 block residual values.

*/

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include "mp4dec_lib.h"
#include "motion_comp.h"

#define PAD_CORNER {    temp = *prev; \
            temp |= (temp<<8);  \
            temp |= (temp<<16); \
            *((uint32*)ptr) = temp; \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  \
            *((uint32*)(ptr+=16)) = temp;  \
            *((uint32*)(ptr+4)) = temp;  }

#define PAD_ROW  {  temp = *((uint32*)prev); \
                    temp2 = *((uint32*)(prev+4)); \
            *((uint32*)ptr) =  temp;\
            *((uint32*)(ptr+4)) =  temp2; \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;\
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;\
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;\
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;\
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;\
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;\
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp2;}

#define PAD_EXTRA_4x8           {   temp = *((uint32*)(prev+8)); \
                *((uint32*)ptr) =  temp; \
                *((uint32*)(ptr+=16)) = temp; \
                *((uint32*)(ptr+=16)) = temp; \
                *((uint32*)(ptr+=16)) = temp; \
                *((uint32*)(ptr+=16)) = temp; \
                *((uint32*)(ptr+=16)) = temp; \
                *((uint32*)(ptr+=16)) = temp; \
                *((uint32*)(ptr+=16)) = temp; }

#define PAD_COL { temp = *prev; \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)ptr) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp; \
            temp = *(prev+=16); \
            temp|=(temp<<8);  temp|=(temp<<16); \
            *((uint32*)(ptr+=16)) = temp; \
            *((uint32*)(ptr+4)) = temp;}

/* copy 8x8 block */
#define COPY_BLOCK  {           *((uint32*)ptr) = *((uint32*)prev); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4));  }

#define COPY_12x8       {       *((uint32*)ptr) = *((uint32*)prev); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); }

/*----------------------------------------------------------------------------
; FUNCTION CODE
----------------------------------------------------------------------------*/
int GetPredOutside(
    int xpos,       /* i */
    int ypos,       /* i */
    uint8 *c_prev,      /* i */
    uint8 *pred_block,      /* i */
    int width,      /* i */
    int height,     /* i */
    int rnd1,       /* i */
    int pred_width
)
{
    /*----------------------------------------------------------------------------
    ; Define all local variables
    ----------------------------------------------------------------------------*/
    uint8   *prev;      /* pointers to adjacent pixels in the    */
    uint8   pred[256];  /* storage for padded pixel values, 16x16 */
    uint8   *ptr;
    int xoffset;
    uint32 temp, temp2;

    /*----------------------------------------------------------------------------
    ; Function body here
    ----------------------------------------------------------------------------*/
    /* saturate xpos and ypos */
    if (xpos < -16) xpos = -16;
    if (xpos > ((width - 1) << 1)) xpos = (width - 1) << 1;
    if (ypos < -16) ypos = -16;
    if (ypos > ((height - 1) << 1)) ypos = (height - 1) << 1;

    if (xpos < 0)
    {
        if (ypos < 0) /* pad top left of frame */
        {
            /* copy the block */
            ptr = pred + (8 << 4) + 8;
            prev = c_prev;
            COPY_BLOCK

            /* pad the corner */
            ptr = pred;
            prev = pred + (8 << 4) + 8;
            PAD_CORNER

            /* pad top */
            ptr = pred + 8;
            prev = pred + (8 << 4) + 8;
            PAD_ROW

            /* pad left */
            ptr = pred + (8 << 4);
            prev = pred + (8 << 4) + 8;
            PAD_COL


            ptr = pred + (((ypos >> 1) + 8) << 4) + (xpos >> 1) + 8;

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
        else if ((ypos >> 1) < (height - B_SIZE)) /* pad left of frame */
        {
            /* copy block */
            ptr = pred + 8;
            prev = c_prev + (ypos >> 1) * width;
            COPY_BLOCK
            /* copy extra line */
            *((uint32*)(ptr += 16)) = *((uint32*)(prev += width));
            *((uint32*)(ptr + 4)) = *((uint32*)(prev + 4));

            /* pad left */
            ptr = pred;
            prev = pred + 8;
            PAD_COL
            /* pad extra line */
            temp = *(prev += 16);
            temp |= (temp << 8);
            temp |= (temp << 16);
            *((uint32*)(ptr += 16)) = temp;
            *((uint32*)(ptr + 4)) = temp;

            ptr = pred + 8 + (xpos >> 1);

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
        else /* pad bottom left of frame */
        {
            /* copy the block */
            ptr = pred + 8; /* point to the center */
            prev = c_prev + width * (height - 8);
            COPY_BLOCK

            /* pad the corner */
            ptr = pred + (8 << 4);
            prev = ptr - 8;
            PAD_CORNER

            /* pad bottom */
            ptr = pred + (8 << 4) + 8;
            prev = ptr - 16;
            PAD_ROW

            /* pad left */
            ptr = pred ;
            prev = ptr + 8;
            PAD_COL

            ptr = pred + 8 + (((ypos >> 1) - (height - 8)) << 4) + (xpos >> 1);

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
    }
    else if ((xpos >> 1) < (width - B_SIZE))
    {
        if (ypos < 0) /* pad top of frame */
        {
            xoffset = xpos >> 1;
            xoffset = xoffset & 0x3; /* word align ptr */

            /* copy block */
            ptr = pred + (8 << 4);
            prev = c_prev + (xpos >> 1) - xoffset;

            if (xoffset || (xpos&1)) /* copy extra 4x8 */
            {
                COPY_12x8
            }
            else
            {
                COPY_BLOCK
            }

            /* pad top */
            ptr = pred;
            prev = pred + (8 << 4);
            PAD_ROW
            if (xoffset || (xpos&1)) /* pad extra 4x8 */
            {
                ptr = pred + 8;
                PAD_EXTRA_4x8
            }

            ptr = pred + (((ypos >> 1) + 8) << 4) + xoffset;

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
        else /* pad bottom of frame */
        {
            xoffset = xpos >> 1;
            xoffset = xoffset & 0x3; /* word align ptr */
            /* copy block */
            ptr = pred ;
            prev = c_prev + width * (height - 8) + (xpos >> 1) - xoffset;
            if (xoffset  || (xpos&1))
            {
                COPY_12x8
            }
            else
            {
                COPY_BLOCK
            }

            /* pad bottom */
            ptr = pred + (8 << 4);
            prev = ptr - 16;
            PAD_ROW
            if (xoffset || (xpos&1))
            {
                ptr = pred + (8 << 4) + 8;
                PAD_EXTRA_4x8
            }

            ptr = pred + (((ypos >> 1) - (height - 8)) << 4) + xoffset;

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
    }
    else
    {
        if (ypos < 0) /* pad top right of frame */
        {
            /* copy block */
            ptr = pred + (8 << 4);
            prev = c_prev + width - 8;
            COPY_BLOCK

            /* pad top-right */
            ptr = pred + 8;
            prev = pred + (8 << 4) + 7;
            PAD_CORNER

            /* pad top */
            ptr = pred ;
            prev = pred + (8 << 4);
            PAD_ROW;

            /* pad right */
            ptr = pred + (8 << 4) + 8;
            prev = ptr - 1;
            PAD_COL;

            ptr = pred + ((8 + (ypos >> 1)) << 4) + (8 - (width - (xpos >> 1)));

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
        else if ((ypos >> 1) < (height - B_SIZE)) /* pad right of frame */
        {
            /* copy block */
            ptr = pred;
            prev = c_prev + (ypos >> 1) * width + width - 8;
            COPY_BLOCK
            /* copy extra line */
            *((uint32*)(ptr += 16)) = *((uint32*)(prev += width));
            *((uint32*)(ptr + 4)) = *((uint32*)(prev + 4));

            /* pad right */
            ptr = pred + 8;
            prev = ptr - 1;
            PAD_COL;
            /* pad extra line */
            temp = *(prev += 16);
            temp |= (temp << 8);
            temp |= (temp << 16);
            *((uint32*)(ptr += 16)) = temp;
            *((uint32*)(ptr + 4)) = temp;


            ptr = pred + 8 - (width - (xpos >> 1));

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;

        }
        else /* pad bottom right of frame */
        {
            /* copy block */
            ptr = pred;
            prev = c_prev + width * (height - 8) + width - 8;
            COPY_BLOCK

            /* pad bottom-right */
            ptr = pred + (8 << 4) + 8;
            prev = ptr - 17;
            PAD_CORNER

            /* pad right */
            ptr = pred + 8;
            prev = ptr - 1;
            PAD_COL

            /* pad bottom */
            ptr = pred + (8 << 4);
            prev = ptr - 16;
            PAD_ROW

            ptr = pred + 8 - (width - (xpos >> 1)) + ((8 - (height - (ypos >> 1))) << 4);

            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);

            return 1;
        }
    }
}