// Copyright (c) 2003-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 <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include <imageconversion.h>

#include <101F7BF5_extra.rsg>

#include "TestAsyncCodec.h"

#include "TestAsyncConvert.h"

#include "TestPanic.h"

#include "TestDecs.h"

#include "TestUids.hrh"

//_LIT(KTestPanicCategory, "TestAsyncConvertPlugin");	// EABI warning removal

const TInt KDummyFileSize = 100;

const TInt KDummyHeaderSize = 10;

const TInt KDummyDataSize = KDummyFileSize - KDummyHeaderSize;

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

// CTestAsyncDecoder.

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

CTestAsyncDecoder* CTestAsyncDecoder::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestAsyncDecoder::CTestAsyncDecoder()

	{

	}

void CTestAsyncDecoder::ConstructL()

	{

	}

CTestAsyncDecoder::~CTestAsyncDecoder()

	{

	delete iScheduler;

	CImageDecoderPlugin::Cleanup();

	}

void CTestAsyncDecoder::ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType) const

	{

	__ASSERT_ALWAYS(aFrameNumber == 0, Panic(EFrameNumberOutOfRange));

	aImageType = KImageTypeTestUid;

	aImageSubType = KImageSubTypeTestUid;

	}

void CTestAsyncDecoder::ScanDataL()

	{

	SetDataLength(10);

	if (!iReadHeaders)

		{

		TPtrC8 bufferDes;

		ReadDataL(0, bufferDes, (KDummyHeaderSize));

		if (bufferDes.Length() < KDummyHeaderSize)

			User::Leave(KErrUnderflow);

		iReadHeaders = ETrue;

		SetDataLength(KDummyDataSize);

		iDecodeIterations = 0;

		// create the codec

		delete iImageReadCodec;

		iImageReadCodec = NULL;

		iImageReadCodec = CTestAsyncReadCodec::NewL(*this);

		SetImageReadCodec(iImageReadCodec);

		// create the async decoder

		delete iScheduler;

		iScheduler = NULL;

		iScheduler = new (ELeave) CAsyncScheduler(*this);

		// create a dummy TFrameInfo

		TFrameInfo imageInfo;

		imageInfo = ImageInfo();

		imageInfo.iFrameSizeInTwips.iWidth = 0;

		imageInfo.iFrameSizeInTwips.iHeight = 0;

		imageInfo.iFrameCoordsInPixels.SetRect(TPoint(0, 0), TPoint(256, 256));

		imageInfo.iOverallSizeInPixels = TSize(256, 256);

		imageInfo.iBitsPerPixel = 24;

		imageInfo.iDelay = 0;

		imageInfo.iFlags = TFrameInfo::ECanDither;

		imageInfo.iFrameDisplayMode = EColor16M;

		SetImageInfo(imageInfo);

		SetStartPosition(KDummyHeaderSize);

		ReadFrameHeadersL();

		}

	}

CFrameInfoStrings* CTestAsyncDecoder::FrameInfoStringsL(RFs& aFs, TInt aFrameNumber)

	{

	if (aFrameNumber!=0)

		User::Leave(KErrArgument);

	const TUid testCodecDllUid = {KTestDecoderDllUidValue};

	RResourceFile resourceFile;

	OpenExtraResourceFileLC(aFs,testCodecDllUid,resourceFile);

	HBufC8* resourceInfo = resourceFile.AllocReadLC(THEDECODERINFO);

	TResourceReader resourceReader;

	resourceReader.SetBuffer(resourceInfo);

	TBuf<128> info;

	TBuf<128> templte;

	CFrameInfoStrings* frameInfoStrings = CFrameInfoStrings::NewLC();

	info = resourceReader.ReadTPtrC();

	frameInfoStrings->SetDecoderL(info);

	info = resourceReader.ReadTPtrC();

	frameInfoStrings->SetFormatL(info);

	templte = resourceReader.ReadTPtrC();

	const TFrameInfo& frameInfo = FrameInfo(aFrameNumber);

	const TSize& size = frameInfo.iOverallSizeInPixels;

	info.Format(templte, size.iWidth, size.iHeight);

	frameInfoStrings->SetDimensionsL(info);

	templte = resourceReader.ReadTPtrC();

	iMaxValue = 10;

	info.Format(templte, iMaxValue);

	frameInfoStrings->SetDepthL(info);

	// leave details blank

	CleanupStack::Pop(frameInfoStrings); 

	CleanupStack::PopAndDestroy(2); // resourceInfo + resourceFile

	return frameInfoStrings;

	}

void CTestAsyncDecoder::DoConvert()

	{

	const TInt KDecodeIterations = 10;

	TRAPD(errCode, PrepareForProcessFrameL());

	if (errCode!=KErrNone)

		{

		RequestComplete(errCode);

		return;

		}

	if (iError != KErrNone)

		{

		RequestComplete(iError);

		}

	// need to get more data from client app ?

	else if (SourceData().Length() < KDummyDataSize)

		{

		RequestComplete(KErrUnderflow);

		}

	else if (iDecodeIterations++ > KDecodeIterations)

		{

		RequestComplete(iError);

		}

	else 

		{

		iDecodeState = EDecodeInit;

		iScheduler->Start();

		SetSelfPending();

		}

	}

