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

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include <caf/caf.h>

#include <caf/content.h>

#include <caf/data.h>

#include <mm/mmcleanup.h>

#include <mm/mmpluginutils.h>

#include <imageframe.h>

#include <imageprocessor/imageprocessor_uids.hrh>

#include "imageprocessorimpl.h"

#include <imageprocessor/imageprocessorobserver.h>

#include <imageprocessor/imageprocessorplugin.h>

#include <imageprocessor/imageprocessoreffect.h>

#include "imageprocessorcallback.h"

#include <imageprocessor/imageprocessorpreview.h>

#include <imageprocessor/imageprocessorpreviewintf.h>

#include <imageprocessor/imageprocessoroverlay.h>

#include <imageprocessor/imageprocessoroverlayintf.h>

#include <imageprocessor/imageprocessorprogressinfo.h>

#include <imageprocessor/imageprocessorprogressinfointf.h>

#include <imageprocessor/imageprocessorinputinfo.h>

#include <imageprocessor/imageprocessorinputinfointf.h>

#include <imageprocessor/imageprocessoroutputinfo.h>

#include <imageprocessor/imageprocessoroutputinfointf.h>

#include "imageprocessormain.h"

using namespace ImageProcessor;

// current state = row

// new state = column

const TBool CImageProcessorImpl::iValidStates[CImgProcessor::EStatesCount][CImgProcessor::EStatesCount] = 

	{

		//	EUninitialized	EInitializing	EInitialized	EEffectActive	EProcessing	PInit	PRend

		{	

			ETrue, 			ETrue, 			EFalse, 		EFalse, 		EFalse,		EFalse,	EFalse	//EUninitialized

		},		

		{	

			ETrue, 			ETrue, 			ETrue, 			EFalse,			EFalse,		EFalse,	EFalse	//EInitializing

		},

		{	

			ETrue,	 		EFalse,			ETrue, 			ETrue, 			ETrue,		ETrue,	ETrue	//EInitialized

		},		

		{	

			EFalse, 		EFalse,			ETrue,			ETrue, 			ETrue,		ETrue,	ETrue	//EEffectActive

		},

		{	

			EFalse, 		EFalse,			ETrue,			ETrue,			ETrue,		EFalse,	EFalse	//EProcessing

		},

		{	

			EFalse, 		EFalse,			ETrue,			ETrue,			EFalse,		ETrue,	EFalse	//EPreviewInitializing

		},

		{	

			EFalse, 		EFalse,			ETrue,			ETrue,			EFalse,		EFalse,	ETrue	//EPreviewRendering

		}

	};

CImageProcessorImpl* CImageProcessorImpl::NewL(RFs& aFileServerSession, CImgProcessor& aImageProcessor, MImgProcessorObserver& aObserver, TUid aPluginUid)

	{

	CImageProcessorImpl* self = new (ELeave) CImageProcessorImpl(aFileServerSession, aImageProcessor, aPluginUid);

	CleanupStack::PushL(self);

	self->ConstructL(aObserver);

	CleanupStack::Pop(self);

	return self;

	}

CImageProcessorImpl::CImageProcessorImpl(RFs& aFileServerSession, CImgProcessor& aImageProcessor, TUid aPluginUid):

	iFileServerSession(aFileServerSession),

	iImageProcessor(aImageProcessor),

	iPluginUid(aPluginUid)

	{

	}

void CImageProcessorImpl::ConstructL(MImgProcessorObserver& aObserver)

	{

	iCallbackHandler = CImageProcessorCallback::NewL(iImageProcessor,aObserver);

	}

