/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

* Resampling framework for YUV 4.2.0.

*

*/

// INCLUDES

#include "ctrscaler.h"

#include "ctrsettings.h"

#include "ctrhwsettings.h"

#include <e32math.h>

// Debug print macro

#ifdef _DEBUG

    #include <e32svr.h>

    #define PRINT(x) RDebug::Print x;

#else

    #define PRINT(x)

#endif

// An assertion macro wrapper to clean up the code a bit

#define VPASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CTRScaler"), KErrAbort))

// Macros for fixed point math

#define FP_BITS         15      // Number of bits to use for FP decimals

#define FP_FP(x)        (static_cast<TInt>((x) * 32768.0))

#define FP_ONE          (1 << FP_BITS)

#define FP_MUL(x,y)     (((x) * (y)) >> FP_BITS)

#define FP_FRAC(x)      ((x) & (FP_ONE - 1))

#define FP_INT(x)       ((x) >> FP_BITS)

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CTRScaler::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CTRScaler* CTRScaler::NewL()

    {

    // Standard two phase construction

    CTRScaler* self = new (ELeave) CTRScaler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CTRScaler::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CTRScaler::ConstructL()

    {

    }

// -----------------------------------------------------------------------------

// CTRScaler::CTRScaler

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

CTRScaler::CTRScaler()

    {

    // Scaler does not perform any operation before initializing

    iOperation = EOperationNone;

    iTrgBuffer = NULL;

    }

// ---------------------------------------------------------

// CTRScaler::~CTRScaler()

// Destructor

// ---------------------------------------------------------

//

CTRScaler::~CTRScaler()

    {

    }

// ---------------------------------------------------------

// CTRScaler::IsWideAspectRatio()

// Checks if aspect ratio is wide

// ---------------------------------------------------------

//

TBool CTRScaler::IsWideAspectRatio(TSize aSize)

    {

    return ( TReal(aSize.iWidth) / TReal(aSize.iHeight) ) > KTRWideThreshold;

    }

// -----------------------------------------------------------------------------

// CTRScaler::SetupScalerL

// Sets the scaler options (src buffer, dest buffer (could be the same as a src), src resolution, trg resolution)

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CTRScaler::SetScalerOptionsL(TPtr8& aSrc, TPtr8& aTrg, TSize& aSrcSize, TSize& aTrgSize )

    {

    PRINT((_L("CTRScaler::SetScalerOptionsL, src = (%d, %d), trg = (%d, %d)"), 

        aSrcSize.iWidth, aSrcSize.iHeight, aTrgSize.iWidth, aTrgSize.iHeight));

    // Check settings

    if ( ( !aSrc.Ptr() ) || ( !aTrg.Ptr() ) || 

       ( aSrcSize.iWidth == 0) || ( aSrcSize.iHeight == 0 )   || 

       ( aTrgSize.iWidth == 0) || ( aTrgSize.iHeight == 0 )   ||

       ( aSrc.MaxLength() < ( aSrcSize.iWidth * aSrcSize.iHeight * 3 / 2 ) ) || 

       ( aTrg.MaxLength() < ( aTrgSize.iWidth * aTrgSize.iHeight * 3 / 2 ) )

        )

        {

        PRINT((_L("CTRScaler::SetupScalerL(), Given options are not supported")))

        User::Leave(KErrNotSupported);

        }

    else

        {

        TReal remainder = 0.0;

        iTrgBuffer = NULL;

        // We don't support non-multiple output yet

        Math::Mod( remainder, static_cast<TReal>(aTrgSize.iWidth), 4.0 );

        if ( remainder == 0.0 )

            {

            Math::Mod( remainder, static_cast<TReal>(aTrgSize.iHeight), 4.0 );

            }

        if ( remainder != 0.0 )

            {

            PRINT((_L("CTRScaler::SetupScalerL(), Scaler does not support output resolution that is not multiple by 4")))

            User::Leave(KErrNotSupported);

            }

        TSize targetSize = aTrgSize;

        // check if black boxing is needed

        TBool srcWide = IsWideAspectRatio(aSrcSize);

        TBool dstWide = IsWideAspectRatio(aTrgSize);

        iBlackBoxing = TSize(0,0);

        TBool doScaling = ETrue;

        if (srcWide != dstWide)

            {

                TSize resolution(0,0);

                doScaling = GetIntermediateResolution(aSrcSize, aTrgSize, resolution, iBlackBoxing);

                // Set the whole image to black

                TUint yLength = aTrgSize.iWidth * aTrgSize.iHeight;

		        TUint uvLength = yLength >> 1;

                // Y

        		TInt data = 0;

        		TPtr8 tempPtr(0,0);        		

        		tempPtr.Set(const_cast<TUint8*>(aTrg.Ptr()), yLength, yLength);        		

        		tempPtr.Fill((TChar)data, yLength);

        		// U,V        		

        		data = 127;

        		tempPtr.Set(const_cast<TUint8*>(aTrg.Ptr()) + yLength, uvLength, uvLength); 

        		tempPtr.Fill((TChar)data, uvLength);                

                aTrgSize = resolution;

                PRINT((_L("CTRScaler::SetScalerOptionsL, blackboxing width = %d, height = %d"), iBlackBoxing.iWidth, iBlackBoxing.iHeight));

            }

        if ( !doScaling )

            {

            // No need to perform resampling operation, copy data with black boxing

            iOperation = EOperationCopyWithBB;

            }        

        else if ( (aTrgSize.iWidth == aSrcSize.iWidth) && (aTrgSize.iHeight == aSrcSize.iHeight) )

            {

            // No need to perform resampling operation, just copy data

            iOperation = EOperationCopy;

            }

        else if ( (aTrgSize.iWidth == aSrcSize.iWidth * 2) && (aTrgSize.iHeight == aSrcSize.iHeight * 2) )

            {

            // Resolution is doubled

            iOperation = EDoubleSize;

            }

        else if ( (aTrgSize.iWidth * 2 == aSrcSize.iWidth) && (aTrgSize.iHeight * 2 == aSrcSize.iHeight) )

            {

            // Resolution is halved

            iOperation = EHalveSize;

            }

        else if ( (aTrgSize.iWidth > aSrcSize.iWidth) && (aTrgSize.iHeight > aSrcSize.iHeight) )

            {

            // Resolution is increased

            iOperation = EUpSampling;

            }

        else if ( (aTrgSize.iWidth < aSrcSize.iWidth) && (aTrgSize.iHeight < aSrcSize.iHeight) )

            {

            // Resolution is decreased

            iOperation = EDownSampling;

            }

        else

            {

            // The image is streched ie. vertical resolution increases and horizontal decreases or vice versa

            iOperation = EUpDownSampling;

            }

        // Set given settings

        iSrc = const_cast<TUint8*>( aSrc.Ptr() );

        iTrg = const_cast<TUint8*>( aTrg.Ptr() );

        iSrcSize = aSrcSize;

        iTrgSize = aTrgSize;

        iSrcInit = iSrc;

        iTrgInit = iTrg;

        aTrgSize = targetSize;  // recover target size since it's a reference

        iTrgDataSize = aTrgSize.iWidth * aTrgSize.iHeight * 3 / 2;

        iTrgBuffer = &aTrg;

        }

    }

// ---------------------------------------------------------

// CTRScaler::GetIntermediateResolution()

// Calculates intermediate resolution for use with black boxing

// ---------------------------------------------------------

//

TBool CTRScaler::GetIntermediateResolution(TSize aSrcSize, TSize aTrgSize, 

                                           TSize& aTargetResolution, TSize& aBlackBoxing)

    {

    TSize resolution;

    TBool doScaling = ETrue;

    TBool srcWide = IsWideAspectRatio(aSrcSize);

    TBool dstWide = IsWideAspectRatio(aTrgSize);

    VPASSERT(srcWide != dstWide);

    if (dstWide)

        {

        // Pillarboxing

        // scale height to destination

        TReal factor = TReal(aTrgSize.iHeight) / TReal(aSrcSize.iHeight);

        resolution.iWidth = TInt( aSrcSize.iWidth * factor );

        if (resolution.iWidth & 0x1 > 0)

            resolution.iWidth++;

        resolution.iHeight = aTrgSize.iHeight;

        while ( (aTrgSize.iWidth - resolution.iWidth) % 4 != 0 )

        {

            resolution.iWidth += 2;

        }

        aBlackBoxing.iWidth = (aTrgSize.iWidth - resolution.iWidth) / 2;

        if ( factor == 1.0 )

            {

            // source and destination heights are the same, 

            // meaning source width is smaller and we don't

            // have to scale, just do pillarboxing

            doScaling = EFalse;

            // set target width

            resolution.iWidth = aTrgSize.iWidth;

            }

        }

    else

        {

        // Letterboxing

        // scale width to destination

        TReal factor = TReal(aTrgSize.iWidth) / TReal(aSrcSize.iWidth);                                

        resolution.iHeight = TInt( aSrcSize.iHeight * factor );                

        if (resolution.iHeight & 0x1 > 0)

            resolution.iHeight++;

        resolution.iWidth = aTrgSize.iWidth;

        while ( (aTrgSize.iHeight - resolution.iHeight) % 4 != 0 )

            {

            resolution.iHeight += 2;

            }                                    

        aBlackBoxing.iHeight = (aTrgSize.iHeight - resolution.iHeight) / 2;

        if ( factor == 1.0 )

            {

            // source and destination widths are the same, 

            // meaning source height is smaller and we don't

            // have to scale, just do letterboxing

            doScaling = EFalse;

            // set target height

            resolution.iHeight = aTrgSize.iHeight;

            }

        }

    PRINT((_L("CTRScaler::GetIntermediateResolution, resolution = (%d, %d), bb = (%d, %d)"), 

        resolution.iWidth, resolution.iHeight, aBlackBoxing.iWidth, aBlackBoxing.iHeight));

    aTargetResolution = resolution;

    return doScaling;

}

// -----------------------------------------------------------------------------

// CTRScaler::Scale()

// Scale the image

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CTRScaler::Scale()

    {

    TSize srcSizeUV = TSize( iSrcSize.iWidth / 2, iSrcSize.iHeight / 2 );

    TSize trgSizeUV = TSize( iTrgSize.iWidth / 2, iTrgSize.iHeight / 2 );

    TSize blackBoxingUV = TSize( iBlackBoxing.iWidth / 2, iBlackBoxing.iHeight / 2 );

    switch( iOperation )

        {

        case EOperationCopy:

            {

            // Src / Trg resolutions are the same, no needs to perform resampling

            if ( iSrc != iTrg )

                {

                    // Copy data, if different memory areas are specified

                    Mem::Copy( iTrg, iSrc, iTrgDataSize );            

                }

            else

                {

                // The same memory fragment is specified for the output; Keep it without changes;

                }

            }

            break;

        case EOperationCopyWithBB:

            {                

            // Copy with black boxing

            CopyWithBlackBoxing(iSrcSize, iTrgSize, iBlackBoxing);

            CopyWithBlackBoxing(srcSizeUV, trgSizeUV, blackBoxingUV);

            CopyWithBlackBoxing(srcSizeUV, trgSizeUV, blackBoxingUV);

            }

            break;

        case EDownSampling:

            {

            TInt error = KErrNoMemory;

            // If scaling to less than 50% of the source size

            if ( (iTrgSize.iWidth * 2 < iSrcSize.iWidth) && (iTrgSize.iHeight * 2 < iSrcSize.iHeight) )

                {

                // Try to do the scaling in two steps

                TRAP( error, DoHalveAndBilinearResampleL() );

                }

            // If the above failed or scaling to 51% or higher        

            if ( error != KErrNone )

                {

                // Resample the Y, U & V components

                ResampleBilinear(iSrcSize, iTrgSize, iBlackBoxing);

                ResampleBilinear(srcSizeUV, trgSizeUV, blackBoxingUV);

                ResampleBilinear(srcSizeUV, trgSizeUV, blackBoxingUV);

                }

            }

            break;

        case EUpSampling:

        case EUpDownSampling:

            {            

            // Resample the Y, U & V components

            ResampleBilinear(iSrcSize, iTrgSize, iBlackBoxing);

            ResampleBilinear(srcSizeUV, trgSizeUV, blackBoxingUV);

            ResampleBilinear(srcSizeUV, trgSizeUV, blackBoxingUV);

            }

            break;

        case EDoubleSize:

            {

            // Resample the Y, U & V components to double size

            ResampleDouble(iSrcSize, iTrgSize);

            ResampleDouble(srcSizeUV, trgSizeUV);

            ResampleDouble(srcSizeUV, trgSizeUV);

            }

            break;

        case EHalveSize:

            {

            // Resample the Y, U & V components to half size

            ResampleHalve(iSrcSize, iTrgSize, iBlackBoxing);

            ResampleHalve(srcSizeUV, trgSizeUV, blackBoxingUV);

            ResampleHalve(srcSizeUV, trgSizeUV, blackBoxingUV);

            }

            break;

        case EOperationNone:

            {

            PRINT((_L("CTRScaler::Scale(), Scaler was not initialized yet to perform any operation")))

            return;

            }

//            break;

        default:

            {

            }

        }

    // Recover source and target data pointers

    iSrc = iSrcInit;

    iTrg = iTrgInit;

    // Set Dsc length

    if (iTrgBuffer)

        {

        iTrgBuffer->SetLength(iTrgDataSize);

        }

    }

// -----------------------------------------------------------------------------

// CTRScaler::CopyWithBlackBoxing()

// Copies frame to target buffer applying black borders

// -----------------------------------------------------------------------------

//       

void CTRScaler::CopyWithBlackBoxing(TSize& aSrcSize, TSize& aTrgSize, TSize& aBlackBoxing)

{

    if (aBlackBoxing.iHeight != 0)

        {

        TInt copyLength = aSrcSize.iWidth * aSrcSize.iHeight;

        iTrg += aBlackBoxing.iHeight * aTrgSize.iWidth;

        Mem::Copy(iTrg, iSrc, copyLength);

        iTrg += copyLength;

        iTrg += aBlackBoxing.iHeight * aTrgSize.iWidth;                                        

        iSrc += copyLength;

        } 

    else if (aBlackBoxing.iWidth != 0)

        {

        TInt i;

        iTrg += aBlackBoxing.iWidth;

        for (i = 0; i < iTrgSize.iHeight; i++)

            {

            // copy one row

            Mem::Copy(iTrg, iSrc, aSrcSize.iWidth);

            iSrc += aSrcSize.iWidth;

            iTrg += aSrcSize.iWidth;

            iTrg += aBlackBoxing.iWidth * 2;

            }

        // subtract the width of one pillar

        iTrg -= aBlackBoxing.iWidth;

        }

}

// -----------------------------------------------------------------------------

// CTRScaler::DoHalveAndBilinearResampleL()

// First resamples an image to half size and then uses bilinear resample to

// scale it to requested size.

// -----------------------------------------------------------------------------

//    

void CTRScaler::DoHalveAndBilinearResampleL()

    {

    // Make sure the scale factor is correct

    VPASSERT( (iTrgSize.iWidth * 2 < iSrcSize.iWidth) &&

              (iTrgSize.iHeight * 2 < iSrcSize.iHeight) );

    TSize srcSizeUV = TSize( iSrcSize.iWidth / 2, iSrcSize.iHeight / 2 );

    TSize trgSizeUV = TSize( iTrgSize.iWidth / 2, iTrgSize.iHeight / 2 );

    TSize blackBoxingUV = TSize( iBlackBoxing.iWidth / 2, iBlackBoxing.iHeight / 2 );

    // Calculate the size for the temporary image where we store the intermediate result         

    TSize tempSize = TSize( iSrcSize.iWidth / 2, iSrcSize.iHeight / 2 );

    TSize tempSizeUV = TSize( tempSize.iWidth / 2, tempSize.iHeight / 2 );

    // Allocate memory for the temporary image

    TUint8* tempBuffer = (TUint8*) User::AllocLC(tempSize.iWidth * tempSize.iHeight * 3 / 2);

    // Set the temporary image as the target

    iTrg = tempBuffer;

    TSize zeroBlackBox = TSize(0,0);

    // Resample the Y, U & V components to half size

    ResampleHalve(iSrcSize, tempSize, zeroBlackBox);

    ResampleHalve(srcSizeUV, tempSizeUV, zeroBlackBox);

    ResampleHalve(srcSizeUV, tempSizeUV, zeroBlackBox);

    // Set the temporary image as the source and recover the original target

    iSrc = tempBuffer;

    iTrg = iTrgInit;

    // Resample the Y, U & V components

    ResampleBilinear(tempSize, iTrgSize, iBlackBoxing);

    ResampleBilinear(tempSizeUV, trgSizeUV, blackBoxingUV);

    ResampleBilinear(tempSizeUV, trgSizeUV, blackBoxingUV);

    // Release the temporary buffer

    CleanupStack::PopAndDestroy(tempBuffer);