/*
* Copyright (c) 2003,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:  Camera Application Engine still image burst class
*
*/



// INCLUDE FILES

#include "CaeEngineImp.h"                   // For LOGTEXT
#include <fbs.h>                            // For CFbsBitmap
#include <hal.h>                            // For HAL

#include "CaeStillBurst.h"                  // Still image burst capturing class.
#include "CaeImageItem.h"                   // Still image item class.


// CONSTANTS
const TInt KCaeStillBurstImageQueueGranularity = 6;
const TInt KCaeMinImageHeapSize = 0; 

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


// -----------------------------------------------------------------------------
// CCaeStillBurst::NewL
// -----------------------------------------------------------------------------
//
CCaeStillBurst* CCaeStillBurst::NewL()
    {
    LOGTEXT( _L( "Cae: CCaeStillBurst::NewL() entering" ) );

    CCaeStillBurst* self = new( ELeave ) CCaeStillBurst;

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    LOGTEXT( _L( "Cae: CCaeStillBurst::NewL() returning" ) );

    return self;
    }

    
// -----------------------------------------------------------------------------
// CCaeStillBurst::~CCaeStillBurst
// Destroys image queue.
// -----------------------------------------------------------------------------
//
CCaeStillBurst::~CCaeStillBurst()
    {
    LOGTEXT( _L( "Cae: CCaeStillBurst::~CCaeStillBurst() entering" ) );

    ResetAndDestroyImages();

    if ( iImageHeap )
        {
        iImageHeap->Close();
        }

    delete iImageQueue;

    LOGTEXT( _L( "Cae: CCaeStillBurst::~CCaeStillBurst() returning" ) );
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::CCaeStillBurst
// -----------------------------------------------------------------------------
//
CCaeStillBurst::CCaeStillBurst() 
    {
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::ConstructL
// Allocates image queue.
// -----------------------------------------------------------------------------
//
void CCaeStillBurst::ConstructL()
    {
    LOGTEXT2( _L( "Cae: CCaeStillBurst::ConstructL() entering, min heap: %d" ), KCaeMinImageHeapSize );

    iImageQueue = new( ELeave ) RPointerArray<CCaeImageItem>( 
        KCaeStillBurstImageQueueGranularity );

    TInt maxMem;
    User::LeaveIfError( HAL::Get( HAL::EMemoryRAM, maxMem ) );
    #if (defined (__WINS__) || defined (__WINSCW__))
    maxMem /= 2; // Fix emulator -4 error
    #endif

    iImageHeap = User::ChunkHeap( NULL, KCaeMinImageHeapSize, maxMem );

    #ifdef _DEBUG
    if ( !iImageHeap )
        {
        LOGTEXT( _L( "Cae: CCaeStillBurst::ConstructL() Error: Cannot create iImageHeap !" ) );
        }
    #endif

    User::LeaveIfNull( iImageHeap );

    LOGTEXT( _L( "Cae: CCaeStillBurst::ConstructL() returning" ) );
    }



// -----------------------------------------------------------------------------
// CCaeStillBurst::SetLengthL
// -----------------------------------------------------------------------------
//
void CCaeStillBurst::SetLengthL( 
    TInt aLength )
    {
    LOGTEXT2( _L( "Cae: CCaeStillBurst::SetLengthL(): length: %d" ), aLength );

    // Leave if not supported.
    if ( aLength < 1 )
        {
        LOGTEXT( _L( "Cae: CCaeStillBurst::SetLengthL(): leaving KErrArgument" ));
        User::Leave( KErrArgument );
        }

    iDesiredLength = aLength;
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::Length
// -----------------------------------------------------------------------------
//
TInt CCaeStillBurst::Length() const
    {
    LOGTEXT2( _L( "Cae: CCaeStillBurst::Length(): length: %d" ), iDesiredLength );

    return iDesiredLength;
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::AppendImage
// Appends an image item object to image queue.
// -----------------------------------------------------------------------------
//
TInt CCaeStillBurst::AppendImage( 
    CFbsBitmap*  aBitmap, 
    HBufC8*      aImageData, 
    TInt         aError )
    {
    LOGTEXT2( _L( "Cae: CCaeStillBurst::AppendImage() entering: %d" ), aError );

    TInt result( KErrNone );

    CCaeImageItem* imageItem = new CCaeImageItem( *iImageHeap );
    if ( imageItem ) 
        {
        if (aImageData)
            {
            // Copy image data from HBufC8 to image heap
            imageItem->iImageData = iImageHeap->Alloc( aImageData->Size() );
            if ( imageItem->iImageData )
                {
                imageItem->iImageDataSize = aImageData->Size();
                Mem::Copy( imageItem->iImageData, aImageData->Ptr(), 
                    imageItem->iImageDataSize );
                }
            else
                {
                result = KErrNoMemory;
                }
            }
        if ( result == KErrNone ) 
            {
            imageItem->iBitmap = aBitmap;
            imageItem->iError  = aError;
            // Add image to the queue.
            result = iImageQueue->Append( imageItem );
            }
        if ( result == KErrNone ) 
            {
            iCountOfBurstAppends++;
            LOGTEXT2( _L( "Cae: CCaeStillBurst::AppendImage(): count of burst appends = %d" ), iCountOfBurstAppends );

            // Given aImageData can be deleted now as it has successfully 
            // been copied to imageItem->iImageData
            delete aImageData;
            }
        else
            {
            // Do not delete the bitmap if error, delete just imageItem 
            // which deletes also iImageData.
            imageItem->iBitmap = NULL;
            delete imageItem;
            imageItem = NULL;
            }
        }
    else 
        {
        result = KErrNoMemory;
        }

    LOGTEXT( _L( "Cae: CCaeStillBurst::AppendImage() returning" ) );

    return result;
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::CaptureCount
// -----------------------------------------------------------------------------
//
TInt CCaeStillBurst::CaptureCount() const
    {
    // Return the count of appends (captures) made.
    return iCountOfBurstAppends;
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::ImageCount
// -----------------------------------------------------------------------------
//
TInt CCaeStillBurst::ImageCount() const
    {
    // Return the count of image items.
    return iImageQueue->Count();
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::GetNextImage
// Fetches and deletes the next image from image queue.
// -----------------------------------------------------------------------------
//
TInt CCaeStillBurst::GetNextImage( 
    CFbsBitmap*&   aBitmap,     // output
    HBufC8*&       aImageData,  // output
    TInt&          aError )     // output
    {
    LOGTEXT2( _L( "Cae: CCaeStillBurst::GetNextImage() entering, %d images in queue" ), iImageQueue->Count() );

    TInt error( KErrNone );

    if ( iImageQueue->Count() > 0 )
        {

        if ( (*iImageQueue)[0]->iImageData )
            {
            // Copy image data from queue image item.
            aImageData = HBufC8::New( (*iImageQueue)[0]->iImageDataSize );
            if ( aImageData )
                {
                aImageData->Des().Copy( (TUint8*)(*iImageQueue)[0]->iImageData, 
                    (*iImageQueue)[0]->iImageDataSize );
                }
            else
                {
                error = KErrNoMemory;
                }
            }

        if ( error == KErrNone )
            {
            // Get bitmap pointer and image error value from the queue image item.
            aBitmap     = (*iImageQueue)[0]->iBitmap;
            aError      = (*iImageQueue)[0]->iError;

            #ifdef _DEBUG
            if ( aError )
                {
                LOGTEXT2( _L( "Cae: CCaeStillBurst::GetNextImage(): This image has error: %d" ), aError );
                }
            #endif

            // Do not delete the bitmap. Delete the image item which deletes iImageData also.
            (*iImageQueue)[0]->iBitmap = NULL;
            delete (*iImageQueue)[0];
            iImageQueue->Remove( 0 );
            }

        if ( ( iImageQueue->Count() == 0 ) || error ) 
            {
            // Give free memory to system from the top of heap.
            iImageHeap->Compress(); 
            LOGTEXT( _L( "Cae: CCaeStillBurst::GetNextImage(): last image fetched, compressed the heap" ) );
            MEM();
            }
        }
    else 
        {
        aBitmap = NULL;
        aImageData = NULL;
        error = KErrUnderflow;
        }

    LOGTEXT2( _L( "Cae: CCaeStillBurst::GetNextImage() returning: %d" ), error );

    return error;
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::IsBurstCaptured
// -----------------------------------------------------------------------------
//
TBool CCaeStillBurst::IsBurstCaptured() const
    {
    TBool isComplete( EFalse );
    if ( iCountOfBurstAppends >= iDesiredLength )
        {
        isComplete = ETrue;
        }    
    return isComplete;
    }


// -----------------------------------------------------------------------------
// CCaeStillBurst::ResetAndDestroyImages()
// Reset and destroy image queue.
// -----------------------------------------------------------------------------
//
void CCaeStillBurst::ResetAndDestroyImages()
    {
    LOGTEXT( _L( "Cae: CCaeStillBurst::ResetAndDestroyImages()" ) );

    if ( iImageQueue ) 
        {
        // Reset and destroy the image items from queue.
        iImageQueue->ResetAndDestroy();
        }
    if ( iImageHeap )
        {
        iImageHeap->Compress(); // Give free memory to system from the top of heap
        }
    iCountOfBurstAppends = 0;
    }


//  End of File