/*

* Copyright (c) 2008-2009 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:    

*

*/

#include <graphics/surface.h>

#include <graphics/surfacemanager.h>

#include <graphics/surfaceupdateclient.h>

#include <e32math.h>

#include <imageconversion.h> 

#include <fbs.h>

#include <glxtracer.h>

#include <glxlog.h>

#include <glxgeneraluiutilities.h>

#include "glxactivecallback.h"

#include "glxhdmisurfaceupdater.h"

#include "glxactivedecoder.h"

const TInt KMulFactorToCreateBitmap = 4;

const TInt KZoomDelay = 10000;

//100 , is decide for 20 steps of zooming , with each step being 5 pixels.

const TInt KMaxZoomLimit = 100;

//evey time we zoom , there is a increase in the ht amd width by 10 pixels.

const TInt KSingleStepForZoom = 10;

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

// NewLC

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

CGlxHdmiSurfaceUpdater* CGlxHdmiSurfaceUpdater::NewL(RWindow* aWindow, const TDesC& aImageFile, 

                                                      MGlxGenCallback* aCallBack)

    {

    TRACER("CGlxHdmiSurfaceUpdater* CGlxHdmiSurfaceUpdater::NewL()");

    CleanupStack::PushL(self);

    CleanupStack::Pop(self);

    return self;

    }

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

// destructor 

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

CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater()

    {

    TRACER("CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater()");

    ReleaseContent();

    if(iWindow)

        {

        iWindow->RemoveBackgroundSurface(ETrue);

        }

	if(iTimer && iTimer->IsActive())	 	 	 // Check for a CPeriodic Instance

        {

        iTimer->Cancel();

        }

    delete iTimer;   

    if (iGlxDecoderAO)

        {

        delete iGlxDecoderAO;

        }        

    iGlxDecoderAO = NULL;

    iFsSession.Close();

    if (iSurfManager)

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater() - Close"); 

        if(iSurfSessionConnected)

            {

            iSurfUpdateSession.Close();

            }

        if (iSurfChunk)

            {

            iSurfChunk->Close();

            }            

        delete iSurfChunk;

        iSurfChunk = NULL;        

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater(). iSurfManager->CloseSurface()"); 

        iSurfManager->CloseSurface(iSurfId);

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater(). iSurfManager->Close()"); 

        iSurfManager->Close();

        delete iSurfManager;

        iSurfManager = NULL;       

        }

    }

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

// ReleaseContent 

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

void CGlxHdmiSurfaceUpdater::ReleaseContent()

    {

    TRACER("void CGlxHdmiSurfaceUpdater::ReleaseContent()"); 

    if ( iGlxDecoderAO )

        {

        iGlxDecoderAO->Cancel();

        }

        {

        }

    if(iSurfBufferAO && iSurfBufferAO->IsActive())

        {

		iSurfBufferAO->Cancel();

        }

    if ( iImageDecoder )

        {

        delete iImageDecoder;

        iImageDecoder = NULL;    

        }

    if (iSurfSessionConnected &&  iSurfManager)

        {

        iSurfUpdateSession.CancelAllUpdateNotifications();

        }

    }

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

// CTor 

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

    {

    TRACER("CGlxHdmiSurfaceUpdater::CGlxHdmiSurfaceUpdater()");

    // Implement nothing here

    }

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

// ConstructL 

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

    {

    TRACER("CGlxHdmiSurfaceUpdater::ConstructL()");

    TInt error = iFsSession.Connect ();

    GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::ConstructL() FsSession Connect error = %d", error);

    User::LeaveIfError(error);

    iShiftToCloning = EFalse;

    // Create the active object

    iGlxDecoderAO = CGlxHdmiDecoderAO::NewL(this);

    CreateBitmapL();

    TRAP_IGNORE(CreateHdmiL());

    if(iSurfManager)

#ifdef _DEBUG

#endif

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    }

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

// UpdateNewImageL 

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

    {

    TRACER("CGlxHdmiSurfaceUpdater::UpdateNewImageL()");

        {

        iTimer->Cancel();

        }

    CreateBitmapL();

    if(iSurfManager)

    else

#ifdef _DEBUG

    iStartTime.HomeTime();

#endif

    if(iSurfManager)

    }

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

// CreateHDMI 

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

void CGlxHdmiSurfaceUpdater::CreateHdmiL(TBool aCreateSurface)

    {

    TRACER("CGlxHdmiSurfaceUpdater::CreateHdmiL()");

    if (aCreateSurface)

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::CreateHdmiL() Create Surface");

        CreateSurfaceL();        

        }

    // Active objects for double buffered draw signalling

    if(!iSurfBufferAO)

        {

        iSurfBufferAO = new(ELeave) CGlxActiveCallBack(TCallBack(SurfBuffer0Ready, this),

                    CActive::EPriorityStandard-1);

        CActiveScheduler::Add(iSurfBufferAO);    

        }

    }

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

