/*
* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:
*
* Description:  Image Transforms subsystem.
*
*/


// INCLUDE FILES

#include <e32svr.h>
#include <fbs.h>

#include "CVtImageScalerImplNearest.h"
#include "cvtimage.h"

// MACROS

#ifdef _DEBUG
#    define __IF_DEBUG(t) {RDebug::t;}
#else
#    define __IF_DEBUG(t)
#endif

// LOCAL CONSTANTS AND MACROS

const TUint32 KDecimalBits = 16;        // 16.16 pseudo real format

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

// ======================= CVtImageScalerImplNearest =======================

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale( TBool& aContinue )
// -----------------------------------------------------------------------------
TInt CVtImageScalerImplNearest::Scale( TBool& aContinue )
    {
    TInt result( KErrNone );

    aContinue = EFalse;

    // this implementation does not support different display modes for source
    // and target
    if( iSource->DisplayMode() != iTarget->DisplayMode() )
        {
        return KErrNotSupported;
        }

    // if sizes are same, just copy the data
    if( iSource->Size() == iTarget->Size() )
        {
        Mem::Copy(
            iTarget->DataAddress(),
            iSource->DataAddress(),
            iTarget->BytesPerRow() * iTarget->Size().iHeight );
        }
    else if( ( iSource->Size().iHeight * 2 == iTarget->Size().iHeight ) &&
        ( iSource->Size().iWidth * 2 == iTarget->Size().iWidth ) )
        {
        switch( iSource->DisplayMode() )
            {
            case CVtImage::EVtColor4K:
            case CVtImage::EVtColor64K:
                Scale2x4K64K();
                break;

            case CVtImage::EVtColor16M:
                Scale2x16M();
                break;

            case CVtImage::EVtColor16MU:
            case CVtImage::EVtColor16MA:
                Scale2x16MU16MA();
                break;

            default:
                if ( iSource->Type() == CVtImage::EVtImageBitmap &&
                     iTarget->Type() == CVtImage::EVtImageBitmap )
                    {
                    TRAPD( error,
                        ScaleWithBitmapScalerL(
                            CBitmapScaler::EMinimumQuality ) );
                    result = error;
                    }
                else
                    {
                    result = KErrNotSupported;
                    }
            }
        }
    else
        {
        Initialize();

        switch( iSource->DisplayMode() )
            {
            case CVtImage::EVtColor4K:
                Scale4K(
                    reinterpret_cast< const TUint16* >(
                        iSource->DataAddress() ),
                    iSource->BytesPerRow(),
                    reinterpret_cast< TUint16* >( iTarget->DataAddress() ),
                    iTarget->Size().iWidth,
                    iTarget->Size().iHeight,
                    iU,
                    iV );
                break;

            case CVtImage::EVtColor64K:
                Scale64K(
                    reinterpret_cast< const TUint16* >(
                        iSource->DataAddress() ),
                    iSource->BytesPerRow(),
                    reinterpret_cast< TUint16* >( iTarget->DataAddress() ),
                    iTarget->Size().iWidth,
                    iTarget->Size().iHeight,
                    iU,
                    iV );
                break;

            case CVtImage::EVtColor16M:
                Scale16M(
                    reinterpret_cast< const TUint8* >(
                        iSource->DataAddress() ),
                    iSource->BytesPerRow(),
                    reinterpret_cast< TUint8* >( iTarget->DataAddress() ),
                    iTarget->Size().iWidth,
                    iTarget->Size().iHeight,
                    iTarget->BytesPerRow(),
                    iU,
                    iV );
                break;

            case CVtImage::EVtColor16MU:
            case CVtImage::EVtColor16MA:
                Scale16MU16MA(
                    iSource->DataAddress(),
                    iSource->BytesPerRow(),
                    iTarget->DataAddress(),
                    iTarget->Size().iWidth,
                    iTarget->Size().iHeight,
                    iU,
                    iV );
                break;

            default:
                if ( iSource->Type() == CVtImage::EVtImageBitmap &&
                     iTarget->Type() == CVtImage::EVtImageBitmap )
                    {
                    TRAPD( error,
                        ScaleWithBitmapScalerL(
                            CBitmapScaler::EMinimumQuality ) );
                    result = error;
                    }
                else
                    {
                    result = KErrNotSupported;
                    }
            }
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::ValidateSourceTargetL(
//  const CVtImage& aSource, CVtImage& aTarget )
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::ValidateSourceTargetL(
    const CVtImage& aSource,
    CVtImage& aTarget )
    {
    if( aSource.DisplayMode() != aTarget.DisplayMode() )
        {
        User::Leave( KErrNotSupported );
        }

    switch( aSource.DisplayMode() )
        {
        case CVtImage::EVtColor4K:
        case CVtImage::EVtColor64K:
        case CVtImage::EVtColor16M:
        case CVtImage::EVtColor16MU:
        case CVtImage::EVtColor16MA:
            break;

        default:
            // Scaling for bitmaps is supported for other display modes
            if ( !( aSource.Type() == CVtImage::EVtImageBitmap &&
                 aTarget.Type() == CVtImage::EVtImageBitmap ) )
                {
                User::Leave( KErrNotSupported );
                }
        }
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Initialize()
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Initialize()
    {
    iU = ( 1 << KDecimalBits ) * iSource->Size().iWidth /
        iTarget->Size().iWidth + 1;
    iV = ( 1 << KDecimalBits ) * iSource->Size().iHeight /
        iTarget->Size().iHeight + 1;
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale4K(
//  const TUint16* aSrcPtr, TUint32 aSrcWidth, TUint16* aTrgPtr,
//  TUint32 aTrgWidth, TUint32 aTrgHeight, TUint32 aDx, TUint32 aDy )
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale4K(
    const TUint16* aSrcPtr,
    TUint32 aSrcWidth,
    TUint16* aTrgPtr,
    TUint32 aTrgWidth,
    TUint32 aTrgHeight,
    TUint32 aDx,
    TUint32 aDy )
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale4K() >>" ), RThread().Id().operator TUint() ) );
    // scaling 4K and 64K is equal procedure
    Scale64K( aSrcPtr, aSrcWidth, aTrgPtr, aTrgWidth, aTrgHeight, aDx, aDy );
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale4K() <<" ), RThread().Id().operator TUint() ) );
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale64K(
//  const TUint16* aSrcPtr, TUint32 aSrcPitch, TUint16* aTrgPtr,
//  TUint32 aTrgWidth, TUint32 aTrgHeight, TUint32 aDx, TUint32 aDy )
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale64K(
    const TUint16* aSrcPtr,
    TUint32 aSrcPitch,
    TUint16* aTrgPtr,
    TUint32 aTrgWidth,
    TUint32 aTrgHeight,
    TUint32 aDx,
    TUint32 aDy )
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale64K() >>" ), RThread().Id().operator TUint() ) );

    TUint32 sy( 0 );

    for( TUint32 y = 0; y < aTrgHeight; y++ )
        {
        const TUint16* srow =
            aSrcPtr + ( sy >> KDecimalBits ) * ( aSrcPitch >> 1 );

        TUint32 sx( 0 );

        TUint32 x( 0 );

        // loop unrolled with 8
        for( ; x < ( aTrgWidth >> 3 ); x++ )
            {
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            }

        // handle remaining columns
        for( x = 0; x < ( aTrgWidth & 7 ); x++ )
            {
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            }

        // if target width is not even aligning is needed
        if( aTrgWidth & 1 )
            {
            aTrgPtr++;
            }

        sy += aDy;
        }

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale64K() <<" ), RThread().Id().operator TUint() ) );
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale16M(
//  const TUint8* aSrcPtr, TUint32 aSrcPitch, TUint8* aTrgPtr,
//  TUint32 aTrgWidth, TUint32 aTrgHeight, TUint32 aTrgPitch, TUint32 aDx, TUint32 aDy )
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale16M(
    const TUint8* aSrcPtr,
    TUint32 aSrcPitch,
    TUint8* aTrgPtr,
    TUint32 aTrgWidth,
    TUint32 aTrgHeight,
    TUint32 aTrgPitch,
    TUint32 aDx,
    TUint32 aDy )
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale16M() >>" ), RThread().Id().operator TUint() ) );

    TUint32 sy( 0 );

    for( TUint32 y = 0; y < aTrgHeight; y++ )
        {
        const TUint8* s = aSrcPtr + ( sy >> KDecimalBits ) * aSrcPitch;

        TUint8* d = aTrgPtr;

        TUint32 sx( 0 );

        TUint32 x( 0 );

        for( ; x < aTrgWidth; x++ )
            {
            const TUint8* tempSrc = s + ( sx >> KDecimalBits ) * 3;
            *d++ = *tempSrc++;
            *d++ = *tempSrc++;
            *d++ = *tempSrc++;
            sx += aDx;
            }

        aTrgPtr += aTrgPitch;

        sy += aDy;
        }

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale16M() <<" ), RThread().Id().operator TUint() ) );
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale16MU16MA( const TUint32* aSrcPtr,
//  TUint32 aSrcPitch, TUint32* aTrgPtr, TUint32 aTrgWidth, TUint32 aTrgHeight,
//  TUint32 aDx, TUint32 aDy )
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale16MU16MA(
    const TUint32* aSrcPtr,
    TUint32 aSrcPitch,
    TUint32* aTrgPtr,
    TUint32 aTrgWidth,
    TUint32 aTrgHeight,
    TUint32 aDx,
    TUint32 aDy )
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale16MU16MA() >>" ), RThread().Id().operator TUint() ) );

    TUint32 sy( 0 );

    for( TUint32 y = 0; y < aTrgHeight; y++ )
        {
        const TUint32* srow =
            aSrcPtr + ( sy >> KDecimalBits ) * ( aSrcPitch >> 2 );

        TUint32 sx( 0 );

        TUint32 x( 0 );

        // loop unrolled with 8
        for( ; x < ( aTrgWidth >> 3 ); x++ )
            {
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            }

        // handle remaining columns
        for( x = 0; x < ( aTrgWidth & 7 ); x++ )
            {
            *aTrgPtr++ = srow[ sx >> KDecimalBits ];
            sx += aDx;
            }

        sy += aDy;
        }

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale16MU16MA() <<" ), RThread().Id().operator TUint() ) );
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale2x4K64K()
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale2x4K64K()
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale2x4K64K() >>" ), RThread().Id().operator TUint() ) );

    TInt sheight = iSource->Size().iHeight;
    TInt swidth = iSource->Size().iWidth;
    TInt spitch = iSource->BytesPerRow();
    TInt dpitch = iTarget->BytesPerRow();

    TUint16* s = reinterpret_cast< TUint16* >( iSource->DataAddress() );
    TUint32* d = iTarget->DataAddress();

    for( TInt y = 0; y < sheight; y++ )
        {
        TUint16* s2 = s;
        TUint32* d1 = d;
        for( TInt x = 0; x < swidth; x++ )
            {
            TUint32 p = *s2++;
            p |= ( p << 16 );
            *d1++ = p;
            }
        d = reinterpret_cast< TUint32* >(
            Mem::Copy( reinterpret_cast< TUint8* >( d ) + dpitch, d, dpitch ) );
        s = reinterpret_cast< TUint16* >(
            reinterpret_cast< TUint8* >( s ) + spitch );
        }

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale2x4K64K() <<" ), RThread().Id().operator TUint() ) );
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale2x16M()
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale2x16M()
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale2x16M() >>" ), RThread().Id().operator TUint() ) );

    TInt sheight = iSource->Size().iHeight;
    TInt swidth = iSource->Size().iWidth;
    TInt spitch = iSource->BytesPerRow();
    TInt dpitch = iTarget->BytesPerRow();

    TUint8* s = reinterpret_cast< TUint8* >( iSource->DataAddress() );
    TUint8* d = reinterpret_cast< TUint8* >( iTarget->DataAddress() );

    for( TInt y = 0; y < sheight; y++ )
        {
        TUint8* s2 = s;
        TUint8* d1 = d;
        for( TInt x = 0; x < swidth; x++ )
            {
            TUint8 g = *s2++;
            TUint8 b = *s2++;
            TUint8 r = *s2++;

            *d1++ = g;
            *d1++ = b;
            *d1++ = r;

            *d1++ = g;
            *d1++ = b;
            *d1++ = r;
            }
        d = Mem::Copy( d + dpitch, d, dpitch );
        s += spitch;
        }

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale2x16M() <<" ), RThread().Id().operator TUint() ) );
    }

// -----------------------------------------------------------------------------
// CVtImageScalerImplNearest::Scale2x16MU16MA()
// -----------------------------------------------------------------------------
void CVtImageScalerImplNearest::Scale2x16MU16MA()
    {
    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale2x16MU16MA() >>" ), RThread().Id().operator TUint() ) );

    TInt sheight = iSource->Size().iHeight;
    TInt swidth = iSource->Size().iWidth;
    TInt spitch = iSource->BytesPerRow();
    TInt dpitch = iTarget->BytesPerRow();

    TUint32* s = iSource->DataAddress();
    TUint32* d = iTarget->DataAddress();

    for( TInt y = 0; y < sheight; y++ )
        {
        TUint32* s2 = s;
        TUint32* d1 = d;
        for( TInt x = 0; x < swidth; x++ )
            {
            TUint32 p = *s2++;
            *d1++ = p;
            *d1++ = p;
            }
        d = reinterpret_cast< TUint32* >(
            Mem::Copy( reinterpret_cast< TUint8* >( d ) + dpitch, d, dpitch ) );
        s = reinterpret_cast< TUint32* >(
            reinterpret_cast< TUint8* >( s ) + spitch );
        }

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplNearest::Scale2x16MU16MA() <<" ), RThread().Id().operator TUint() ) );
    }

// End of File