void CImageProcessorImpl::Cleanup()

	{

	Cancel();

	TInt err = KErrNone;

	if (iOverlay) 

		{

		TRAP(err, iOverlay->ResetL());

		}

	for (TInt i=0; i < iEffects.Count(); i++ )

		{ 

		TRAP(err, iEffects[i]->ResetL());

		}

	for (TInt i=0; i < iPreviews.Count(); i++ )

		{ 

		TRAP(err, iPreviews[i]->ResetL());

		TRAP(err, iPreviews[i]->UninitializeL());

		}

	if (iPlugin)

		{

		TRAP(err, iPlugin->ResetL());

		}

	delete iCallbackHandler;

	iCallbackHandler = NULL;

	delete iOverlay;

	iOverlay = NULL;

	delete iProgressInfo;

	iProgressInfo = NULL;

	delete iInputInfo;

	iInputInfo = NULL;

	delete iOutputInfo;

	iOutputInfo = NULL;

	delete iDrmInput;

	iDrmInput = NULL;

	delete iOverlayDrmInput;

	iOverlayDrmInput = NULL;

	iEffects.ResetAndDestroy();

	iPreviews.ResetAndDestroy();

	iOverlayDrmInputs.ResetAndDestroy();

	iFrameworkEffects.Close();

	iPluginEffects.Close();

	iInputFormats.Close();

	iInputImageFrameFormats.Close();

	iInputDisplayModes.Close();

	iOutputFormats.Close();

	iOutputImageFrameFormats.Close();

	iOutputDisplayModes.Close();

	iPreviewOutputImageFrameFormats.Close();

	iPreviewOutputDisplayModes.Close();

	iOverlayInputFormats.Close();

	iOverlayInputImageFrameFormats.Close();

	iOverlayInputDisplayModes.Close();

	iTypesUtilityArray.ResetAndDestroy();

	if(iPlugin)

		{

		iPlugin->Destroy();

		iPlugin = NULL;

		REComSession::DestroyedImplementation(iPluginDtorKey);      

		}

	iState = CImgProcessor::EUninitialized;

	iPreviousState = CImgProcessor::EUninitialized;

	iSupportedOptions = CImgProcessor::EOptionNone;

	iOptions = CImgProcessor::EOptionNone;

	iSupportedOperations = CImgProcessor::EOperationNone;

	iIsInputSet = EFalse;

	iIsOutputSet = EFalse;

	}

CImageProcessorImpl::~CImageProcessorImpl()

	{

	Cleanup();

	}

void CImageProcessorImpl::SupportedEffectsL(RArray<TUid>& aEffects) const

	{

	aEffects = iPluginEffects;

	}

void CImageProcessorImpl::SupportedInputFormatsL(RArray<TUid>& aFormats) const

	{

	aFormats = iInputFormats;

	}

void CImageProcessorImpl::SupportedInputSubFormatsL(TUid aFormats, RArray<TUid>& aSubFormats) const

	{

	iPlugin->SupportedInputSubFormatsL(aFormats, aSubFormats);

	}

void CImageProcessorImpl::SupportedInputImageFrameFormatsL(RArray<TUid>& aFormats) const

	{

	aFormats = iInputImageFrameFormats;

	}

void CImageProcessorImpl::SupportedInputDisplayModesL(RArray<TDisplayMode>& aDisplayModes) const

	{

	aDisplayModes = iInputDisplayModes;

	}

void CImageProcessorImpl::SupportedOutputFormatsL(RArray<TUid>& aFormats) const

	{

	aFormats = iOutputFormats;

	}

void CImageProcessorImpl::SupportedOutputSubFormatsL(TUid aFormat, RArray<TUid>& aSubFormats) const

	{

	iPlugin->SupportedOutputSubFormatsL(aFormat, aSubFormats);

	}

void CImageProcessorImpl::SupportedOutputImageFrameFormatsL(RArray<TUid>& aFormats) const

	{

	aFormats = iOutputImageFrameFormats;

	}

void CImageProcessorImpl::SupportedOutputDisplayModesL(RArray<TDisplayMode>& aDisplayModes) const

	{

	aDisplayModes = iOutputDisplayModes;

	}

TUint64 CImageProcessorImpl::SupportedOptions() const

	{

	return iSupportedOptions;

	}

TUint CImageProcessorImpl::SupportedOperations() const

	{	

	return iSupportedOperations;

	}

