/*

* Copyright (c) 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 "SGGifAnimator.h"

#include <s32file.h>

#include <fbs.h>

#include <gdi.h>

#include <imageconversion.h>

#include <aknenv.h>

#include <AknGlobalProgressDialog.h>

#include <AknQueryDialog.h> 

#include <avkon.rsg>

_LIT(KSavingText, "Saving");

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

TInt CGifAnimator::CreateGifAnimation(const TDesC& aFileName, TSize aDimensions, CVideoFrameArray* aVideoFrameArray)

    {

	CGifAnimator* self = new(ELeave) CGifAnimator;

	CleanupStack::PushL(self);

	TRAPD(err, self->StartL(aFileName, aDimensions, aVideoFrameArray));

	CleanupStack::PopAndDestroy();

	return err;

    }

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

CGifAnimator::CGifAnimator() : CActive(EPriorityStandard)

    {

    }

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

void CGifAnimator::StartL(const TDesC& aFileName, const TSize& aDimensions, CVideoFrameArray* aVideoFrameArray)

    {

    __ASSERT_ALWAYS(aFileName.Length() > 0, User::Panic(_L("GifAnim"), 100));

    __ASSERT_ALWAYS(aDimensions.iHeight > 0, User::Panic(_L("GifAnim"), 101));

    __ASSERT_ALWAYS(aDimensions.iWidth > 0, User::Panic(_L("GifAnim"), 102));

    __ASSERT_ALWAYS(aVideoFrameArray != NULL, User::Panic(_L("GifAnim"), 103));

    CActiveScheduler::Add(this);

    // show a progress dialog

    iSavingProgressDialog = CSavingProgressDialog::NewL(this);

    iSavingProgressDialog->StartDisplayingL(KSavingText, aVideoFrameArray->Count()-1);

    // open the file for writing

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iOutFile.Replace(iFs, aFileName, EFileWrite));

    // write header

    WriteHeaderL(aDimensions);

    // process each frame of the animation

    for (TInt i=0; i<aVideoFrameArray->Count(); i++)

        {

        // write headers and raster block

        TVideoFrame frame = aVideoFrameArray->At(i);

        WriteGraphicControlL(frame);

        CFbsBitmap* bitmap = GetBitmapLC(frame, aDimensions);

        WriteImageDescriptorL(frame);

        WriteRasterDataL(bitmap);

        CleanupStack::PopAndDestroy(); //bitmap

        // update the progress bar

        iSavingProgressDialog->IncreaseProgressValueWithOne();

        }

    // write footer and finish

    WriteFooterL();

    FinishL();

    // remove the progress dialog from the screen

    iSavingProgressDialog->ProcessFinished();

    }    

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

CGifAnimator::~CGifAnimator()

    {

    Cancel();

    if (iImageEncoder)

        delete iImageEncoder;

    if (iGIFImageData)

        delete iGIFImageData;

    delete iSavingProgressDialog;

    }

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

void CGifAnimator::WriteHeaderL(const TSize& aDimensions)

    {

    WriteInt8L('G');

    WriteInt8L('I');

    WriteInt8L('F');

    WriteInt8L('8');

    WriteInt8L('9');

    WriteInt8L('a');

    WriteInt16L(aDimensions.iWidth);  // width of animation

    WriteInt16L(aDimensions.iHeight); // height of animation

    // logical screen descriptor

    TUint8 packedFlags = 0;

	packedFlags |= 8 - 1; // size of colour table is number of bits in each color table minus one (bits 0-2)

	packedFlags |= (8 - 1) << 4; // colour resolution ie maximum size of the original colour palette (bits 4-6)

	packedFlags |= 0x80; // use global colour table (bit 7)

    WriteInt8L(packedFlags);

    WriteInt8L(TRANSPARENCY_INDEX); // background color index

    WriteInt8L(0); // pixel aspect ratio, 0=not used

    // write the Symbian default palette since that's what is used

    CPalette* palette = CPalette::NewDefaultL(EColor256);

    CleanupStack::PushL(palette);

    for (TInt i=0; i<palette->Entries(); i++)

        {

        TRgb entry = palette->GetEntry(i);

        WriteInt8L(entry.Red());

        WriteInt8L(entry.Green());

        WriteInt8L(entry.Blue());

        }

    CleanupStack::PopAndDestroy(); //palette

    }

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

void CGifAnimator::WriteGraphicControlL(const TVideoFrame& aFrame)

    {

    TInt packedFlags(0);

    // enable transparency if needed

    if (aFrame.iEnableTransparency)

        packedFlags |= 0x01; 

    // set disposal method:

    // 0 = disposal method not specified, 1 = do not dispose of graphic,

    // 2 = overwrite graphic with background color, 3 = overwrite graphic with previous graphic

    TInt disposalMethod = 1;

    packedFlags |= ((disposalMethod << 2) & 0x1c);

    WriteInt8L(0x21); // GIF extension

    WriteInt8L(0xf9); // GIF graphic control block

    WriteInt8L(0x04); // block size

    WriteInt8L(packedFlags); // packed

    WriteInt16L(aFrame.iDelay); // delay

    WriteInt8L(TRANSPARENCY_INDEX); // transparent color index

    WriteInt8L(0); // block terminator, always 0

    }

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

void CGifAnimator::WriteImageDescriptorL(const TVideoFrame& aFrame)

    {

    WriteInt8L(0x2c); // GIF image descriptor

    WriteInt16L(aFrame.iXPos);

    WriteInt16L(aFrame.iYPos);

    WriteInt16L(aFrame.iWidth);

    WriteInt16L(aFrame.iHeight);

    WriteInt8L(0); // packed flags, none specified in this case

    }

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

CFbsBitmap* CGifAnimator::GetBitmapLC(TVideoFrame& aFrame, const TSize& aDimensions)

    {

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    // read the bitmap from the temporary file

    RFile bitmapFile;

    User::LeaveIfError( bitmapFile.Open(iFs, aFrame.iFileStorePath, EFileRead) );

    RFileReadStream readStream(bitmapFile);

    bitmap->InternalizeL(readStream);

    readStream.Close();

    bitmapFile.Close();

    // delete the temporary file since it's not needed anymore

    iFs.Delete(aFrame.iFileStorePath);

    // resize the bitmap to match the video dimensions if it is a full screen one

    if (aFrame.iFillsWholeScreen && (aFrame.iWidth != aDimensions.iWidth || aFrame.iHeight != aDimensions.iHeight))

        {

        if (bitmap->Resize(aDimensions) == KErrNone)

            {

            // also update dimensions of this frame to match the dimensions of the video            

            aFrame.iWidth = aDimensions.iWidth;

            aFrame.iHeight = aDimensions.iHeight;

            }

        }

    return bitmap;

    }

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

void CGifAnimator::WriteRasterDataL(CFbsBitmap* aBitmap)

    {

    // reset the encoder

    if (iImageEncoder)

        {

	    delete iImageEncoder;

        iImageEncoder = NULL;

        }

    // make sure the buffer for conversion is empty    

    if (iGIFImageData)

        {

	    delete iGIFImageData;

        iGIFImageData = NULL;

        }        

    // init & convert the bitmap to GIF format

    iImageEncoder = CImageEncoder::DataNewL(iGIFImageData, CImageEncoder::EOptionNone, KImageTypeGIFUid);

    iImageEncoder->Convert( &iStatus, *aBitmap );

    // execute the async operation and wait till it's finished    

    SetActive();

    iWait.Start();

    // check any erros in active object

    User::LeaveIfError( iStatus.Int() );

    // check if we have valid data

    if (iGIFImageData == NULL || iGIFImageData->Des().Length()<793)

        User::Leave(KErrNoMemory);

    // in GIF files generated by Symbian, the raster data always starts at offset 791,

    // initial code size in GIF encoding should be 8 since we have a 8bpp image,

    // also check that the second last byte is the terminator 0,

    // if this check fails in newer releases of S60, proper parsing of GIF format is probably needed

    TUint8* imagePtr = &iGIFImageData->Des()[0];

    if (imagePtr[791] != 8 || imagePtr[iGIFImageData->Des().Length()-2] != 0)

        User::Leave(KErrNotSupported);

    // write the raster data block to the file

    TUint writeLength = iGIFImageData->Des().Length() - 1 - 791;

    imagePtr+=791;

    TPtr8 writePtr(imagePtr, writeLength, writeLength);

    User::LeaveIfError( iOutFile.Write(writePtr) );

    }

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

void CGifAnimator::WriteFooterL()

    {

    WriteInt8L(0x3b); // GIF trailer

    }

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

void CGifAnimator::FinishL()

    {

    iOutFile.Close();

    iFs.Close();

    }

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

void CGifAnimator::WriteInt8L(TInt aValue)

    {

    HBufC8* buf = HBufC8::NewMaxLC(1);

    TUint8* ptr = &buf->Des()[0];

    ptr[0] = TUint8(aValue);

    User::LeaveIfError( iOutFile.Write(buf->Des()) );

    CleanupStack::PopAndDestroy(); // buf

    }

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

void CGifAnimator::WriteInt16L(TInt aValue)

    {

    HBufC8* buf = HBufC8::NewMaxLC(2);

    TUint8* ptr = &buf->Des()[0];

    ptr[0] = TUint8(aValue);

    ptr[1] = TUint8(aValue>>8);

    User::LeaveIfError( iOutFile.Write(buf->Des()) );

    CleanupStack::PopAndDestroy(); // buf

    }

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

void CGifAnimator::DoCancel()

    {

    CAknEnv::StopSchedulerWaitWithBusyMessage( iWait );

    }

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

void CGifAnimator::RunL()

    {

    CAknEnv::StopSchedulerWaitWithBusyMessage( iWait );

    }

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

void CGifAnimator::DialogDismissedL(TInt aButtonId)

    {

    // check if cancel button was pressed

    if (aButtonId == EAknSoftkeyCancel)

        {

        }

    }

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

/*************************************************************************************************/

