/*
 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "spatial_resampler.h"


namespace webrtc {

VPMSimpleSpatialResampler::VPMSimpleSpatialResampler()
:
_resamplingMode(kFastRescaling),
_targetWidth(0),
_targetHeight(0),
_interpolatorPtr(NULL)
{
}

VPMSimpleSpatialResampler::~VPMSimpleSpatialResampler()
{
    Release();
}

WebRtc_Word32
VPMSimpleSpatialResampler::Release()
{
    if (_interpolatorPtr != NULL)
    {
        delete _interpolatorPtr;
        _interpolatorPtr = NULL;
    }
    return VPM_OK;
}

WebRtc_Word32
VPMSimpleSpatialResampler::SetTargetFrameSize(WebRtc_UWord32 width,
                                              WebRtc_UWord32 height)
{
    if (_resamplingMode == kNoRescaling)
    {
        return VPM_OK;
    }

    if (width < 1 || height < 1)
    {
        return VPM_PARAMETER_ERROR;
    }

    _targetWidth = width;
    _targetHeight = height;

    return VPM_OK;
}

void
VPMSimpleSpatialResampler::SetInputFrameResampleMode(VideoFrameResampling
                                                     resamplingMode)
{
    _resamplingMode = resamplingMode;
}

void
VPMSimpleSpatialResampler::Reset()
{
    _resamplingMode = kFastRescaling;
    _targetWidth = 0;
    _targetHeight = 0;
}

WebRtc_Word32
VPMSimpleSpatialResampler::ResampleFrame(const VideoFrame& inFrame,
                                         VideoFrame& outFrame)
{
    WebRtc_Word32 ret;

    if (_resamplingMode == kNoRescaling)
    {
        return outFrame.CopyFrame(inFrame);
    }
    else if (_targetWidth < 1 || _targetHeight < 1)
    {
        return VPM_PARAMETER_ERROR;
    }

    // Check if re-sampling is needed
    if ((inFrame.Width() == _targetWidth) &&
        (inFrame.Height() == _targetHeight))
    {
        return outFrame.CopyFrame(inFrame);
    }
    if (_resamplingMode == kBiLinear)
    {
        return BiLinearInterpolation(inFrame, outFrame);
    }

    outFrame.SetTimeStamp(inFrame.TimeStamp());

    WebRtc_UWord32 currentLength = inFrame.Width() * inFrame.Height() * 3 / 2;
    if (_targetWidth > inFrame.Width() &&
        ( ExactMultiplier(inFrame.Width(), inFrame.Height())))
    {
        // The codec might want to pad this later... adding 8 pixels
        const WebRtc_UWord32 requiredSize = (_targetWidth + 8) *
                                            (_targetHeight + 8) * 3 / 2;
        outFrame.VerifyAndAllocate(requiredSize);
        return UpsampleFrame(inFrame, outFrame);
    }
    else
    {
        // 1 cut/pad
        // 2 scale factor 2X (in both cases if required)
        WebRtc_UWord32 croppedWidth = inFrame.Width();
        WebRtc_UWord32 croppedHeight = inFrame.Height();

        //Calculates cropped dimensions
        CropSize(inFrame.Width(), inFrame.Height(),
                 croppedWidth, croppedHeight);

        VideoFrame* targetFrame;
        outFrame.VerifyAndAllocate(croppedWidth * croppedHeight * 3 / 2);
        targetFrame = &outFrame;

        ConvertI420ToI420(inFrame.Buffer(), inFrame.Width(), inFrame.Height(),
                          targetFrame->Buffer(), croppedWidth, croppedHeight);
        targetFrame->SetWidth(croppedWidth);
        targetFrame->SetHeight(croppedHeight);
        //We have correct aspect ratio, sub-sample with a multiple of two to get
        //close to the target size
        ret = SubsampleMultipleOf2(*targetFrame);

        if (ret != VPM_OK)
        {
            return ret;
        }
    }

    return VPM_OK;
}

WebRtc_Word32
VPMSimpleSpatialResampler::UpsampleFrame(const VideoFrame& inFrame,
                                         VideoFrame& outFrame)
{
    outFrame.CopyFrame(inFrame);
    WebRtc_UWord32 currentLength = inFrame.Width() * inFrame.Height() * 3 / 2;

    float ratioWidth = _targetWidth / (float)inFrame.Width();
    float ratioHeight = _targetHeight / (float)inFrame.Height();

    WebRtc_UWord32 scaledWidth = 0;
    WebRtc_UWord32 scaledHeight = 0;
    bool scaled = true;

    if(ratioWidth > 1 || ratioHeight > 1)
    {
        // scale up
        if(ratioWidth <= 1.5 && ratioHeight <= 1.5)
        {
            // scale up 1.5
            currentLength = ScaleI420Up3_2(inFrame.Width(), inFrame.Height(),
                                           outFrame.Buffer(), outFrame.Size(),
                                           scaledWidth, scaledHeight);
        }
        else if(ratioWidth <= 2 && ratioHeight <= 2)
        {
            // scale up 2
            currentLength = ScaleI420Up2(inFrame.Width(), inFrame.Height(),
                                         outFrame.Buffer(), outFrame.Size(),
                                         scaledWidth, scaledHeight);
        }
        else if(ratioWidth <= 2.25 && ratioHeight <= 2.25)
        {
            // scale up 2.25
            currentLength = ScaleI420Up3_2(inFrame.Width(), inFrame.Height(),
                                           outFrame.Buffer(), outFrame.Size(),
                                           scaledWidth, scaledHeight);
            currentLength = ScaleI420Up3_2(scaledWidth, scaledHeight,
                                           outFrame.Buffer(), outFrame.Size(),
                                           scaledWidth, scaledHeight);
        }
        else if(ratioWidth <= 3 && ratioHeight <= 3)
        {
            // scale up 3
            currentLength = ScaleI420Up2(inFrame.Width(), inFrame.Height(),
                                         outFrame.Buffer(), outFrame.Size(),
                                         scaledWidth, scaledHeight);
            currentLength = ScaleI420Up3_2(scaledWidth, scaledHeight,
                                           outFrame.Buffer(), outFrame.Size(),
                                           scaledWidth, scaledHeight);
        }
        else if(ratioWidth <= 4 && ratioHeight <= 4)
        {
            // scale up 4
            currentLength = ScaleI420Up2(inFrame.Width(), inFrame.Height(),
                                         outFrame.Buffer(), outFrame.Size(),
                                         scaledWidth, scaledHeight);
            currentLength = ScaleI420Up2(scaledWidth, scaledHeight,
                                         outFrame.Buffer(), outFrame.Size(),
                                         scaledWidth, scaledHeight);
        }

        //TODO: what if ratioWidth/Height >= 8 ?

        if (scaledWidth <= 0 || scaledHeight <= 0)
        {
            return VPM_GENERAL_ERROR;
        }

        if ((static_cast<WebRtc_UWord32>(scaledWidth) > _targetWidth) ||
            (static_cast<WebRtc_UWord32>(scaledHeight) > _targetHeight))
        {
            currentLength = CutI420Frame(outFrame.Buffer(), scaledWidth,
                                         scaledHeight, _targetWidth,
                                         _targetHeight);
        }
    }
    else
    {
        return VPM_GENERAL_ERROR;
    }

    outFrame.SetWidth(_targetWidth);
    outFrame.SetHeight(_targetHeight);
    outFrame.SetLength(_targetWidth * _targetHeight * 3 / 2);

    return VPM_OK;
}

WebRtc_Word32
VPMSimpleSpatialResampler::CropSize(WebRtc_UWord32 width, WebRtc_UWord32 height,
                                    WebRtc_UWord32& croppedWidth,
                                    WebRtc_UWord32& croppedHeight) const
{
    // Crop the image to a width and height  which is a
    // multiple of two, so that we can do a simpler scaling.
    croppedWidth = _targetWidth;
    croppedHeight = _targetHeight;

    if (width >= 8 * _targetWidth && height >= 8 * _targetHeight)
    {
        croppedWidth = 8 * _targetWidth;
        croppedHeight = 8 * _targetHeight;
    }
    else if (width >= 4 * _targetWidth && height >= 4 * _targetHeight)
    {
        croppedWidth = 4 * _targetWidth;
        croppedHeight = 4 * _targetHeight;
    }
    else if (width >= 2 * _targetWidth && height >= 2 * _targetHeight)
    {
        croppedWidth = 2 * _targetWidth;
        croppedHeight = 2 * _targetHeight;
    }
    return VPM_OK;
}

WebRtc_Word32
VPMSimpleSpatialResampler::SubsampleMultipleOf2(VideoFrame& frame)
{
    WebRtc_UWord32 tempWidth = frame.Width();
    WebRtc_UWord32 tempHeight = frame.Height();

    while (tempWidth / _targetWidth >= 2 && tempHeight / _targetHeight >= 2)
    {
        ScaleI420FrameQuarter(tempWidth, tempHeight, frame.Buffer());
        tempWidth /= 2;
        tempHeight /= 2;
    }
    frame.SetWidth(tempWidth);
    frame.SetHeight(tempHeight);
    frame.SetLength(frame.Width() * frame.Height() * 3 / 2);

    return VPM_OK;
}


bool
VPMSimpleSpatialResampler::ExactMultiplier(WebRtc_UWord32 width,
                                           WebRtc_UWord32 height) const
{
    bool exactMultiplier = false;
    if (_targetWidth % width == 0 && _targetHeight % height == 0)
    {
        // we have a multiple, is it an even multiple?
        WebRtc_Word32 widthMultiple = _targetWidth / width;
        WebRtc_Word32 heightMultiple = _targetHeight / height;
        if (widthMultiple == 2 && heightMultiple == 2 ||
            widthMultiple == 4 && heightMultiple == 4 ||
            widthMultiple == 8 && heightMultiple == 8 ||
            widthMultiple == 1 && heightMultiple == 1)
        {
            exactMultiplier = true;
        }
    }
    return exactMultiplier;
}

WebRtc_Word32
VPMSimpleSpatialResampler::BiLinearInterpolation(const VideoFrame& inFrame,
                                                 VideoFrame& outFrame)
{
    WebRtc_Word32 retVal;

   if (_interpolatorPtr == NULL)
   {
       _interpolatorPtr = new interpolator();
   }
   // set bi-linear interpolator
   retVal =  _interpolatorPtr->Set(inFrame.Width(), inFrame.Height(),
                                   _targetWidth, _targetHeight,
                                   kI420, kI420, kBilinear );
    if (retVal < 0 )
    {
        return retVal;
    }

    // Verify size of output buffer
    outFrame.VerifyAndAllocate(_targetHeight * _targetWidth * 3 >> 1);
    WebRtc_UWord32 outSz = outFrame.Size();

    // interpolate frame
    retVal = _interpolatorPtr->Interpolate(inFrame.Buffer(),
                                           outFrame.Buffer(), outSz);

    assert(outSz <= outFrame.Size());

    // returns height
    if (retVal < 0)
    {
        return retVal;
    }

    // Set output frame parameters
    outFrame.SetHeight(_targetHeight);
    outFrame.SetWidth(_targetWidth);
    outFrame.SetLength(outSz);
    outFrame.SetTimeStamp(inFrame.TimeStamp());
    return VPM_OK;
}

WebRtc_UWord32
VPMSimpleSpatialResampler::TargetHeight()
{
    return _targetHeight;
}

WebRtc_UWord32
VPMSimpleSpatialResampler::TargetWidth()
{
    return _targetWidth;
}


} //namespace