/* ------------------------------------------------------------------
 * 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.
 * -------------------------------------------------------------------
 */
#include "colorconv_config.h"
#include "cczoomrotationbase.h"

// Use default DLL entry point
#include "oscl_dll.h"
OSCL_DLL_ENTRY_POINT_DEFAULT()


/**************************************************************
ASSUMPTIONS:
1. zoom ratio must be in range (1, 3]
2. cannot do zoom in in one dimenstion and zoom out in another
3. caller should take care of the aspect ratio control
4. if there are margins, the caller should paint the background to the desired color
5. all the starting address MUST be multiple of 4, which is normally the case.

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


ColorConvertBase::ColorConvertBase(): _mRowPix(NULL), _mColPix(NULL), _mInitialized(false), _mState(0), _mYuvRange(false)
{
}


OSCL_EXPORT_REF ColorConvertBase::~ColorConvertBase()
{
    if (_mRowPix)
    {
        OSCL_ARRAY_DELETE(_mRowPix);
    }
    if (_mColPix)
    {
        OSCL_ARRAY_DELETE(_mColPix);
    }
}


int16 ColorConvertBase::GetCapability(void)
{
    int16 cap = 0;
#if CCROTATE
    cap |= CCSUPPORT_ROTATION;
#endif
#if CCSCALING
    cap |= CCSUPPORT_SCALING;
#endif
    return cap;
}


/**************************************************************
nRotation : Rotation direction is defined at run time
			0 -- No rotation
			1 -- 90 degree counter clockwise (default)
			2 -- 180 degree rotation (upside-down)
			3 -- 90 degree clockwise
			-1 -- flip left-right
			-2 -- flip and rotate 90 degree cnt clk
			-3 -- flip and rotate 180 degree
			-4 -- flip and rotate 270 degree
**************************************************************/
int32 ColorConvertBase::Init(int32 Src_width, int32 Src_height, int32 Src_pitch, int32 Dst_width, int32 Dst_height, int32 Dst_pitch, int32 nRotation)
{

    /* check the followings, must be multiple of 2 */
    if ((Src_pitch&1) || (Dst_pitch&1) || (Dst_height&1) || (Src_height&1) || (Src_width&1))
    {
        return 0;
    }

    _mInitialized = false;
    _mSrc_mheight = Src_height;
    _mRotation	=	nRotation;
    _mDisp.src_pitch = _mSrc_pitch  =	Src_pitch;
    _mDisp.dst_pitch = _mDst_pitch	=	Dst_pitch;
    _mDisp.src_width = _mSrc_width	=	Src_width;
    _mDisp.src_height = _mSrc_height =	Src_height;
    _mDisp.dst_width = _mDst_width	=	Dst_width;
    _mDisp.dst_height = _mDst_height =	Dst_height;

    /* Check support for rotation */
    if (_mRotation&0x1)
    {
        if (!(GetCapability()&CCSUPPORT_ROTATION))
        {
            return 0;
        }
    }

    _mIsFlip = false;
    if (_mRotation & 0x4)
    {
        _mIsFlip = true;
        _mRotation -= 4;
    }

    //For now, we only support the zoom ratio <=3
    if (_mRotation&0x1)
    {
        if (((Src_width*3) < Dst_height) || ((Src_height*3) < Dst_width))
        {
            return 0;
        }
    }
    else
    {
        if (((Src_width*3) < Dst_width) || ((Src_height*3) < Dst_height))
        {
            return 0;
        }
    }

    if (_mRowPix)
    {
        OSCL_ARRAY_DELETE(_mRowPix);
    }
    if (_mColPix)
    {
        OSCL_ARRAY_DELETE(_mColPix);
    }
    _mRowPix = NULL;
    _mColPix = NULL;

    if ((_mRotation&0x1) == 0)
    { /* no rotation */
        if ((_mDst_width != _mSrc_width) || (_mDst_height != _mSrc_height))
        { /* scaling */
            //calulate the Row
            int32 leavecode = 0;
            OSCL_TRY(leavecode,
                     _mRowPix = OSCL_ARRAY_NEW(uint8, _mSrc_width);
                     _mColPix = OSCL_ARRAY_NEW(uint8, _mSrc_height);
                    );
            OSCL_FIRST_CATCH_ANY(leavecode,
                                 if (_mRowPix)
        {
            OSCL_ARRAY_DELETE(_mRowPix);
            }
            if (_mColPix)
        {
            OSCL_ARRAY_DELETE(_mColPix);
            }
            _mRowPix = NULL;
            _mColPix = NULL;
            return 0;
                                );
            StretchLine(_mRowPix, _mSrc_width, _mDst_width);
            StretchLine(_mColPix, _mSrc_height, _mDst_height);
            _mIsZoom = true;
        }
        else
        {
            _mIsZoom = false;
        }
    }
    else
    { /* rotation,  */
        if ((_mDst_height != _mSrc_width) || (_mDst_width != _mSrc_height))
        { /* scaling */
            //calulate the Row
            int32 leavecode = 0;
            OSCL_TRY(leavecode,
                     _mRowPix = OSCL_ARRAY_NEW(uint8, _mSrc_height);
                     _mColPix = OSCL_ARRAY_NEW(uint8, _mSrc_width);
                    );
            OSCL_FIRST_CATCH_ANY(leavecode,
                                 if (_mRowPix)
        {
            OSCL_ARRAY_DELETE(_mRowPix);
            }
            if (_mColPix)
        {
            OSCL_ARRAY_DELETE(_mColPix);
            }
            _mRowPix = NULL;
            _mColPix = NULL;
            return 0;
                                );
            StretchLine(_mColPix, _mSrc_width, _mDst_height);
            StretchLine(_mRowPix, _mSrc_height, _mDst_width);
            _mIsZoom = true;
        }
        else
        {
            _mIsZoom = false;
        }
    }

    // Check support to scaling
    if (_mIsZoom)
    {
        if (!(GetCapability()&CCSUPPORT_SCALING))
        {
            return 0;
        }
    }

    _mInitialized = true;

    return 1;
}

