/*

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

// MACROS

#ifdef _DEBUG

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

#else

#    define __IF_DEBUG(t)

#endif

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

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

// CVtImageIYUV::NewL( TInt aBitmapHandle )

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

EXPORT_C CVtImageIYUV* CVtImageIYUV::NewL( const TSize& aSize )

    {

    CVtImageIYUV* self = new ( ELeave ) CVtImageIYUV( aSize );

    CleanupStack::PushL( self );

    self->ConstructL( 0 );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CVtImageIYUV::NewL( const TSize& aSize, TDisplayMode aDisplayMode, 

//  const TDesC8& aImage )

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

EXPORT_C CVtImageIYUV* CVtImageIYUV::NewL( 

        const TSize& aSize, 

        const TDesC8& aImage )

    {

    CVtImageIYUV* self = new ( ELeave ) CVtImageIYUV( aSize );

    CleanupStack::PushL( self );

    self->ConstructL( &aImage );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CVtImageIYUV::NewL( const TSize& aSize, TDisplayMode aDisplayMode, 

//  TPtr8& aImage )

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

EXPORT_C CVtImageIYUV* CVtImageIYUV::NewL( 

        const TSize& aSize, 

        TPtr8& aImage )

    {

    CVtImageIYUV* self = new ( ELeave ) CVtImageIYUV( aSize );

    CleanupStack::PushL( self );

    self->ValidateSizeL( aSize );

    self->SetImageL( aImage ); // No constructor call!

    CleanupStack::Pop(); // self

    return self;

    }

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

// CVtImageIYUV::~CVtImageIYUV()

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

EXPORT_C CVtImageIYUV::~CVtImageIYUV()

    {

    delete iImage;

    }

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

// CVtImageIYUV::SetImageL( const TDesC8& aImage )

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

EXPORT_C void CVtImageIYUV::SetImageL( const TDesC8& aImage )

    {

    CheckDescriptorSizeL( aImage );

    if( !iImage )

        {

        ConstructL( &aImage );

        }

    else

        {

        *iImage = aImage;

        }

    }

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

// CVtImageIYUV::SetImageL( TPtr8& aImage )

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

EXPORT_C void CVtImageIYUV::SetImageL( TPtr8& aImage )

    {

    CheckDescriptorSizeL( aImage );

    delete iImage; iImage = 0;

    iPtrImage.Set( aImage );

    SetYUVPointers();

    }

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

// CVtImageIYUV::Image() const

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

EXPORT_C TPtrC8 CVtImageIYUV::Image() const

    {

    return iPtrImage;

    }

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

// CVtImageIYUV::Y() const

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

EXPORT_C TUint8* CVtImageIYUV::Y() const

    {

    return iY;

    }

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

// CVtImageIYUV::U() const

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

EXPORT_C TUint8* CVtImageIYUV::U() const

    {

    return iU;

    }

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

// CVtImageIYUV::V() const

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

EXPORT_C TUint8* CVtImageIYUV::V() const

    {

    return iV;

    }

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

// CVtImageIYUV::UVPlaneWidth() const

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

EXPORT_C TInt CVtImageIYUV::UVPlaneWidth() const

    {

    return iSize.iWidth / 2;

    }

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

// CVtImageIYUV::UVPlaneHeight() const

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

EXPORT_C TInt CVtImageIYUV::UVPlaneHeight() const

    {

    return iSize.iHeight / 2;

    }

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

// CVtImageIYUV::NeedHeapLock() const

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

TBool CVtImageIYUV::NeedHeapLock() const

    {

    return EFalse;

    }

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

// CVtImageIYUV::DisplayMode() const

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

CVtImage::TVtDisplayMode CVtImageIYUV::DisplayMode() const

    {

    return CVtImage::EVtColorIYUV;

    }

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

// CVtImageIYUV::Size() const

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

TSize CVtImageIYUV::Size() const

    {

    return iSize;

    }

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

// CVtImageIYUV::BytesPerRow() const

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

TInt CVtImageIYUV::BytesPerRow() const

    {

    return iSize.iWidth;

    }

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

// CVtImageIYUV::DataAddress() const

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

TUint32* CVtImageIYUV::DataAddress() const

    {

    return reinterpret_cast< TUint32* >( iY );

    }

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

// CVtImageIYUV::LineAddress( TInt aLine ) const

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

TUint32* CVtImageIYUV::LineAddress( TInt aLine ) const

    {

    if( aLine < 0 )

        {

        aLine = 0;

        }

    else if( aLine > Size().iHeight - 1 )

        {

        aLine = Size().iHeight - 1;

        }

    return reinterpret_cast< TUint32* >( 

        reinterpret_cast< TUint8* >( DataAddress() ) + BytesPerRow() * aLine );

    }

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

// CVtImageIYUV::ImageSize() const

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

TInt CVtImageIYUV::ImageSize() const

    {

    return UVPlaneWidth() * UVPlaneHeight() * 2 + BytesPerRow() * iSize.iHeight;

    }

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

// CVtImageIYUV::CVtImageIYUV( const TSize& aSize )

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

CVtImageIYUV::CVtImageIYUV( const TSize& aSize )

: CVtImage( CVtImage::EVtImageIYUV ), iSize( aSize ), iPtrImage( 0, 0 )

    {

    }

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

// CVtImageIYUV::ConstructL( const TDesC8* aImage )

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

void CVtImageIYUV::ConstructL( const TDesC8* aImage )

    {   

    ValidateSizeL( iSize );

    if( !aImage )

        {

        // empty image

        TInt size( ImageSize() );

        iImage = HBufC8::NewL( size );

        iImage->Des().SetLength( size );

        }

    else

        {

        // prefilled image

        CheckDescriptorSizeL( *aImage );

        iImage = aImage->AllocL();

        }

    // set ptr descriptor

    iPtrImage.Set( iImage->Des() );

    // set YUV pointers

    SetYUVPointers();

    }

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

// CVtImageIYUV::ValidateSizeL( const TSize& aSize )

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

void CVtImageIYUV::ValidateSizeL( const TSize& aSize )

    {

    if( ( aSize.iWidth & 1 ) || ( aSize.iHeight & 1 ) )

        {

        User::Leave( KErrNotSupported );

        }

    }

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

// CVtImageIYUV::CheckDescriptorSizeL( const TDesC8& aImage )

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

void CVtImageIYUV::CheckDescriptorSizeL( const TDesC8& aImage )

    {

    if( aImage.Size() != ImageSize() )

        {

        User::Leave( KErrArgument );

        }

    }

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

// CVtImageIYUV::SetYUVPointers()

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

void CVtImageIYUV::SetYUVPointers()

    {

    iY = const_cast< TUint8* >( iPtrImage.Ptr() );

    iU = iY + BytesPerRow() * iSize.iHeight;

    iV = iU + UVPlaneWidth() * UVPlaneHeight();

    }

// End of File