/*
* 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:    Classes for thumbnail-related tasks.
*
*/




/**
 * @internal reviewed 31/07/2007 by Simon Brooks
 */

#include "glxtnquickthumbnailtask.h"

#include <ExifRead.h>
#include <glxassert.h>
#include <glxtracer.h>
#include <imageconversion.h>

#include "glxtnfileinfo.h"
#include "glxtnfileutility.h"
#include "glxtnimagedecoderfactory.h"
#include "glxtnthumbnailrequest.h"
#include "glxtnvideoutility.h"
#include "mglxtnthumbnailcreatorclient.h"


// All EXIF data is within the first KGlxMaxExifSize bytes of the file
const TInt KGlxMaxExifSize = 0x10000;

// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxtnQuickThumbnailTask* CGlxtnQuickThumbnailTask::NewL(
        const TGlxThumbnailRequest& aRequestInfo,
        CGlxtnFileUtility& aFileUtility, MGlxtnThumbnailCreatorClient& aClient)
    {
    TRACER("CGlxtnQuickThumbnailTask::NewL()");
    CGlxtnQuickThumbnailTask* task = new (ELeave) CGlxtnQuickThumbnailTask(
                                        aRequestInfo, aFileUtility, aClient);
    CleanupStack::PushL(task);
    task->ConstructL(aRequestInfo.iBitmapHandle);
    CleanupStack::Pop( task );
    return task;
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
CGlxtnQuickThumbnailTask::CGlxtnQuickThumbnailTask(
                                    const TGlxThumbnailRequest& aRequestInfo,
                                    CGlxtnFileUtility& aFileUtility,
                                    MGlxtnThumbnailCreatorClient& aClient ) :
    CGlxtnLoadThumbnailTask( KGlxtnTaskIdQuickThumbnail,
                            aRequestInfo, aFileUtility, aClient ),
    iQuality( EGlxThumbnailQualityLow )
    {
    TRACER("CGlxtnQuickThumbnailTask::CGlxtnQuickThumbnailTask()");
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CGlxtnQuickThumbnailTask::~CGlxtnQuickThumbnailTask() 
    {
    TRACER("CGlxtnQuickThumbnailTask::~CGlxtnQuickThumbnailTask()");
    delete iUtility;
    delete iVideoFrame;
    }

// -----------------------------------------------------------------------------
// DoStartL
// -----------------------------------------------------------------------------
//
TBool CGlxtnQuickThumbnailTask::DoStartL(TRequestStatus& aStatus)
    {
    TRACER("TBool CGlxtnQuickThumbnailTask::DoStartL()");
    iInfo = new (ELeave) CGlxtnFileInfo;
	Client().FetchFileInfoL(iInfo, ItemId(), &aStatus);
    iState = EStateFetchingUri;

    return ETrue;
    } 

// -----------------------------------------------------------------------------
// DoCancel
// -----------------------------------------------------------------------------
//
void CGlxtnQuickThumbnailTask::DoCancel() 
    {
    TRACER("void CGlxtnQuickThumbnailTask::DoCancel()");
    CGlxtnLoadThumbnailTask::DoCancel();

    if ( EStateFetchingUri == iState )
        {
        Client().CancelFetchUri( ItemId() );
        }

    if ( iUtility )
        {
        iUtility->Cancel();
        }

    iFileUtility.ClearBadFileMarker();
    }

// -----------------------------------------------------------------------------
// DoRunL
// -----------------------------------------------------------------------------
//
TBool CGlxtnQuickThumbnailTask::DoRunL(TRequestStatus& aStatus) 
    {
    TRACER("TBool CGlxtnQuickThumbnailTask::DoRunL()");
    TInt error = aStatus.Int();
	TBool active = EFalse;

    if ( KErrNone == error )
        {
        switch ( iState )
            {
            case EStateFetchingUri:
                User::LeaveIfNull(iInfo);
                iBadFileMarkerNotNeededFlag = ETrue;

                TBool protectedFile;
                iInfo->IdentifyFileL(iVideo, protectedFile);
                
                // leave if file is DRM protected and client has no DRM 
                // capablity
                if ( protectedFile && !iDrmAllowed )
                    {
                    User::Leave(KErrAccessDenied);
                    }

                if ( !LoadThumbnailL( aStatus ) )
                    {
                    iBadFileMarkerNotNeededFlag = EFalse;
                    iFileUtility.CheckBadFileListL( iInfo->FilePath() );
                    QuickDecodeL(aStatus);
                    }
                active = ETrue;
                break;

            case EStateLoading:
                iQuality = EGlxThumbnailQualityHigh;
                active = HandleLoadedThumbnailL(aStatus);
                break;

            case EStateDecodingThumbnail:
                // Nothing to do
                break;

            case EStateDecodingImage:
                QuickScaleL();
                break;

            default:
                GLX_ASSERT_ALWAYS( EFalse, Panic( EGlxPanicIllegalState ),
                                "CGlxtnQuickThumbnailTask: Illegal state" );
                break;
            }
        }
    else
        {
        if ( EStateLoading == iState )
            {
            // Loading failed - generate low quality thumbnail instead
            iBadFileMarkerNotNeededFlag = EFalse;
            iFileUtility.CheckBadFileListL( iInfo->FilePath() );
            QuickDecodeL(aStatus);
            active = ETrue;
            }
        }

    if ( !active )
        {
        if ( !iBadFileMarkerNotNeededFlag )
            {
            iFileUtility.ClearBadFileMarker();
            }
        Client().ThumbnailFetchComplete(ItemId(), iQuality, error);
        }
       
    return active; 
    }

// -----------------------------------------------------------------------------
// DoRunError
// -----------------------------------------------------------------------------
//
TBool CGlxtnQuickThumbnailTask::DoRunError(TInt aError)
    {
    TRACER("TBool CGlxtnQuickThumbnailTask::DoRunError(TInt aError)");
    iFileUtility.ClearBadFileMarker();
    Client().ThumbnailFetchComplete(ItemId(), iQuality, aError);

    return EFalse;
    }

// -----------------------------------------------------------------------------
// QuickDecodeL
// -----------------------------------------------------------------------------
//
void CGlxtnQuickThumbnailTask::QuickDecodeL(TRequestStatus& aStatus)
    {
    TRACER("void CGlxtnQuickThumbnailTask::QuickDecodeL(TRequestStatus& aStatus)");
    iQuality = EGlxThumbnailQualityLow;

    if ( iVideo )
        {
        RArray<TSize> targetSizes;
        CleanupClosePushL(targetSizes);
        targetSizes.AppendL( TSize(iRequestedSize) );
        iUtility = new (ELeave) CGlxtnVideoUtility;
        iUtility->GetVideoFrameL(&aStatus, iVideoFrame, iInfo->FilePath(), targetSizes, iThumbnail->DisplayMode() );
        iState = EStateDecodingImage;
        CleanupStack::PopAndDestroy(&targetSizes);
        }
    else
        {
        ReadThumbnailL(aStatus);
        }
    }

// -----------------------------------------------------------------------------
// ReadThumbnailL
// -----------------------------------------------------------------------------
//
void CGlxtnQuickThumbnailTask::ReadThumbnailL(TRequestStatus& aStatus)
    {
    TRACER("void CGlxtnQuickThumbnailTask::ReadThumbnailL(TRequestStatus& aStatus)");
    TBool scaleBitmap = ETrue;

    TRAPD(error, ReadExifThumbnailL());
    if ( KErrNotFound == error || KErrCorrupt == error
        || KErrNotSupported == error )
        {
        GLX_DEBUG2("CGlxtnQuickThumbnailTask::ReadThumbnailL() EXIF error(%d)", error);    
        // Use CImageDecoder to get the EXIF thumbnail instead
        iDecoder = GlxtnImageDecoderFactory::NewL(
                                iFileUtility.FsSession(), iInfo->FilePath() );

        TRAPD( error2, iDecoder->SetImageTypeL(
                                    CImageDecoder::EImageTypeThumbnail ) );
        if ( KErrNotFound == error2 )
            {
            // No EXIF thumbnail - load whole image and scale quickly
            scaleBitmap = ETrue;
            }
        else
            {
            User::LeaveIfError( error2 );
            }
        }
    else
        {
        User::LeaveIfError(error);
        GLX_DEBUG1("CGlxtnQuickThumbnailTask::ReadThumbnailL() EXIF TN Found");    
        iDecoder = GlxtnImageDecoderFactory::NewL(
                                    iFileUtility.FsSession(), *iThumbData );
        }

    DecodeThumbnailL(aStatus, scaleBitmap);
    }

// -----------------------------------------------------------------------------
// ReadExifThumbnailL
// -----------------------------------------------------------------------------
//
void CGlxtnQuickThumbnailTask::ReadExifThumbnailL()
    {
    TRACER("void CGlxtnQuickThumbnailTask::ReadExifThumbnailL()");
    __ASSERT_ALWAYS(iInfo, Panic(EGlxPanicNullPointer));

    RFile file;
    CleanupClosePushL(file);
    User::LeaveIfError(file.Open(iFileUtility.FsSession(),
                                    iInfo->FilePath(), EFileRead));
    TInt size;
    User::LeaveIfError(file.Size(size));
    if ( KGlxMaxExifSize < size )
        {
        size = KGlxMaxExifSize;
        }

    HBufC8* exifData = HBufC8::NewLC(size);
    TPtr8 ptr(exifData->Des());
    User::LeaveIfError(file.Read(ptr));

    CExifRead* exifReader = CExifRead::NewL(*exifData, CExifRead::ENoJpeg);
    CleanupStack::PushL(exifReader);
    delete iThumbData;
    iThumbData = NULL;
    iThumbData = exifReader->GetThumbnailL();

    CleanupStack::PopAndDestroy(exifReader);
    CleanupStack::PopAndDestroy(exifData);
    CleanupStack::PopAndDestroy(&file);
    }

// -----------------------------------------------------------------------------
// QuickScaleL
// -----------------------------------------------------------------------------
//
void CGlxtnQuickThumbnailTask::QuickScaleL()
    {
    TRACER("void CGlxtnQuickThumbnailTask::QuickScaleL()");
    User::LeaveIfNull(iVideoFrame);

    TSize frameSize(iVideoFrame->SizeInPixels());
    TSize thumbSize(iRequestedSize);

    // Reduce target thumbSize to same aspect ratio as source image
    if ( thumbSize.iHeight * frameSize.iWidth < thumbSize.iWidth * frameSize.iHeight )
        {
        // Source has taller aspect than target so reduce target width
        thumbSize.iWidth = (thumbSize.iHeight * frameSize.iWidth) / frameSize.iHeight;
        }
    else
        {
        // Source has wider aspect than target so reduce target height
        thumbSize.iHeight = (thumbSize.iWidth * frameSize.iHeight) / frameSize.iWidth;
        }

    // Resize empty bitmap to required size
    User::LeaveIfError( iThumbnail->Resize( thumbSize ) );

    CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( iThumbnail );
    CleanupStack::PushL(device);
    CFbsBitGc* context = NULL;
    User::LeaveIfError(device->CreateContext(context));
    CleanupStack::PushL(context);

    context->DrawBitmap(TRect(thumbSize), iVideoFrame);

    CleanupStack::PopAndDestroy(context); 
    CleanupStack::PopAndDestroy(device);
    }