void ColorConvertBase::StretchLine(uint8 *pLinePix, int32 iSrcLen, int32 iDstLen)
{
    // zoom ratio must be in range (1, 3]
    int32 e, i, j = 0, d, i2SrcLen, i2DstLen;
    bool bIsShrink = false;

    if (iSrcLen > iDstLen)
    {
        bIsShrink = true;
    }

    if (3*iSrcLen == iDstLen || 3*iDstLen == iSrcLen)
    {
        j = 3;
    }
    if (2*iSrcLen == iDstLen || 2*iDstLen == iSrcLen)
    {
        j = 2;
    }

    if (j)
    {
        if (bIsShrink)
        {
            oscl_memset(pLinePix, 0, iSrcLen);
            for (i = 0; i < iSrcLen; i += j)
            {
                pLinePix[i] = 1;
            }
        }
        else
        {
            oscl_memset(pLinePix, j, iSrcLen);
        }
        return;
    }

    //int32 xd1=0 int32 xd2=iDstLen, int32 xs1=0, int32 xs2=iSrcLen
    //int32 dx, dy2, e, d, dx2;
    //dx = xd2 - xd1;
    i2SrcLen = (iSrcLen - 1) << 1;//dy2 = (xs2 - xs1) << 1;
    e = i2SrcLen - (iDstLen - 1);//e = dy2 - dx;
    i2DstLen = (iDstLen - 1) << 1;//dx2 = dx << 1;
    i = 0;
    j = 0;
    for (d = 0; d < iDstLen /*dx*/; d++)
    {
        if (i <= iSrcLen - 1)
        {
            *(pLinePix + i) =  j;
        }
        if (e >= 0)
        {
            i++;
            e -= i2DstLen;
        }
        while (e >= 0)
        {
            if (i <= iSrcLen - 1)
            {
                *(pLinePix + i) =  j; /* zoom in case */
            }
            i++;
            e -= i2DstLen;
        }
        j++;
        e += i2SrcLen;
    }

    e = pLinePix[0];
    for (i = 1; i < iSrcLen; i++)
    {
        d = pLinePix[i];
        pLinePix[i] = (d - e); /* take difference between adjacent iRowPix[]. */
        e = d;
    }

    // add some check here to make sure that sum_{i=0...iSrcLen-1} pLinePix[i] = iDstLen
    e = 0;
    for (i = 0; i < iSrcLen; i++)
    {
        e += pLinePix[i];
    }

    if (e != iDstLen)
    {
        j = 0;
        while (e > iDstLen) /* sum greater than the destination */
        {
            while (pLinePix[j] == 0 && j < iSrcLen) /* find nonzero repetition pixel */
            {
                j++;
            }

            if (j < iSrcLen)
            {
                pLinePix[j]--;		/* remove pixel by one */
                e--;
                j++;				/* move to the next pixel */
            }
            else
            {
                j = 0;
            }
        }

        j = 0;
        while (e < iDstLen) /* sum less than the destination */
        {
            while (pLinePix[j] >= 3 && j < iSrcLen) /* find valid pixel */
            {
                j++;
            }

            if (j < iSrcLen)
            {
                pLinePix[j]++;	/* add pixel by one */
                e++;
                j++;		    /* move to the next pixel */
            }
            else
            {
                j = 0;
            }
        }
    }
}