/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

#include "VeiTitleClipGenerator.h"

#include "VideoEditorCommon.h"

#include "VideoEditorDebugUtils.h"

#include <VedMovie.h>

#include <fbs.h>

#include <bitdev.h>

#include <gdi.h>

#include <aknutils.h>

#include <ImageConversion.h>

#include <BitmapTransforms.h>

#include <aknbiditextutils.h>

#include <AknFontAccess.h>

#include <AknFontSpecification.h>

#include <AknLayoutFont.h>

#include "VideoEditorDebugUtils.h"

const TInt KDefaultNumberOfLines = 15;

const TInt KLineSpacing = 4;

const TInt KMargin = 10;

const TInt KVeiTitleClipDefaultDuration = 5000000;

const TInt KVeiTitleClipFadeLimit = 2000000;

// Restrict the maximum frame rate to 15fps regardless of the movie properties

const TInt KMaxFrameRate = 15;

EXPORT_C CVeiTitleClipGenerator* CVeiTitleClipGenerator::NewL(const TSize& aMaxResolution,

	TVeiTitleClipTransition aTransition, TVeiTitleClipHorizontalAlignment aHorizontalAlignment,

		TVeiTitleClipVerticalAlignment aVerticalAlignment)

	{

	LOGFMT2(KVideoEditorLogFile, "CVeiTitleClipGenerator::NewL: aMaxResolution: (%d,%d)", aMaxResolution.iWidth,aMaxResolution.iHeight);

	__ASSERT_ALWAYS(aMaxResolution.iHeight >= 0, TVedPanic::Panic(TVedPanic::ETitleClipGeneratorIllegalMaxResolution));

	__ASSERT_ALWAYS(aMaxResolution.iWidth >= 0, TVedPanic::Panic(TVedPanic::ETitleClipGeneratorIllegalMaxResolution));

	CVeiTitleClipGenerator* self = CVeiTitleClipGenerator::NewLC(aMaxResolution, aTransition, aHorizontalAlignment, aVerticalAlignment);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CVeiTitleClipGenerator* CVeiTitleClipGenerator::NewLC(const TSize& aMaxResolution, 

	TVeiTitleClipTransition aTransition, TVeiTitleClipHorizontalAlignment aHorizontalAlignment,

		TVeiTitleClipVerticalAlignment aVerticalAlignment)

	{

	LOGFMT2(KVideoEditorLogFile, "CVeiTitleClipGenerator::NewLC: In: aMaxResolution: (%d,%d)", aMaxResolution.iWidth,aMaxResolution.iHeight);

	__ASSERT_ALWAYS(aMaxResolution.iHeight >= 0, TVedPanic::Panic(TVedPanic::ETitleClipGeneratorIllegalMaxResolution));

	__ASSERT_ALWAYS(aMaxResolution.iWidth >= 0, TVedPanic::Panic(TVedPanic::ETitleClipGeneratorIllegalMaxResolution));

	CVeiTitleClipGenerator* self = new (ELeave) CVeiTitleClipGenerator(aMaxResolution, aTransition, aHorizontalAlignment, aVerticalAlignment);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CVeiTitleClipGenerator::ConstructL()

	{

	iDescriptiveName = HBufC::NewL(0);

	iWrappedArray = new (ELeave) CArrayFixFlat<TPtrC>(KDefaultNumberOfLines);

	iText = HBufC::NewL(0);

	GetTextFont();

	}

EXPORT_C CVeiTitleClipGenerator::~CVeiTitleClipGenerator()

	{

	LOG(KVideoEditorLogFile, "CVeiTitleClipGenerator::~CVeiTitleClipGenerator(): In");

	delete iDecodeOperation;

	delete iText;

	if (iWrappedArray) 

		{ 

		iWrappedArray->Reset();

		}

	delete iWrappedArray;

	delete iBackgroundImage;

	delete iScaledBackgroundImage;

	delete iDescriptiveName;

	LOG(KVideoEditorLogFile, "CVeiTitleClipGenerator::~CVeiTitleClipGenerator(): Out");

	}

CVeiTitleClipGenerator::CVeiTitleClipGenerator(const TSize& aMaxResolution, 

											   TVeiTitleClipTransition aTransition, 

											   TVeiTitleClipHorizontalAlignment aHorizontalAlignment,

											   TVeiTitleClipVerticalAlignment aVerticalAlignment)

   : iFirstFrameComplexityFactor(0),

     iGetFontResolution(aMaxResolution),

     iMaxResolution(aMaxResolution),

     iTransition(aTransition),

     iHorizontalAlignment(aHorizontalAlignment),

	 iVerticalAlignment(aVerticalAlignment)

	{

	// Set some default values

	iDuration = TTimeIntervalMicroSeconds(KVeiTitleClipDefaultDuration);

	iBackgroundColor = KRgbBlack;

	iTextColor = KRgbWhite;

	}

EXPORT_C TPtrC CVeiTitleClipGenerator::DescriptiveName() const

	{

	return *iDescriptiveName;

	}

EXPORT_C TUid CVeiTitleClipGenerator::Uid() const

	{

	return KUidTitleClipGenerator;

	}

EXPORT_C TTimeIntervalMicroSeconds CVeiTitleClipGenerator::Duration() const

	{

	return iDuration;

	}

EXPORT_C TInt CVeiTitleClipGenerator::VideoFrameCount() const

	{

	TReal countReal((TReal)( (static_cast<TInt32>(iDuration.Int64())) / 1000000.0 ) * (TReal)(MaximumFramerate()) + 0.5);

	return (TInt) countReal;

	}

EXPORT_C TTimeIntervalMicroSeconds CVeiTitleClipGenerator::VideoFrameStartTime(TInt aIndex) const

	{

	__ASSERT_ALWAYS(aIndex >= 0 && aIndex < VideoFrameCount(), 

		TVedPanic::Panic(TVedPanic::EVideoClipGeneratorIllegalVideoFrameIndex));

	TTimeIntervalMicroSeconds frameTime(1000000 / MaximumFramerate());

	return TTimeIntervalMicroSeconds(TInt64(aIndex) * frameTime.Int64());

	}

EXPORT_C TTimeIntervalMicroSeconds CVeiTitleClipGenerator::VideoFrameEndTime(TInt aIndex) const

	{

	__ASSERT_ALWAYS(aIndex >= 0 && aIndex < VideoFrameCount(), 

		TVedPanic::Panic(TVedPanic::EVideoClipGeneratorIllegalVideoFrameIndex));

	TTimeIntervalMicroSeconds frameTime(1000000 / MaximumFramerate());

	return TTimeIntervalMicroSeconds( (static_cast<TInt64>(aIndex) + 1) * frameTime.Int64() ); 

	}

EXPORT_C TTimeIntervalMicroSeconds CVeiTitleClipGenerator::VideoFrameDuration(TInt aIndex) const

	{

	__ASSERT_ALWAYS(aIndex >= 0 && aIndex < VideoFrameCount(), 

		TVedPanic::Panic(TVedPanic::EVideoClipGeneratorIllegalVideoFrameIndex));

	return TTimeIntervalMicroSeconds(VideoFrameEndTime(aIndex).Int64() - VideoFrameStartTime(aIndex).Int64());

	}

EXPORT_C TInt CVeiTitleClipGenerator::VideoFirstFrameComplexityFactor() const

	{

	return iFirstFrameComplexityFactor;

	}

EXPORT_C TInt CVeiTitleClipGenerator::VideoFrameDifferenceFactor(TInt aIndex) const

	{

	__ASSERT_ALWAYS(aIndex > 0 && aIndex < VideoFrameCount(), 

		TVedPanic::Panic(TVedPanic::EVideoClipGeneratorIllegalVideoFrameIndex));

	TInt differenceFactor = 0;

	TInt pixels = iMaxResolution.iHeight * iMaxResolution.iWidth;

	TInt scale = 1000;

	TInt fontHeight = iTextFont->HeightInPixels();

	switch(iTransition) 

		{

	case EVeiTitleClipTransitionNone:

		{

		differenceFactor = 0; // if there is no transition, it's just a static text

		}

		break;

	case EVeiTitleClipTransitionFade:

		{

		TInt inEndFrame;

		TInt outStartFrame;

		CalculateTransitionFrameIndices(inEndFrame, outStartFrame);

		if ((aIndex < inEndFrame) || (aIndex > outStartFrame)) 

			{

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

				{

				TInt lineWidth = iTextFont->TextWidthInPixels(iWrappedArray->At(i));

				differenceFactor += fontHeight * lineWidth;

				}

			differenceFactor *= scale;

			differenceFactor /= pixels;

			}

		else

			{

			differenceFactor = 0;

			}

		}

		break;

	case EVeiTitleClipTransitionScrollBottomToTop:

	case EVeiTitleClipTransitionScrollTopToBottom:

		{

		TInt yTravelPerFrame = (iMaxResolution.iHeight + iWrappedTextBoxHeight) / VideoFrameCount() + 1;

		TInt maxLineWidth = 0;

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

			{

			TInt lineWidth = iTextFont->TextWidthInPixels(iWrappedArray->At(i));

			if (lineWidth > maxLineWidth) 

				{

				maxLineWidth = lineWidth;

				}

			}

		differenceFactor = scale * maxLineWidth * yTravelPerFrame / pixels;

		break;

		}

	case EVeiTitleClipTransitionScrollLeftToRight:

	case EVeiTitleClipTransitionScrollRightToLeft:

		{

		TInt xTravelPerFrame = (iMaxResolution.iWidth + iTextFont->TextWidthInPixels(*iText)) / VideoFrameCount() + 1;

		differenceFactor = scale * xTravelPerFrame * fontHeight / pixels;

		break;

		}

	default:

		TVedPanic::Panic(TVedPanic::EInternal);

		}

	return differenceFactor;

	}

EXPORT_C TInt CVeiTitleClipGenerator::GetVideoFrameIndex(TTimeIntervalMicroSeconds aTime) const

	{

	__ASSERT_ALWAYS(aTime.Int64() >= 0 && aTime.Int64() <= iDuration.Int64(),

		TVedPanic::Panic(TVedPanic::EVideoClipGeneratorIllegalVideoFrameIndex));

	TTimeIntervalMicroSeconds frameTime(1000000 / MaximumFramerate());

	return (static_cast<TInt32>(aTime.Int64() / frameTime.Int64()));

	}

EXPORT_C void CVeiTitleClipGenerator::GetFrameL(MVedVideoClipGeneratorFrameObserver& aObserver,

								  TInt aIndex, TSize* const aResolution,

								  TDisplayMode aDisplayMode, TBool aEnhance,

								  TInt aPriority)

	{

#ifdef VERBOSE

	LOGFMT3(KVideoEditorLogFile, "CVeiTitleClipGenerator::GetFrameL(): In: aIndex:%d, aResolution:(%d,%d)",\

		aIndex, aResolution->iWidth, aResolution->iHeight);

#endif

	__ASSERT_ALWAYS(aIndex == KFrameIndexBestThumb || aIndex >= 0 

		&& aIndex < VideoFrameCount(), 

		TVedPanic::Panic(TVedPanic::EVideoClipGeneratorIllegalVideoFrameIndex));

    TDisplayMode displayMode = aDisplayMode;

    // check validity of thumbnail and associated operation

    if(aEnhance)	// for saving to file

        {

        if(displayMode == ENone)					// if no preference

			{

            displayMode = EColor16M;				// 24-bit color image for enhancement

			}

        else if(displayMode != EColor16M)	// invalid combination

			{

            User::Leave(KErrNotSupported);

			}

        }

    else								// for screen display

        {

        if(displayMode == ENone)					// if no preference

			{

            displayMode = EColor64K;				// 16-bit image

			}

        }

	iUseScaledImage = EFalse;

	iGetFrameObserver = &aObserver;

    iGetFrameIndex = aIndex;

	iGetFrameResolution = TSize(aResolution->iWidth, aResolution->iHeight);

	iGetFrameDisplayMode = displayMode;

	iGetFrameEnhance = aEnhance;

	iGetFramePriority = aPriority;	

	if (!iBackgroundImage)

		{

		// No background image, just finish.

		FinishGetFrameL();

		}

	else if	((aResolution->iHeight == iBackgroundImage->SizeInPixels().iHeight) || 

			 (aResolution->iWidth == iBackgroundImage->SizeInPixels().iWidth)) 

		{

		// The background image does not need scaling - deleting scaled image

		// causes FinishGetFrameL() to use the original.

		iUseScaledImage = EFalse;

		FinishGetFrameL();

		}

	else if (iScaledBackgroundImage &&

			 ((aResolution->iHeight == iScaledBackgroundImage->SizeInPixels().iHeight) || 

			 (aResolution->iWidth == iScaledBackgroundImage->SizeInPixels().iWidth)))

		{

		// Scaled image is in correct resolution

		iUseScaledImage = ETrue;

		FinishGetFrameL();

		}

	else

		{

		// We need to scale the image.

		iUseScaledImage = ETrue;

		if (iScaledBackgroundImage) 

			{

			delete iScaledBackgroundImage;

			iScaledBackgroundImage = 0;

			}

		if (iDecodeOperation) 

			{

			delete iDecodeOperation;

			iDecodeOperation = 0;

			}

		CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

		CleanupStack::PushL(bitmap);

		User::LeaveIfError(bitmap->Create(iBackgroundImage->SizeInPixels(), iBackgroundImage->DisplayMode()));

		CFbsDevice* device = CFbsBitmapDevice::NewL(bitmap);

		CFbsBitGc* gc = NULL;

		device->CreateContext(gc);

		gc->BitBlt(TPoint(0,0), iBackgroundImage);

		delete gc;

		delete device;		

		iDecodeOperation = CVeiTitleClipImageDecodeOperation::NewL(*this, bitmap);

		CleanupStack::Pop(bitmap);

		iDecodeOperation->StartScalingOperationL(iGetFrameResolution);

		}

#ifdef VERBOSE

	LOG(KVideoEditorLogFile, "CVeiTitleClipGenerator::GetFrameL(): Out");

#endif

	}

EXPORT_C CFbsBitmap* CVeiTitleClipGenerator::FinishGetFrameL(TInt aError)

	{

#ifdef VERBOSE

	LOGFMT(KVideoEditorLogFile, "CVeiTitleClipGenerator::FinishGetFrameL(): In: aError:%d", aError);

#endif

	ASSERT(iGetFrameResolution.iWidth > 0 && iGetFrameResolution.iHeight > 0);

	if (aError != KErrNone) 

		{

		iGetFrameObserver->NotifyVideoClipGeneratorFrameCompleted(*this, aError, NULL);

		return NULL;

		}

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	TInt err = bitmap->Create(iGetFrameResolution, iGetFrameDisplayMode);

	if (err != KErrNone) 

		{

		delete bitmap;

		bitmap = NULL;

		iGetFrameObserver->NotifyVideoClipGeneratorFrameCompleted(*this, err, NULL);

		}

	else

		{

		CFbsDevice* device = CFbsBitmapDevice::NewL(bitmap);

		CFbsBitGc* gc = NULL;

		device->CreateContext(gc);

		/* Draw the background. */

		if (iUseScaledImage) 

			{

			TSize bgImageSize(iScaledBackgroundImage->SizeInPixels());

			TPoint bgPoint((iGetFrameResolution.iWidth - bgImageSize.iWidth) / 2,

						   (iGetFrameResolution.iHeight - bgImageSize.iHeight) / 2);

			gc->BitBlt(bgPoint, iScaledBackgroundImage);

			}

		else if (iBackgroundImage) 

			{

			TSize bgImageSize(iBackgroundImage->SizeInPixels());

			TPoint bgPoint((iGetFrameResolution.iWidth - bgImageSize.iWidth) / 2,

						   (iGetFrameResolution.iHeight - bgImageSize.iHeight) / 2);

			gc->BitBlt(bgPoint, iBackgroundImage);

			}

		else

			{

			gc->SetBrushColor(iBackgroundColor);

			gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

			gc->DrawRect(bitmap->SizeInPixels());

			}

		delete gc;

		delete device;

		switch(iTransition) 

			{

		case EVeiTitleClipTransitionNone:

		case EVeiTitleClipTransitionFade:

			{

			DrawMainTitleFrameL(*bitmap, iGetFrameIndex);

			break;

			}

		case EVeiTitleClipTransitionScrollBottomToTop:

		case EVeiTitleClipTransitionScrollTopToBottom:

		case EVeiTitleClipTransitionScrollLeftToRight:

		case EVeiTitleClipTransitionScrollRightToLeft:

			{

			DrawScrollTitleFrameL(*bitmap, iGetFrameIndex);

			break;

			}

		default:

			TVedPanic::Panic(TVedPanic::EInternal);

			}

		/* Notify the observer. */

		if (iGetFrameObserver) 

			{

			iGetFrameObserver->NotifyVideoClipGeneratorFrameCompleted(*this, KErrNone, bitmap);

			}

		iGetFrameObserver = 0;

	    iGetFrameIndex = -5;

		CleanupStack::Pop(bitmap);

		}

#ifdef VERBOSE

	LOG(KVideoEditorLogFile, "CVeiTitleClipGenerator::FinishGetFrameL(): Out");

#endif

	return bitmap;

	}

EXPORT_C void CVeiTitleClipGenerator::CancelFrame()

	{

	if (iDecodeOperation) 

		{

		iDecodeOperation->Cancel();

		}

	}

EXPORT_C TVeiTitleClipTransition CVeiTitleClipGenerator::Transition() const

	{

	return iTransition;

	}

EXPORT_C TVeiTitleClipHorizontalAlignment CVeiTitleClipGenerator::HorizontalAlignment() const

	{

	return iHorizontalAlignment;

	}

EXPORT_C TVeiTitleClipVerticalAlignment CVeiTitleClipGenerator::VerticalAlignment() const

	{

	return iVerticalAlignment;

	}

EXPORT_C void CVeiTitleClipGenerator::SetTransitionAndAlignmentsL(												

		TVeiTitleClipTransition aTransition,

		TVeiTitleClipHorizontalAlignment aHorizontalAlignment,

		TVeiTitleClipVerticalAlignment aVerticalAlignment)

	{

	TBool updateNeeded = EFalse;

	if (iTransition != aTransition) 

		{

		iTransition = aTransition;

		updateNeeded = ETrue;

		}

	if (iHorizontalAlignment != aHorizontalAlignment) 

		{

		iHorizontalAlignment = aHorizontalAlignment;

		updateNeeded = ETrue;

		}

	if (iVerticalAlignment != aVerticalAlignment) 

		{

		iVerticalAlignment = aVerticalAlignment;

		updateNeeded = ETrue;

		}

	if (updateNeeded) 

		{

		UpdateFirstFrameComplexityFactorL();

		ReportSettingsChanged();

		}

	}

EXPORT_C void CVeiTitleClipGenerator::SetTextL(const TDesC& aText)

	{

	LOG(KVideoEditorLogFile, "CVeiTitleClipGenerator::SetTextL(): In");

	/* Don't do anything if the texts are equal. */

	if (iText && !iText->Compare(aText)) 

		{

		return;

		}

	/* Delete old text. */

	if (iText) 

		{

		delete iText;

		iText = 0;

		}

	/* Wrap the string to lines. */

	WrapTextToArrayL(aText);

	ReportSettingsChanged();

	LOG(KVideoEditorLogFile, "CVeiTitleClipGenerator::SetTextL(): Out");

	}

EXPORT_C void CVeiTitleClipGenerator::SetDescriptiveNameL(const TDesC& aDescriptiveName)

	{

	if (iDescriptiveName && !iDescriptiveName->Compare(aDescriptiveName)) 

		{

		return;

		}