// a helper class to display the progress dialog on the screen

CSavingProgressDialog::CSavingProgressDialog() : CActive(EPriorityLow)

    {

	CActiveScheduler::Add(this);

    }

void CSavingProgressDialog::ConstructL(MDialogCallback* aDialogCallback)

    {

    iGlobalProgressDialog = CAknGlobalProgressDialog::NewL();

    iDialogCallback = aDialogCallback;

    }

CSavingProgressDialog* CSavingProgressDialog::NewL(MDialogCallback* aDialogCallback)

    {

    CSavingProgressDialog* self = new(ELeave) CSavingProgressDialog();

    CleanupStack::PushL(self);

    self->ConstructL(aDialogCallback);

    CleanupStack::Pop(self);

    return self;

    }

CSavingProgressDialog::~CSavingProgressDialog()

    {

    Cancel();

    delete iGlobalProgressDialog;

    }

void CSavingProgressDialog::StartDisplayingL(const TDesC &aText, TInt aFinalValue)

    {

    if (!iVisible)

        {

        iFinalValue = aFinalValue;

        iCurrentValue = 0;

        iGlobalProgressDialog->ShowProgressDialogL(iStatus, aText, R_AVKON_SOFTKEYS_EMPTY,

            aFinalValue, CAknNoteDialog::ENoTone);

        iVisible = ETrue;

        SetActive();

        }

    }

void CSavingProgressDialog::DoCancel()

    {

    if (iGlobalProgressDialog)

        {

        iGlobalProgressDialog->CancelProgressDialog();

        }

    iVisible = EFalse;

    }

void CSavingProgressDialog::RunL()

    {

    if (iGlobalProgressDialog && iStatus.Int() == KErrNotFound)

        {

        // user dismissed the dialog

        iDialogCallback->DialogDismissedL(EAknSoftkeyCancel);

        }

    }

void CSavingProgressDialog::IncreaseProgressValueWithOne()

    {

    iCurrentValue++;

    iGlobalProgressDialog->UpdateProgressDialog(iCurrentValue, iFinalValue);

    }

void CSavingProgressDialog::ProcessFinished()

    {

    iGlobalProgressDialog->ProcessFinished();

    iVisible = EFalse;

    }

/*************************************************************************************************/