/*

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

#include "cvtimage.h"

#include "CVtImageScalerMacros.h"

// MACROS

#ifdef _DEBUG

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

#else

#    define __IF_DEBUG(t)

#endif

// LOCAL CONSTANTS AND MACROS

const TUint32 KDecimalBits = 14;    // 18.14 pseudo real format,

                                    // this must be lower than 15!

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

// ======================= CVtImageScalerImplBilinear ==========================

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

// CVtImageScalerImplBilinear::Scale( TBool& aContinue )

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

TInt CVtImageScalerImplBilinear::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:

                Scale2x4K64K( 0xeee );  // 0000ggggbbbbrrrr ->

                break;                  // mask = %0000111011101110 = 0xeee

            case CVtImage::EVtColor64K:

                Scale2x4K64K( 0xf7de ); // bbbbbggggggrrrrr ->

                break;                  // mask = %1111011111011110 = 0xf7de

            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::EMaximumQuality ) );

                    result = error;

                    }

                else

                    {

                    result = KErrNotSupported;

                    }

            }

        }

    else

        {

        Initialize();

        switch( iSource->DisplayMode() )

            {

            case CVtImage::EVtColor4K:

                Scale4K();

                break;

            case CVtImage::EVtColor64K:

                Scale64K();

                break;

            case CVtImage::EVtColor16M:

                Scale16M();

                break;

            case CVtImage::EVtColor16MU:

                Scale16MU();

                break;

            case CVtImage::EVtColor16MA:

                Scale16MA();

                break;

            default:

                if ( iSource->Type() == CVtImage::EVtImageBitmap &&

                     iTarget->Type() == CVtImage::EVtImageBitmap )

                    {

                    TRAPD( error,

                        ScaleWithBitmapScalerL(

                            CBitmapScaler::EMaximumQuality ) );

                    result = error;

                    }

                else

                    {

                    result = KErrNotSupported;

                    }

            }

        }

    return result;

    }

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

// CVtImageScalerImplBilinear::ValidateSourceTargetL(

//  const CVtImage& aSource, CVtImage& aTarget )

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

void CVtImageScalerImplBilinear::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 );

                }

        }

    }

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

// CVtImageScalerImplBilinear::Initialize()

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

void CVtImageScalerImplBilinear::Initialize()

    {

    iU = ( 1 << KDecimalBits ) * iSource->Size().iWidth /

        iTarget->Size().iWidth;

    iV = ( 1 << KDecimalBits ) * iSource->Size().iHeight /

        iTarget->Size().iHeight;

    }

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

// CVtImageScalerImplBilinear::Scale4K()

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

void CVtImageScalerImplBilinear::Scale4K()

    {

    __IF_DEBUG( Print( _L( "ImageScaler [%d]: CVtImageScalerImplBilinear::Scale4K() >>" ), RThread().Id().operator TUint() ) );

    TInt width = iTarget->Size().iWidth;

    TInt height = iTarget->Size().iHeight;

    TInt mod_width = width - ( ( 1 << KDecimalBits ) / iU );

    TUint16* t = reinterpret_cast< TUint16* >( iTarget->DataAddress() );

    TUint32 sourceY( 0 );

    TUint32 b00( 0 );

    TUint32 g00( 0 );

    TUint32 r00( 0 );

    TUint32 b01( 0 );

    TUint32 g01( 0 );

    TUint32 r01( 0 );

    TUint32 b10( 0 );

    TUint32 g10( 0 );

    TUint32 r10( 0 );

    TUint32 b11( 0 );

    TUint32 g11( 0 );

    TUint32 r11( 0 );

    for( TInt y = 0; y < height; y++ )

        {

        TUint16* s = reinterpret_cast< TUint16* >(

            iSource->LineAddress( sourceY >> KDecimalBits ) );

        TUint16* snext = reinterpret_cast< TUint16* >(

            iSource->LineAddress( ( sourceY >> KDecimalBits ) + 1 ) );

        TUint32 invdv = sourceY & ( ( 1 << KDecimalBits ) - 1 ); // decimal part

        TUint32 dv = ( 1 << KDecimalBits ) - invdv; // 1 - decimal part

        TUint32 sourceX( 0 );

        TUint32 x0prev( TUint32( -1 ) );

        TInt x;

        for( x = 0; x < mod_width; x++ )

            {

            TUint32 x0 = sourceX >> KDecimalBits;

            // If the source is still same then we don't have to fetch

            // pixels from memory and unpack them again

            if( x0 != x0prev )

                {

                TUint32 p0 = *( s + x0 );

                b00 = UNPACK_4K_BLUE( p0 );

                g00 = UNPACK_4K_GREEN( p0 );

                r00 = UNPACK_4K_RED( p0 );

                p0 = *( s + x0 + 1 );

                b01 = UNPACK_4K_BLUE( p0 );

                g01 = UNPACK_4K_GREEN( p0 );

                r01 = UNPACK_4K_RED( p0 );

                p0 = *( snext + x0 );

                b10 = UNPACK_4K_BLUE( p0 );

                g10 = UNPACK_4K_GREEN( p0 );

                r10 = UNPACK_4K_RED( p0 );

                p0 = *( snext + x0 + 1 );

                b11 = UNPACK_4K_BLUE( p0 );

                g11 = UNPACK_4K_GREEN( p0 );

                r11 = UNPACK_4K_RED( p0 );

                x0prev = x0;

                }

            TUint32 invdu = sourceX & ( ( 1 << KDecimalBits ) - 1 ); // decimal

            TUint32 du = ( 1 << KDecimalBits ) - invdu; // 1 - decimal part

            TUint32 w1 = ( du * dv ) >> KDecimalBits;

            TUint32 w2 = ( invdu * dv ) >> KDecimalBits;

            TUint32 w3 = ( du * invdv ) >> KDecimalBits;

            TUint32 w4 = ( invdu * invdv ) >> KDecimalBits;

            TUint32 bres = w1 * b00 + w2 * b01 + w3 * b10 + w4 * b11;

            bres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 gres = w1 * g00 + w2 * g01 + w3 * g10 + w4 * g11;

            gres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 rres = w1 * r00 + w2 * r01 + w3 * r10 + w4 * r11;

            rres += ( 1 << ( KDecimalBits - 1 ) );

            *t = 0;

            *t++ = PACK_4K_BGR(

                bres >> KDecimalBits,

                gres >> KDecimalBits,

                rres >> KDecimalBits );

            sourceX += iU;

            }

        // last columns

        for( ; x < width; x++ )

            {

            TUint32 x0 = sourceX >> KDecimalBits;

            // If the source is still same then we don't have to fetch pixels

            // from memory and unpack them again

            if( x0 != x0prev )

                {

                TUint32 p0 = *( s + x0 );

                b01 = b00 = UNPACK_4K_BLUE( p0 );

                g01 = g00 = UNPACK_4K_GREEN( p0 );

                r01 = r00 = UNPACK_4K_RED( p0 );

                p0 = *( snext + x0 );

                b11 = b10 = UNPACK_4K_BLUE( p0 );

                g11 = g10 = UNPACK_4K_GREEN( p0 );

                r11 = r10 = UNPACK_4K_RED( p0 );

                x0prev = x0;

                }

            TUint32 invdu = sourceX & ( ( 1 << KDecimalBits ) - 1 ); // decimal

            TUint32 du = ( 1 << KDecimalBits ) - invdu; // 1 - decimal part

            TUint32 w1 = ( du * dv ) >> KDecimalBits;

            TUint32 w2 = ( invdu * dv ) >> KDecimalBits;

            TUint32 w3 = ( du * invdv ) >> KDecimalBits;

            TUint32 w4 = ( invdu * invdv ) >> KDecimalBits;

            TUint32 bres = w1 * b00 + w2 * b01 + w3 * b10 + w4 * b11;

            bres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 gres = w1 * g00 + w2 * g01 + w3 * g10 + w4 * g11;

            gres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 rres = w1 * r00 + w2 * r01 + w3 * r10 + w4 * r11;

            rres += ( 1 << ( KDecimalBits - 1 ) );

            *t++ = PACK_4K_BGR(

                bres >> KDecimalBits,

                gres >> KDecimalBits,

                rres >> KDecimalBits );

            sourceX += iU;

            }

        // if width is not even -> then we need to skip one additional byte

        if( width & 1 )

            {

            t++;

            }

        sourceY += iV;

        }

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

    }

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

// CVtImageScalerImplBilinear::Scale64K()

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

void CVtImageScalerImplBilinear::Scale64K()

    {

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

    TInt width = iTarget->Size().iWidth;

    TInt height = iTarget->Size().iHeight;

    TInt mod_width = width - ( ( 1 << KDecimalBits ) / iU );

    TUint16* t = reinterpret_cast< TUint16* >( iTarget->DataAddress() );

    TUint32 sourceY( 0 );

    TUint32 b00( 0 );

    TUint32 g00( 0 );

    TUint32 r00( 0 );

    TUint32 b01( 0 );

    TUint32 g01( 0 );

    TUint32 r01( 0 );

    TUint32 b10( 0 );

    TUint32 g10( 0 );

    TUint32 r10( 0 );

    TUint32 b11( 0 );

    TUint32 g11( 0 );

    TUint32 r11( 0 );

    for( TInt y = 0; y < height; y++ )

        {

        TUint16* s = reinterpret_cast< TUint16* >(

            iSource->LineAddress( sourceY >> KDecimalBits ) );

        TUint16* snext = reinterpret_cast< TUint16* >(

            iSource->LineAddress( ( sourceY >> KDecimalBits ) + 1 ) );

        TUint32 invdv = sourceY & ( ( 1 << KDecimalBits ) - 1 ); // decimal part

        TUint32 dv = ( 1 << KDecimalBits ) - invdv; // 1 - decimal part

        TUint32 sourceX( 0 );

        TUint32 x0prev( TUint32( -1 ) );

        TInt x;

        for( x = 0; x < mod_width; x++ )

            {

            TUint32 x0 = sourceX >> KDecimalBits;

            // If the source is still same then we don't have to fetch pixels

            // from memory and unpack them again

            if( x0 != x0prev )

                {

                TUint32 p0 = *( s + x0 );

                b00 = UNPACK_64K_BLUE( p0 );

                g00 = UNPACK_64K_GREEN( p0 );

                r00 = UNPACK_64K_RED( p0 );

                p0 = *( s + x0 + 1 );

                b01 = UNPACK_64K_BLUE( p0 );

                g01 = UNPACK_64K_GREEN( p0 );

                r01 = UNPACK_64K_RED( p0 );

                p0 = *( snext + x0 );

                b10 = UNPACK_64K_BLUE( p0 );

                g10 = UNPACK_64K_GREEN( p0 );

                r10 = UNPACK_64K_RED( p0 );

                p0 = *( snext + x0 + 1 );

                b11 = UNPACK_64K_BLUE( p0 );

                g11 = UNPACK_64K_GREEN( p0 );

                r11 = UNPACK_64K_RED( p0 );

                x0prev = x0;

                }

            TUint32 invdu = sourceX & ( ( 1 << KDecimalBits ) - 1 ); // decimal

            TUint32 du = ( 1 << KDecimalBits ) - invdu; // 1 - decimal part

            TUint32 w1 = ( du * dv ) >> KDecimalBits;

            TUint32 w2 = ( invdu * dv ) >> KDecimalBits;

            TUint32 w3 = ( du * invdv ) >> KDecimalBits;

            TUint32 w4 = ( invdu * invdv ) >> KDecimalBits;

            TUint32 bres = w1 * b00 + w2 * b01 + w3 * b10 + w4 * b11;

            bres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 gres = w1 * g00 + w2 * g01 + w3 * g10 + w4 * g11;

            gres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 rres = w1 * r00 + w2 * r01 + w3 * r10 + w4 * r11;

            rres += ( 1 << ( KDecimalBits - 1 ) );

            *t++ = PACK_64K_BGR(

                bres >> KDecimalBits,

                gres >> KDecimalBits,

                rres >> KDecimalBits );

            sourceX += iU;

            }

        // last columns

        for( ; x < width; x++ )

            {

            TUint32 x0 = sourceX >> KDecimalBits;

            // If the source is still same then we don't have to fetch pixels

            // from memory and unpack them again

            if( x0 != x0prev )

                {

                TUint32 p0 = *( s + x0 );

                b01 = b00 = UNPACK_64K_BLUE( p0 );

                g01 = g00 = UNPACK_64K_GREEN( p0 );

                r01 = r00 = UNPACK_64K_RED( p0 );

                p0 = *( snext + x0 );

                b11 = b10 = UNPACK_64K_BLUE( p0 );

                g11 = g10 = UNPACK_64K_GREEN( p0 );

                r11 = r10 = UNPACK_64K_RED( p0 );

                x0prev = x0;

                }

            TUint32 invdu = sourceX & ( ( 1 << KDecimalBits ) - 1 ); // decimal

            TUint32 du = ( 1 << KDecimalBits ) - invdu; // 1 - decimal part

            TUint32 w1 = ( du * dv ) >> KDecimalBits;

            TUint32 w2 = ( invdu * dv ) >> KDecimalBits;

            TUint32 w3 = ( du * invdv ) >> KDecimalBits;

            TUint32 w4 = ( invdu * invdv ) >> KDecimalBits;

            TUint32 bres = w1 * b00 + w2 * b01 + w3 * b10 + w4 * b11;

            bres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 gres = w1 * g00 + w2 * g01 + w3 * g10 + w4 * g11;

            gres += ( 1 << ( KDecimalBits - 1 ) );

            TUint32 rres = w1 * r00 + w2 * r01 + w3 * r10 + w4 * r11;

            rres += ( 1 << ( KDecimalBits - 1 ) );

            *t++ = PACK_64K_BGR(

                bres >> KDecimalBits,

                gres >> KDecimalBits,

                rres >> KDecimalBits );

            sourceX += iU;

            }

        // if width is not even -> then we need to skip one additional byte

        if( width & 1 )

            {

            t++;

            }

        sourceY += iV;

        }

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

    }

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

// CVtImageScalerImplBilinear::Scale16M()

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

void CVtImageScalerImplBilinear::Scale16M()

    {

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

    TInt width = iTarget->Size().iWidth;

    TInt height = iTarget->Size().iHeight;

    TInt mod_width = width - ( ( 1 << KDecimalBits ) / iU );

    TUint32 t_pitch = iTarget->BytesPerRow();