/*

 * 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 <graphics/surface_hints.h>

#include <e32math.h>

#include <apgcli.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"

#include <bitdev.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;

_LIT(KMimeJpeg,"image/jpeg");

_LIT(KMimeJpg,"image/jpg");

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

// NewLC

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

CGlxHdmiSurfaceUpdater* CGlxHdmiSurfaceUpdater::NewL(RWindow* aWindow,

        const TDesC& aImageFile, const TDesC& aNextImageFile,

        CFbsBitmap* aFsBitmap, MGlxGenCallback* aCallBack,

        MGlxHDMIDecoderObserver& aDecoderObserver)

    {

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

    CGlxHdmiSurfaceUpdater* self = new (ELeave) CGlxHdmiSurfaceUpdater(

            aWindow, aCallBack, aDecoderObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aFsBitmap, aImageFile, aNextImageFile);

    CleanupStack::Pop(self);

    return self;

    }

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

// destructor 

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

CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater()

    {

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

    GLX_LOG_INFO(

            "CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater()-EHdmiDisconnected");

    TRAP_IGNORE(iDecoderObserver.HandleHDMIDecodingEventL(EHdmiDisconnected));

    ReleaseContent();

    if (iWindow)

        {

        iWindow->RemoveBackgroundSurface(ETrue);

        }

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

        {

        iTimer->Cancel();

        }

    delete iTimer;

    iFsSession.Close();

    if (iSurfManager)

        {

        GLX_LOG_INFO(

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

        if (iSurfSessionConnected)

            {

            iSurfUpdateSession.Close();

            }

        if (iSurfChunk)

            {

            iSurfChunk->Close();

            }

        delete iSurfChunk;

        GLX_LOG_INFO(

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

        iSurfManager->CloseSurface(iSurfId);

        GLX_LOG_INFO(

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

        iSurfManager->Close();

        delete iSurfManager;

        }

    }

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

// ReleaseContent 

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

void CGlxHdmiSurfaceUpdater::ReleaseContent()

    {

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

    if (iGlxDecoderAO)

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::ReleaseContent() -1");

        iGlxDecoderAO->Cancel();

        }

    if (iFsBitmap)

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::ReleaseContent() -2");

        delete iFsBitmap;

        iFsBitmap = NULL;

        }

    for (TInt i = 0; i <= 2; i++)

        {

        GLX_LOG_INFO1("CGlxHdmiSurfaceUpdater::ReleaseContent() -3, %d", i);

        delete iDecodedBitmap[i];

        iDecodedBitmap[i] = NULL;

        }

    GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::ReleaseContent() -4");

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

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::ReleaseContent() -5");

        iSurfBufferAO->Cancel();

        }

    if (iImageDecoder)

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::ReleaseContent() -6");

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    if (iSurfSessionConnected && iSurfManager)

        {

        GLX_LOG_INFO("CGlxHdmiSurfaceUpdater::ReleaseContent() -7");

        iSurfUpdateSession.CancelAllUpdateNotifications();

        }

    if (iImagePath)

        {

        delete iImagePath;

        iImagePath = NULL;

        }

    }

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

// CTor 

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

CGlxHdmiSurfaceUpdater::CGlxHdmiSurfaceUpdater(RWindow* aWindow,

        MGlxGenCallback* aCallBack, MGlxHDMIDecoderObserver& aDecoderObserver) :

    iWindow(aWindow), iCallBack(aCallBack), iShwFsThumbnail(ETrue),

            iIsNonJpeg(EFalse), iDecoderObserver(aDecoderObserver)

    {

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

    // Implement nothing here

    }

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

// ConstructL 

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

void CGlxHdmiSurfaceUpdater::ConstructL(CFbsBitmap* aFsBitmap,

        const TDesC& aImageFile, const TDesC& aNextImageFile)

    {

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

    // Initiate the HDMI by assigning the necessary values

    InitiateHdmiL(aFsBitmap, aImageFile, aNextImageFile);

    TInt error = iFsSession.Connect();

    GLX_LOG_INFO1(

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

            error);

    User::LeaveIfError(error);

    iShiftToCloning = EFalse;

    iDecodingCurrent = EFalse;

    iDecodingNext = EFalse;

    iDecodingNextFailed = EFalse;

    // Create the active object

    iGlxDecoderAO = CGlxHdmiDecoderAO::NewL(this);

    // Create the HDMI Decoder

    CreateImageDecoderL();

    // Create the Bitmap

    CreateBitmapL();

    // Create the surface and AO for updating the surface

    TRAP_IGNORE( CreateHdmiL());

    if (iSurfManager)

        {

        error = iSurfUpdateSession.Connect();

        GLX_LOG_INFO1(

                "CGlxHdmiSurfaceUpdater::ConstructL() Surface update Session Connect error = %d",

                error);

        User::LeaveIfError(error);

        iSurfSessionConnected = ETrue;

        if (!aNextImageFile.Length())

            {

            ShowFsThumbnailL();

            }

        else

            {

            // Modify the surface position with respect to the buffer size 

            ModifySurfacePostion();

            }

#ifdef _DEBUG

        iStartTime.HomeTime();

#endif

        //start decoding the image    

        iGlxDecoderAO->ConvertImageL(*iDecodedBitmap[EJpgDecodedBitmapIndex],

                iImageDecoder);

        iDecoderObserver.HandleHDMIDecodingEventL(EHdmiDecodingStarted);

        iDecodingCurrent = ETrue;

        }

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

    }

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

// UpdateNewImageL 

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

void CGlxHdmiSurfaceUpdater::UpdateNewImageL(const TDesC& aImageFile,

        const TDesC& aNextImageFile, CFbsBitmap* aFsBitmap)

    {

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

    if (!aImageFile.CompareC(*iImagePath) && !iDecodingCurrent

            && !iDecodingNext)

        {

        iNextImagePath = aNextImageFile.Alloc();

        GLX_LOG_INFO(

                "CGlxHdmiSurfaceUpdater::UpdateNewImageL() - Decoded Image is ready ");

        if (iDecodingNextFailed)

            {

            ShiftToCloningMode();

            iDecodingNextFailed = EFalse;

            }

        else if (iSurfManager)

            {

            iShwFsThumbnail = EFalse;

            if (iIsNonJpeg)

                {

                // if this is non jpeg image, make sure we scale the bitmap

                ScaleDecodedBitmapL( ENonJpgDecodedBitmapIndex);

                }

            // Modify the surface position with respect to the buffer size 

            ModifySurfacePostion();

            ProcessTvImage();

            iWindow->SetBackgroundSurface(iConfig, ETrue);

            iBitmapReady = ETrue;

            return;

            }

        }

    else

        {

        ReleaseContent();

		// Ongoing decoding is cancelled if any,reset the decoding flags. 

		iDecodingNext = EFalse;

		iDecodingCurrent = EFalse;

		}

    // Initiate the HDMI by assigning the necessary values

    InitiateHdmiL(aFsBitmap, aImageFile, aNextImageFile);

    //Cancel the zoom timers if any

    if (iTimer->IsActive())

        {

        GLX_LOG_INFO(

                "CGlxHdmiSurfaceUpdater::UpdateNewImageL() - Cancel Timer");

        iTimer->Cancel();

        }

    // Create the HDMI Decoder

    CreateImageDecoderL();

    // Create the Bitmap

    CreateBitmapL();

    if (iSurfManager)

        {

        // Create the surface and AO for updating the surface

        CreateHdmiL( EFalse);

        }

    else

        {

        TRAP_IGNORE( CreateHdmiL(ETrue));

        }

#ifdef _DEBUG

    iStartTime.HomeTime();

#endif

    if (iSurfManager)

        {

        // Show FS Thumbnail

        ShowFsThumbnailL();

        //start decoding the image

        iGlxDecoderAO->ConvertImageL(*iDecodedBitmap[EJpgDecodedBitmapIndex],

                iImageDecoder);

        iDecoderObserver.HandleHDMIDecodingEventL(EHdmiDecodingStarted);

        iDecodingCurrent = ETrue;

        }

    }

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

// InitiateHdmiL 

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

void CGlxHdmiSurfaceUpdater::InitiateHdmiL(CFbsBitmap* aFsBitmap,

        const TDesC& aImageFile, const TDesC& aNextImageFile)

    {

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

    iImagePath = aImageFile.Alloc();

    iNextImagePath = aNextImageFile.Alloc();

    iFsBitmap = new (ELeave) CFbsBitmap;

    iFsBitmap->Duplicate(aFsBitmap->Handle());

    iIsNonJpeg = EFalse;

    iTvScreenSize = iWindow->Size();

    iBitmapReady = EFalse;

    iLeftCornerForZoom.iX = 0;

    iLeftCornerForZoom.iY = 0;

    iZoom = ETrue;

    }

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

// 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(

                SurfBuffer0ReadyL, 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);

    //Need to set the surface Hint for the surface to indicate

    //that photos do not need overscan compensation and the image will

    //be displayed in 720p resolution. 

    //Refer error: HJVA-85DD25 for more info.

    RSurfaceManager::THintPair surfHint;

    TUid uid(KNullUid);

    uid.iUid = surfaceHints::KSurfaceContent;

    surfHint.Set(uid, surfaceHints::EStillImage, EFalse);

    RSurfaceManager::TSurfaceCreationAttributesBuf attributes;

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

    attributes().iSize = iTvScreenSize;

    attributes().iBuffers = 1;

    attributes().iStride = iTvScreenSize.iWidth * KMulFactorToCreateBitmap;

    attributes().iAlignment = KMulFactorToCreateBitmap;

    attributes().iContiguous = EFalse;

    attributes().iMappable = ETrue;

    attributes().iSurfaceHints = &surfHint;

    attributes().iHintCount = 1;

    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;

    }

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

// SurfBuffer0ReadyL 

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

TInt CGlxHdmiSurfaceUpdater::SurfBuffer0ReadyL(TAny* aObject)

    {

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

    CGlxHdmiSurfaceUpdater* self =

            reinterpret_cast<CGlxHdmiSurfaceUpdater*> (aObject);

    if (!self->iShwFsThumbnail)

        {

        self->iDecodingCurrent = EFalse;

        if (self->iNextImagePath->Length())

            {

            self->DecodeNextImageL();

            }

        else

            {

            self->iDecoderObserver.HandleHDMIDecodingEventL(

                    EHdmiDecodingCompleted);

            }

        }

    return ETrue;

    }

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

// Refresh 

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

void CGlxHdmiSurfaceUpdater::Refresh()

    {

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

    // copy the decoded bitmap on to the surface

    SwapBuffers();

    // refresh the window

    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()");

    TInt bitmapIndex = KErrNotFound;

    if (iShwFsThumbnail) // show FS thumbnail

        {

        bitmapIndex = EFSBitmapIndex;

        }

    else if (iIsNonJpeg && !iShwFsThumbnail) // this indicates it is non jpeg image and decoding finished

        {

        bitmapIndex = ENonJpgDecodedBitmapIndex;

        }

    else // if none of the above state means it is jpeg image and decoding finished

        {

        bitmapIndex = EJpgDecodedBitmapIndex;

        }

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

    iDecodedBitmap[bitmapIndex]->LockHeap();

    // Data stride

    TUint fs = iDecodedBitmap[bitmapIndex]->DataStride();

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

    TUint8* from = (TUint8*) iDecodedBitmap[bitmapIndex]->DataAddress();

    //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.

    TUint bytes = iDecodedBitmap[bitmapIndex]->SizeInPixels().iWidth

            * KMulFactorToCreateBitmap;