TInt CTestAsyncDecoder::NumberOfImageComments() const

	{

	return 1;

	}

HBufC* CTestAsyncDecoder::ImageCommentL(TInt /*aCommentNumber*/) const

	{

	HBufC* imageComment = HBufC::NewL(20);

	TPtr ptr(imageComment->Des());

	ptr.Copy(_L("Test Image Comment 1"));

	return imageComment;

	}

TInt CTestAsyncDecoder::NumberOfFrameComments(TInt /*aFrameNumber*/) const

	{

	return 1;

	}

HBufC* CTestAsyncDecoder::FrameCommentL(TInt /*aFrameNumber*/, TInt /*aCommentNumber*/) const

	{

	HBufC* frameComment = HBufC::NewL(20);

	TPtr ptr(frameComment->Des());

	ptr.Copy(_L("Test Frame Comment 1"));

	return frameComment;

	}

void CTestAsyncDecoder::ProcessFrameComplete(TInt aError)

	{

	iError = aError;

	iDecodeState = EDecodeFinished;

	iScheduler->Start();

	}

void CTestAsyncDecoder::MasoProcessL(TInt aError)

	{

	iError = aError;

	if (aError != KErrNone)

		{

		SelfComplete(iError);

		return;

		}

	switch(iDecodeState)

		{

		case EDecodeInit:

			iDecodeState = EDecodeInProgress;

			iScheduler->Start();

			break;

		case EDecodeInProgress:

			TRAP(iError, iImageReadCodec->ProcessFrameL(SourceData()));

			if (iError != KErrNone)

				{

				SelfComplete(iError);

				break;

				}

			// now wait for async callback to ProcessFrameComplete...

			break;

		case EDecodeFinished:

			SelfComplete(iError);

			break;

		}

	}

void CTestAsyncDecoder::Cleanup()

	{

	// cancel the state machine

	if (iScheduler)

		iScheduler->Cancel();

	CImageDecoderPlugin::Cleanup();

	}

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

// CTestAsyncEncoder.

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

CTestAsyncEncoder* CTestAsyncEncoder::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestAsyncEncoder::CTestAsyncEncoder()

	{

	}

void CTestAsyncEncoder::ConstructL()

	{

	}

CTestAsyncEncoder::~CTestAsyncEncoder()

	{

	delete iScheduler;

	CImageEncoderPlugin::Cleanup();

	}

void CTestAsyncEncoder::DoConvert()

	{

	const TInt KEncodeIterations = 10;

/*

	TRAPD(errCode, PrepareForProcessFrameL());

	if (errCode!=KErrNone)

		{

		RequestComplete(errCode);

		return;

		}

*/

	if (iError != KErrNone)

		{

		RequestComplete(iError);

		}

	if (iEncodeIterations++ > KEncodeIterations)

		{

		RequestComplete(iError);

		}

	else 

		{

		iEncodeState = EEncodeInit;

		iScheduler->Start();

		SetSelfPending();

		}

	}

void CTestAsyncEncoder::PrepareEncoderL(const CFrameImageData* /*aFrameImageData*/)

	{

	// create the codec

	delete iImageWriteCodec;

	iImageWriteCodec = NULL;

	iImageWriteCodec = CTestAsyncWriteCodec::NewL(*this);

	SetImageWriteCodec(iImageWriteCodec);

	// create the scheduler

	delete iScheduler;

	iScheduler = NULL;

	iScheduler = new (ELeave) CAsyncScheduler(*this);

	}

void CTestAsyncEncoder::UpdateHeaderL()

	{

	}

void CTestAsyncEncoder::ProcessFrameComplete(TInt aError)

	{

	iError = aError;

	iEncodeState = EEncodeFinished;

	iScheduler->Start();

	}

void CTestAsyncEncoder::MasoProcessL(TInt aError)

	{

	iError = aError;

	if (aError != KErrNone)

		{

		SelfComplete(iError);

		return;

		}

	switch(iEncodeState)

		{

		case EEncodeInit:

			iEncodeState = EEncodeInProgress;

			iScheduler->Start();

			break;

		case EEncodeInProgress:

			TRAP(iError, iImageWriteCodec->ProcessFrameL(DestinationData()));

			if (iError != KErrNone)

				{

				SelfComplete(iError);

				break;

				}

			// now wait for async callback to ProcessFrameComplete...

			break;

		case EEncodeFinished:

			SelfComplete(iError);

			break;

		}

	}

void CTestAsyncEncoder::Cleanup()

	{

	// cancel the state machine

	if (iScheduler)

		iScheduler->Cancel();

	CImageEncoderPlugin::Cleanup();

	}

// CAsyncScheduler

CAsyncScheduler::CAsyncScheduler(MAsyncSchedulerObserver& aSchedulerObserver) : 

	CActive(CActive::EPriorityIdle), iSchedulerObserver(aSchedulerObserver)

	{

	CActiveScheduler::Add(this); 

	}

void CAsyncScheduler::Start()

	{ 

	SetActive();

	TRequestStatus* status = &iStatus; 

	User::RequestComplete(status, KErrNone);

	}

void CAsyncScheduler::RunL()

	{

	TInt error = iStatus.Int();

	iSchedulerObserver.MasoProcessL(error);

	}