// CreateSurfaceL 

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

void CGlxHdmiSurfaceUpdater::CreateSurfaceL()

    {

    TRACER("CGlxHdmiSurfaceUpdater::CreateSurfaceL()");

    iSurfManager = new(ELeave) RSurfaceManager();

    TInt error = iSurfManager->Open();

    GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::CreateSurfaceL Open Surface manager error = %d", error);

    User::LeaveIfError(error);

    RSurfaceManager::TSurfaceCreationAttributesBuf attributes;

    attributes().iPixelFormat           = EUidPixelFormatARGB_8888;// EUidPixelFormatYUV_420Planar;

    attributes().iBuffers               = 1;

    attributes().iAlignment             = KMulFactorToCreateBitmap;

    attributes().iContiguous            = EFalse;

    attributes().iMappable              = ETrue;

    error = iSurfManager->CreateSurface(attributes, iSurfId);

    GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::CreateSurfaceL, Creating surface error : %d",error);

    if(error == KErrNoMemory)

    	{

    	GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::CreateSurfaceL(). iSurfManager->Close()"); 

		iSurfManager->Close();

		delete iSurfManager;

		iSurfManager = NULL;

    	if(iShiftToCloning == EFalse)

    		{

    		GlxGeneralUiUtilities::ShowErrorNoteL(error); // Show Low Memory Popup Once before shifting to Cloning Mode

    		iShiftToCloning = ETrue;

    		}

    	ShiftToCloningMode();	 	 	 	 	 	 	  // Shift from Posting Mode to Cloning Mode

    	}

    User::LeaveIfError(error);

    //Map the surface and stride the surface info

    MapSurfaceL();

    // Set the Configuration to the surface ID when creating a surface

    iConfig.SetSurfaceId(iSurfId);

    }

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

// MapSurfaceL 

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

void CGlxHdmiSurfaceUpdater::MapSurfaceL()

    {

    TRACER("CGlxHdmiSurfaceUpdater::MapSurfaceL()");

    //Create chunk to map it to the surface ID.

    iSurfChunk = new(ELeave) RChunk();

    User::LeaveIfNull(iSurfChunk);    

    TInt error = iSurfManager->MapSurface(iSurfId, *iSurfChunk);

    GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::MapSurfaceL(), MapSurface error : %d",error);

    User::LeaveIfError(error);

    // Get the info from the surfaceManager

    // and store pointers to the pixel data

    RSurfaceManager::TInfoBuf info;

    error = iSurfManager->SurfaceInfo(iSurfId, info);

    GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::MapSurfaceL(), SurfaceInfo error : %d",error);

    User::LeaveIfError(error);  

    iSurfaceStride = info().iStride;    

    TInt offset = 0;

    iSurfManager->GetBufferOffset( iSurfId, 0,offset);

    iSurfBuffer = iSurfChunk->Base()+offset;

    }

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

// SurfBuffer0Ready 

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

TInt CGlxHdmiSurfaceUpdater::SurfBuffer0Ready(TAny* /*aObject*/)

    {

    TRACER("CGlxHdmiSurfaceUpdater::SurfBuffer0Ready()");

    return ETrue;

    }

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

// Refresh 

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

void CGlxHdmiSurfaceUpdater::Refresh()

    {

    TRACER("CGlxHdmiSurfaceUpdater::Refresh()");

    // copy the decoded bitmap on to the surface

    iCallBack->DoGenCallback();       

    }

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

// SwapBuffers

// This is used to sawp the buffers shown and to be shown 

// After this is done, a refresh to the window should be done to refresh the TV

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

void CGlxHdmiSurfaceUpdater::SwapBuffers()

    {

    TRACER("CGlxHdmiSurfaceUpdater::SwapBuffers()"); 

    // Lock the heap so that subsequent call to dataaddress doesnt happen

    // Data stride

    //Bitmap address from where the data has to be copied.

    //surface chunk address to where the bitmap data has to be copied.

    TUint8* to = (TUint8*)iSurfBuffer;    

    // To buffer (32 bit colors)

    TUint ts = iSurfaceStride;

    //No of bytes to be copied on to the surface.

    GLX_LOG_INFO2("CGlxHdmiSurfaceUpdater::SwapBuffers() - decodeSize width = %d and height %d",

    // Copy the bitmap on to the surface.

        {

        Mem::Copy(to, from, bytes);        

        to += ts;        

        from += fs;        

        }            

    }

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

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

void CGlxHdmiSurfaceUpdater::CreateBitmapL()

    {

    TSize imageSize = iImageDecoder->FrameInfo().iOverallSizeInPixels;

    TReal32 scaleFactor = 0.0f;

            * imageSize.iWidth)

        {

                / (TReal32) imageSize.iHeight;

        }

    else

        {

                / (TReal32) imageSize.iWidth;

        }

    GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::StartImageDecodeL() - scaleFactor=%f",scaleFactor);

    //create the bitmap for the required size