/*

* 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 "CVtImageRotatorImplClockwise.h"

#include "cvtimage.h"

#include "CVtImageIYUV.h"

// MACROS

#ifdef _DEBUG

#    define __IF_DEBUG(t) {RDebug::t;}

#else

#    define __IF_DEBUG(t)

#endif

// LOCAL CONSTANTS AND MACROS

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

// ======================= CVtImageRotatorImplClockwise =======================

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

// CVtImageRotatorImplClockwise::CVtImageRotatorImplClockwise(

//  const CVtImageRotator::TRotationAngle& aAngle )

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

CVtImageRotatorImplClockwise::CVtImageRotatorImplClockwise(

    const CVtImageRotator::TRotationAngle& aAngle ) : CVtImageRotatorImpl( aAngle )

    {

    }

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

// CVtImageRotatorImplClockwise::Rotate( TBool& aContinue )

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

TInt CVtImageRotatorImplClockwise::Rotate( TBool& aContinue )

    {

    __IF_DEBUG( Print( _L( "ImageRotator [%d]: CVtImageRotatorImplClockwise::Rotate() >>" ), RThread().Id().operator TUint() ) );

    TInt result( KErrNone );

    aContinue = EFalse;

    DoRotate();

    __IF_DEBUG( Print( _L( "ImageRotator [%d]: CVtImageRotatorImplClockwise::Rotate() <<" ), RThread().Id().operator TUint() ) );

    return result;

    }

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

// CVtImageRotatorImplClockwise::ValidateSourceTargetL(

//  const CVtImage& aSource, CVtImage& aTarget )

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

void CVtImageRotatorImplClockwise::ValidateSourceTargetL(

    const CVtImage& aSource,

    CVtImage& aTarget )

    {

    // SourceWidth == TargetHeight && SourceHeight == TargetWidth

    if( ( aSource.Size().iWidth != aTarget.Size().iHeight ) ||

        ( aSource.Size().iHeight != aTarget.Size().iWidth ) )

        {

        User::Leave( KErrNotSupported );

        }

    // Displaymodes must match

    if( aSource.DisplayMode() != aTarget.DisplayMode() )

        {

        User::Leave( KErrNotSupported );

        }

    // Check that displaymode is one of the supported

    switch( aSource.DisplayMode() )

        {

        case CVtImage::EVtColor4K:

        case CVtImage::EVtColor64K:

        case CVtImage::EVtColor16M:

        case CVtImage::EVtColor16MU:

        case CVtImage::EVtColor16MA:

        case CVtImage::EVtColorIYUV:

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    }

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

// CVtImageRotatorImplClockwise::ValidateSourceTargetL(

//  const CVtImage& aSource, CVtImage& aTarget )

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

TBool CVtImageRotatorImplClockwise::SupportsRotationAngle(

    const CVtImageRotator::TRotationAngle& aAngle )

    {

    TBool result( EFalse );

    if( ( aAngle == CVtImageRotator::E90DegreesClockwise ) ||

        ( aAngle == CVtImageRotator::E270DegreesClockwise ) )

        {

        result = ETrue;

        }

    return result;

    }

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

// void CVtImageRotatorImplClockwise::DoRotate()

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

void CVtImageRotatorImplClockwise::DoRotate()

    {

    TInt bytesPerRow( iSource->BytesPerRow() );

    TInt height( iSource->Size().iHeight );

    TInt width( iSource->Size().iWidth );

    TInt targetWidth( iTarget->Size().iWidth );

    TInt targetHeight( iTarget->Size().iHeight );

    TInt targetBytesPerRow( iTarget->BytesPerRow() );

    switch( iSource->DisplayMode() )

        {

        // DisplayMode: 4K and 64K

        case CVtImage::EVtColor4K:

        case CVtImage::EVtColor64K:

            {

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

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

            TInt offsetPerRow( -2 );

            if( iAngle == CVtImageRotator::E90DegreesClockwise )

                {

                d += targetBytesPerRow - 2;

                if( targetWidth & 1 )

                    {

                    d -= 2;

                    }

                }

            else

                {

                d += targetBytesPerRow * ( targetHeight - 1 );

                targetBytesPerRow = -targetBytesPerRow;

                offsetPerRow = 2;

                }

            targetBytesPerRow /= 2; // in loop we need 16-bit precalculated

            for( TInt y = height - 1; y >= 0; y-- )

                {

                register const TUint16* tempS = reinterpret_cast< const TUint16* >( s );

                register TUint16* tempD = reinterpret_cast< TUint16* >( d );

                for( register TInt x = width - 1; x >= 0; x-- )

                    {

                    *tempD = *tempS++;

                    tempD += targetBytesPerRow;

                    }

                s += bytesPerRow;

                d += offsetPerRow;

                }

            }

            break;

        // DisplayMode: 16M

        case CVtImage::EVtColor16M:

            {

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

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

            TInt offsetPerRow( -3 );

            if( iAngle == CVtImageRotator::E90DegreesClockwise )

                {

                d += targetWidth * 3 - 3;

                }

            else

                {

                d += targetBytesPerRow * ( targetHeight - 1 );

                targetBytesPerRow = -targetBytesPerRow;

                offsetPerRow = 3;

                }

            for( TInt y = height - 1; y >= 0; y-- )

                {

                register const TUint8* tempS = s;

                register TUint8* tempD = d;

                for( register TInt x = width - 1; x >= 0; x-- )

                    {

                    tempD[ 0 ] = *tempS++;

                    tempD[ 1 ] = *tempS++;

                    tempD[ 2 ] = *tempS++;

                    tempD += targetBytesPerRow;

                    }

                s += bytesPerRow;

                d += offsetPerRow;

                }

            }

            break;

        // DisplayMode: 16MU and 16MA

        case CVtImage::EVtColor16MU:

        case CVtImage::EVtColor16MA:

            {

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

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

            TInt offsetPerRow( -4 );

            if( iAngle == CVtImageRotator::E90DegreesClockwise )

                {

                d += targetBytesPerRow - 4;

                }

            else

                {

                d += targetBytesPerRow * ( targetHeight - 1 );

                targetBytesPerRow = -targetBytesPerRow;

                offsetPerRow = 4;

                }

            targetBytesPerRow /= 4; // in loop we need 32-bit precalculated

            for( TInt y = height - 1; y >= 0; y-- )

                {

                register const TUint32* tempS = reinterpret_cast< const TUint32* >( s );

                register TUint32* tempD = reinterpret_cast< TUint32* >( d );

                for( register TInt x = width - 1; x >= 0; x-- )

                    {

                    *tempD = *tempS++;

                    tempD += targetBytesPerRow;

                    }

                s += bytesPerRow;

                d += offsetPerRow;

                }

            }

            break;

        // DisplayMode: IYUV

        case CVtImage::EVtColorIYUV:

            {

            const CVtImageIYUV* src = reinterpret_cast< const CVtImageIYUV* >( iSource );

            CVtImageIYUV* trg = reinterpret_cast< CVtImageIYUV* >( iTarget );

            RotatePlane

                (

                src->Y(),

                trg->Y(),

                width,

                height,

                bytesPerRow,

                targetHeight,

                targetBytesPerRow

                );

            RotatePlane

                (

                src->U(),

                trg->U(),

                src->UVPlaneWidth(),

                src->UVPlaneHeight(),

                src->UVPlaneWidth(),

                trg->UVPlaneHeight(),

                trg->UVPlaneWidth()

                );

            RotatePlane

                (

                src->V(),

                trg->V(),

                src->UVPlaneWidth(),

                src->UVPlaneHeight(),

                src->UVPlaneWidth(),

                trg->UVPlaneHeight(),

                trg->UVPlaneWidth()

                );

            }

            break;

        default:

            break;

        }

    }

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

// CVtImageRotatorImplClockwise::RotatePlane(

//    const TUint8* aSource,

//    TUint8* aTarget,

//    TInt aSourceWidth,

//    TInt aSourceHeight,

//    TInt aSourceBytesPerRow,

//    TInt aTargetHeight,

//    TInt aTargetBytesPerRow )

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

void CVtImageRotatorImplClockwise::RotatePlane(

    const TUint8* aSource,

    TUint8* aTarget,

    TInt aSourceWidth,

    TInt aSourceHeight,

    TInt aSourceBytesPerRow,

    TInt aTargetHeight,

    TInt aTargetBytesPerRow )

    {

    TInt offsetPerRow( -1 );

    if( iAngle == CVtImageRotator::E90DegreesClockwise )

        {

        aTarget += aTargetBytesPerRow - 1;

        }

    else

        {

        aTarget += aTargetBytesPerRow * ( aTargetHeight - 1 );

        aTargetBytesPerRow = -aTargetBytesPerRow;

        offsetPerRow = -offsetPerRow;

        }

    for( TInt y = aSourceHeight - 1; y >= 0; y-- )

        {

        register const TUint8* tempS = aSource;

        register TUint8* tempD = aTarget;

        for( register TInt x = aSourceWidth - 1; x >= 0; x-- )

            {

            *tempD = *tempS++;

            tempD += aTargetBytesPerRow;

            }

        aSource += aSourceBytesPerRow;

        aTarget += offsetPerRow;

        }

    }

// End of File