void CImageProcessorImpl::SetOptionsL(TUint64 aOptions)

	{

	if ((aOptions | iSupportedOptions) != iSupportedOptions) 

		{

		User::Leave(KErrNotSupported);

		}

	CheckStateL(CImgProcessor::EInitialized);

	iPlugin->SetOptionsL(aOptions);

	iOptions = aOptions;

	}

void CImageProcessorImpl::ApplyOperationL(CImgProcessor::TOperation aOperation)

	{

	if ((aOperation | iSupportedOperations) != iSupportedOperations) 

		{

		User::Leave(KErrNotSupported);

		}

	__ASSERT_ALWAYS(((iState == CImgProcessor::EInitialized) && (iIsInputSet)), User::Leave(KErrNotReady));

	iPlugin->ApplyOperationL(aOperation);

	}

void CImageProcessorImpl::CheckStateL(CImgProcessor::TState aState) const

	{

	if (iState != aState) 

		{

		User::Leave(KErrNotReady);

		}

	}

CImgProcessor::TState CImageProcessorImpl::State() const

	{

	return iState;

	}

void CImageProcessorImpl::SetInputL(const TDesC& aFilename, const TUid& aFormat, const TUid& aSubFormat)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	CheckInputFormatL(aFormat, aSubFormat);

	iPlugin->SetInputL(aFilename, aFormat, aSubFormat);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::SetInputL(RFile& aFile, const TUid& aFormat, const TUid& aSubFormat)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	CheckInputFormatL(aFormat, aSubFormat);

	iPlugin->SetInputL(aFile, aFormat, aSubFormat);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::SetInputL(TMMSource& aDrmFile, const TUid& aFormat, const TUid& aSubFormat)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	CheckInputFormatL(aFormat, aSubFormat);

	CImageProcessorDrmInput* drmInput = CImageProcessorDrmInput::NewL(aDrmFile);

	CleanupStack::PushL(drmInput);

	SetInputL(*(drmInput->Buffer()), aFormat, aSubFormat);

	CleanupStack::Pop();

	iDrmInput = drmInput;

	}

void CImageProcessorImpl::SetInputL(const TDesC8& aBuffer, const TUid& aFormat, const TUid& aSubFormat)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	CheckInputFormatL(aFormat, aSubFormat);

	if (aBuffer.Size() == 0) 

		{

		User::Leave(KErrArgument);

		}

	iPlugin->SetInputL(aBuffer, aFormat, aSubFormat);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::SetInputL(const CFbsBitmap& aBitmap, const CFbsBitmap* aMask)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	if (aBitmap.SizeInPixels() == TSize(0,0)) 

		{

		User::Leave(KErrArgument);

		}

	if((aBitmap.Handle()!=0 && aBitmap.ExtendedBitmapType()!=KNullUid) || (aMask!=NULL && aMask->Handle()!=0 && aMask->ExtendedBitmapType()!=KNullUid))

        {

        User::Leave(KErrNotSupported);

        }

	if ((aMask != NULL) && (aMask->SizeInPixels() == TSize(0,0))) 

		{

		User::Leave(KErrArgument);

		}

	iPlugin->SetInputL(aBitmap, aMask);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::SetInputL(const CImageFrame& aPixelBuffer)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	if (aPixelBuffer.FrameSizeInPixels() == TSize(0,0)) 

		{

		User::Leave(KErrArgument);

		}

	iPlugin->SetInputL(aPixelBuffer);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::SetInputL(CImagePanorama& aPanorama)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	//get the extenstion interface to panorama image as input

	TAny* any = iPlugin->Extension(TUid::Uid(KImageProcessorExtensionPanoramaInputUidValue));

	MImgProcessorPluginPanoramaInput* extension = static_cast<MImgProcessorPluginPanoramaInput*>(any);

	if(extension == NULL)

		{

		User::Leave(KErrNotSupported);

		}

	extension->SetInputL(aPanorama);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::SetInputRectL(const TRect& aRect)

	{

	__ASSERT_ALWAYS(((iState == CImgProcessor::EInitialized) && (iIsInputSet)), User::Leave(KErrNotReady));

	if (aRect == TRect(0,0,0,0) || aRect.Size() == TSize(0,0)) 

		{

		User::Leave(KErrArgument);

		}

	TSize size = iPlugin->CurrentSizeL();

	if (!TRect(size).Intersects(aRect)) 

		{

		User::Leave(KErrArgument);

		}

	iPlugin->SetInputRectL(aRect);

	}

