/*

#include <graphics/surface.h>

#include <graphics/surfacemanager.h>

#include <graphics/surfaceupdateclient.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

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

    {

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

    CleanupStack::PushL(self);

    CleanupStack::Pop(self);

    return self;

    }

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

// destructor 

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

CGlxHdmiSurfaceUpdater::~CGlxHdmiSurfaceUpdater()

    {

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

    ReleaseContent();

        {

        iWindow->RemoveBackgroundSurface(ETrue);

        }

        {

        iTimer->Cancel();

        }

    if (iGlxDecoderAO)

        {

        delete iGlxDecoderAO;

    iGlxDecoderAO = NULL;

    iFsSession.Close();

    if (iSurfManager)

        {

            {

            iSurfUpdateSession.Close();

            }

        if (iSurfChunk)

            {

            iSurfChunk->Close();

        delete iSurfChunk;

        iSurfManager->CloseSurface(iSurfId);

        iSurfManager->Close();

        delete iSurfManager;

        }

    }

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

// ReleaseContent 

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

void CGlxHdmiSurfaceUpdater::ReleaseContent()

    {

        {

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

        iGlxDecoderAO->Cancel();

        }

    if (iFsBitmap)

        {

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

        delete iFsBitmap;

        iFsBitmap = NULL;

        }

        {

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

        delete iDecodedBitmap[i];

        }

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

        {

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

        }

        {

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

        delete iImageDecoder;

        }

        {

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

        iSurfUpdateSession.CancelAllUpdateNotifications();

        }

    if (iImagePath)

        {

        delete iImagePath;

        iImagePath = NULL;

        }

    }

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

// CTor 

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

CGlxHdmiSurfaceUpdater::CGlxHdmiSurfaceUpdater(RWindow* aWindow,

    {

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

    // Implement nothing here

    }

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

// ConstructL 

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

    {

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

    // Initiate the HDMI by assigning the necessary values

    User::LeaveIfError(error);

    iShiftToCloning = 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

        {

        error = iSurfUpdateSession.Connect();

        User::LeaveIfError(error);

        iSurfSessionConnected = ETrue;

#ifdef _DEBUG

        iStartTime.HomeTime();

#endif

        //start decoding the image    

        }

    }

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

// UpdateNewImageL 

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

    {

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

    // Initiate the HDMI by assigning the necessary values

    //Cancel the zoom timers if any

        {

        iTimer->Cancel();

        }

    // Create the HDMI Decoder

    CreateImageDecoderL();

    // Create the Bitmap

    CreateBitmapL();

        {

        // Create the surface and AO for updating the surface

        }

    else

        {

        }

#ifdef _DEBUG

    iStartTime.HomeTime();

#endif

        {

        // Show FS Thumbnail

        ShowFsThumbnailL();

        //start decoding the image

        }

    }

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

// InitiateHdmiL 

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

    {

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

    iImagePath = aImageFile.Alloc();

    iFsBitmap = new (ELeave) CFbsBitmap;

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

    iIsNonJpeg = EFalse;

    iTvScreenSize = iWindow->Size();

    iBitmapReady = EFalse;

    iLeftCornerForZoom.iY = 0;

    iZoom = ETrue;

    }

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

// CreateHDMI 

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

void CGlxHdmiSurfaceUpdater::CreateHdmiL(TBool aCreateSurface)

    {

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

    if (aCreateSurface)

        {

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

        }

    // Active objects for double buffered draw signalling

        {

        }

    }

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

// CreateSurfaceL 

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

void CGlxHdmiSurfaceUpdater::CreateSurfaceL()

    {

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

    TInt error = iSurfManager->Open();

    User::LeaveIfError(error);

    RSurfaceManager::TSurfaceCreationAttributesBuf attributes;

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

    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.

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

    User::LeaveIfError(error);

    // Get the info from the surfaceManager

    // and store pointers to the pixel data

    RSurfaceManager::TInfoBuf info;

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

    TInt offset = 0;

    }

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

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

    {

    return ETrue;

    }

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

// Refresh 

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

void CGlxHdmiSurfaceUpdater::Refresh()

    {

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

    // copy the decoded bitmap on to the surface

    // refresh the window

    }

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

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

    {

    TInt bitmapIndex = KErrNotFound;