TSize CImageProcessorImpl::CurrentSizeL() const

	{

	__ASSERT_ALWAYS(iIsInputSet, User::Leave(KErrNotReady));

	return iPlugin->CurrentSizeL();

	}

TInt CImageProcessorImpl::CalculatePixelBufferSizeL(TSize aSizeInPixels, TDisplayMode aDisplayMode, TUint32 aScanLineLength) const

	{

	__ASSERT_ALWAYS((iState != CImgProcessor::EUninitialized), User::Leave(KErrNotReady));

	return iPlugin->CalculatePixelBufferSizeL(aSizeInPixels, aDisplayMode, aScanLineLength);

	}

TInt CImageProcessorImpl::CalculatePixelBufferSizeL(TSize aSizeInPixels, const TUid& aFormat, TUint32 aScanLineLength) const

	{

	__ASSERT_ALWAYS((iState != CImgProcessor::EUninitialized), User::Leave(KErrNotReady));

	return iPlugin->CalculatePixelBufferSizeL(aSizeInPixels, aFormat, aScanLineLength);

	}

void CImageProcessorImpl::CreateInputL(CFbsBitmap& aBitmap)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	if (aBitmap.SizeInPixels() == TSize(0,0)) 

		{

		User::Leave(KErrArgument);

		}

	if(aBitmap.Handle()!=0 && aBitmap.ExtendedBitmapType()!=KNullUid)

        {

        User::Leave(KErrNotSupported);

        }

	iPlugin->CreateInputL(aBitmap);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::CreateInputL(CImageFrame& aPixelBuffer)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	if (aPixelBuffer.FrameSizeInPixels() == TSize(0,0)) 

		{

		User::Leave(KErrArgument);

		}

	iPlugin->CreateInputL(aPixelBuffer);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::CreateInputL(const TSize& aSize, const TRgb& aColor)

	{

	__ASSERT_ALWAYS((iState == CImgProcessor::EInitialized), User::Leave(KErrNotReady));

	if (aSize == TSize(0,0)) 

		{

		User::Leave(KErrArgument);

		}

	iPlugin->CreateInputL(aSize, aColor);

	delete iDrmInput;

	iDrmInput = NULL;

	iIsInputSet = ETrue;

	}

void CImageProcessorImpl::InputUpdatedL()

	{

	__ASSERT_ALWAYS(((iState == CImgProcessor::EInitialized) && (iIsInputSet)), User::Leave(KErrNotReady));

	iPlugin->InputUpdatedL();

	}

void CImageProcessorImpl::ResetL() 

	{

	__ASSERT_ALWAYS(((iState != CImgProcessor::EUninitialized) && (iState != CImgProcessor::EInitializing)), User::Leave(KErrNotReady));

	Cancel();

	if (iOverlay) 

		{

		iOverlay->ResetL();

		}

	delete iOverlayDrmInput;

	iOverlayDrmInput = NULL;

	for (TInt i=0; i < iEffects.Count(); i++ )

		{ 

		iEffects[i]->ResetL();

		}

	for (TInt i=0; i < iPreviews.Count(); i++ )

		{ 

		iPreviews[i]->ResetL();

		}

	iPlugin->ResetL();

	delete iDrmInput;

	iDrmInput = NULL;

	delete iProgressInfo;

	iProgressInfo = NULL;

	delete iInputInfo;

	iInputInfo = NULL;

	delete iOutputInfo;

	iOutputInfo = NULL;