// Copyright (c) 2006-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 <mmf/devvideo/devvideopuconfig.h>

#include "mdfvideodecodehwdeviceadapter.h"

#include "displaymodeutils.h"

#if defined (SYMBIAN_MDFVIDEODECODERHWDEVICE_DEBUG)

#define DEBUG_PRINT RDebug::Print

#else

#define DEBUG_PRINT

#endif // defined (SYMBIAN_MDFVIDEODECODERHWDEVICE_DEBUG)

const TInt KOutputFormatsArraySize = 3;

const TInt KTenFPS = 10;

const TInt KOneSecond = 1000000;

const TInt KInputBufferSize = 8192;

_LIT(KDevVideoHwDeviceDecoderPanicCategory, "DevVideoHwDeviceDecoder");

void DevVideoHwDeviceDecoderPanic(TInt aReason)

	{

	User::Panic(KDevVideoHwDeviceDecoderPanicCategory, aReason);

	}

/* 

 Constructs a new instance of CMdfVideoDecodeHwDeviceAdapter.

 @return    "CMdfVideoDecodeHwDeviceAdapter*"

            A pointer to the newly constructed HwDevice

 */

CMdfVideoDecodeHwDeviceAdapter* CMdfVideoDecodeHwDeviceAdapter::NewL()

	{

	CMdfVideoDecodeHwDeviceAdapter* self = new (ELeave) CMdfVideoDecodeHwDeviceAdapter;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

/*

 Default constructor

*/

CMdfVideoDecodeHwDeviceAdapter::CMdfVideoDecodeHwDeviceAdapter()

	{

	}

void CMdfVideoDecodeHwDeviceAdapter::ConstructL()

	{

	// system clock without HAL

	TInt64 tt64;

	TTime ttime;

	ttime.HomeTime();

	tt64 = ttime.Int64();

	iSystemClock = tt64;

	// reset picture format

	iFormat.iDataFormat = (TImageDataFormat)0;

	// Load the PU Loader plugin

	iPuLoader = static_cast<CMdfPuLoader*>

		(REComSession::CreateImplementationL(TUid::Uid(KUidPuLoaderImplementation), iPuLoaderDtorKey));	

	iState = EProcessingUnitLoaderLoaded;

	}

/*

 Default destructor

*/

CMdfVideoDecodeHwDeviceAdapter::~CMdfVideoDecodeHwDeviceAdapter()

	{

	DEBUG_PRINT(_L("HwDevice: Destroying"));

	// stop playing if necessary

	Stop();

	delete iPlayerEngine;

	delete iScreenDeviceGc;

	// destroy the buffer manager

	delete iBufferManager;

	// destroy the picture header

	delete iPictureHeader;	

		// Unload the DecoderPU

	if (iDecoderPU)

		{

		iPuLoader->UnloadProcessingUnit(iDecoderPU);

		}

	delete iPuLoader;	

	delete iPuData;

	delete iManufacturer;

	REComSession::DestroyedImplementation(iPuLoaderDtorKey);			

	iInputVidFormats.ResetAndDestroy(); // will destroy contents as well

	iOutputVidFormats.Close();

	iPictureRates.Close();

	DEBUG_PRINT(_L("HwDevice: Destroyed"));

	}

/*

 @see CMMFVideoHwDevice::CustomInterface()

 */

TAny* CMdfVideoDecodeHwDeviceAdapter::CustomInterface(TUid aInterface)

	{

	if (aInterface.iUid == KUidDevVideoHwDeviceAdapterSetup)

		{

		return static_cast<MDevVideoHwDeviceAdapterSetup*>(this);

		}

	return NULL;

	}

/*

 @see CMMFVideoPlayHwDevice::PostProcessorInfoLC()

 */

CPostProcessorInfo* CMdfVideoDecodeHwDeviceAdapter::PostProcessorInfoLC()

	{

	// post processor info will be obtained from the post processor plugin, if any

	return NULL;

	}

/*

 @see CMMFVideoPlayHwDevice::GetOutputFormatListL()

 */

void CMdfVideoDecodeHwDeviceAdapter::GetOutputFormatListL(RArray<TUncompressedVideoFormat>& aFormats)

	{

	// TUncompressedVideoFormats is a union - therefore using hard initialisation

	iOutputVidFormats.Reset();

	TUncompressedVideoFormat outputFormats[KOutputFormatsArraySize];

	outputFormats[0].iDataFormat = ERgbRawData;

	outputFormats[0].iRgbFormat = ERgb16bit565;

	iOutputVidFormats.AppendL(outputFormats[0]);

	aFormats.AppendL(outputFormats[0]);

	outputFormats[1].iDataFormat = ERgbFbsBitmap;

	outputFormats[1].iRgbFormat = EFbsBitmapColor16M;

	iOutputVidFormats.AppendL(outputFormats[1]);

	aFormats.AppendL(outputFormats[1]);

	outputFormats[2].iDataFormat = EYuvRawData;

	iOutputVidFormats.AppendL(outputFormats[2]);

	aFormats.AppendL(outputFormats[2]);

	}

/*

 @see CMMFVideoPlayHwDevice::SetOutputFormatL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetOutputFormatL(const TUncompressedVideoFormat& aFormat)

	{

	// check size and format are supported

	if(iOutputVidFormats.Count() == 0) 

		{

		User::Leave(KErrNotReady);

		}

	if(!iOutputVidFormats.Find(aFormat)) 

		{

		User::Leave(KErrNotSupported);

		}

	iFormat = aFormat;

	TDevVideoPlayPuConfig decodeConfig;

	decodeConfig.iImageFormat = iFormat;		

	decodeConfig.iInputBufferSize = KInputBufferSize;	

	TPuConfigVideoPlayback puConfig(decodeConfig);

	User::LeaveIfError(iDecoderPU->Configure(puConfig));

	}

/*

 @see CMMFVideoPlayHwDevice::SetClockSource()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetClockSource(MMMFClockSource* aClock)

	{

	iClockSource = aClock;

	}

/*

 @see CMMFVideoPlayHwDevice::SetVideoDestScreenL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetVideoDestScreenL(TBool aScreen)

	{

	if(aScreen) 

		{

		// NB we expect the output format to have been set before this is called

		if(!iFormat.iDataFormat) 

			{

			User::Leave(KErrNotReady);

			}

		// we support only bitmaps for DSA, not raw data

		if(iFormat.iDataFormat != ERgbFbsBitmap) 

			{

			User::Leave(KErrNotSupported);

			}

		}

	// ETrue = use DSA

	iDSAEnabled = aScreen;

	}

/*

 @see CMMFVideoPlayHwDevice::SetPostProcessTypesL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetPostProcessTypesL(TUint32 /* aPostProcCombination */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetInputCropOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetInputCropOptionsL(const TRect& /* aRect */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetYuvToRgbOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetYuvToRgbOptionsL(const TYuvToRgbOptions& /* aOptions */, const TYuvFormat& /* aYuvFormat */, TRgbFormat /* aRgbFormat */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetYuvToRgbOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetYuvToRgbOptionsL(const TYuvToRgbOptions& /* aOptions */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetRotateOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetRotateOptionsL(TRotationType /* aRotationType */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetScaleOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetScaleOptionsL(const TSize& /* aTargetSize */, TBool /* aAntiAliasFiltering */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetOutputCropOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetOutputCropOptionsL(const TRect& /* aRect */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::SetPostProcSpecificOptionsL()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetPostProcSpecificOptionsL(const TDesC8& /* aOptions */)

	{

	// the decoder is not configurable

	User::Leave(KErrNotSupported);

	}

/*

 @see CMMFVideoPlayHwDevice::Initialize()

 */

void CMdfVideoDecodeHwDeviceAdapter::Initialize()

	{

	__ASSERT_ALWAYS(iProxy, DevVideoHwDeviceDecoderPanic(0));

	TRAPD(err, InitializeL());

	if(err == KErrNone && !iPUInitialized)

		{

		err = KErrNotSupported;		

		}	

	iProxy->MdvppInitializeComplete(this, err);

	}

// private method : body of Initialize()

void CMdfVideoDecodeHwDeviceAdapter::InitializeL()

	{

	// pre-check format

	switch(iFormat.iDataFormat) 

		{

		case 0:

			User::Leave(KErrNotReady);

			break;

		case ERgbRawData:

		case ERgbFbsBitmap:

		case EYuvRawData:

			break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	// create and initialise the buffer manager

	iBufferManager = CMdfVideoDecoderBufferManager::NewL();

	iBufferManager->Init(iFormat);

	iBufferManager->SetFrameSize(iFrameSize);

	DEBUG_PRINT(_L("HwDevice: Buffer Manager initialized"));

	// The actual frame rate will come from the VOL headers.

	iFrameRate = KTenFPS;

	// reset the player flags

	iPrimed = EFalse;

	iInputBufferWaiting = EFalse;	

	iInputEnd = EFalse;

	// create the player engine

	iPlayerEngine = CMdfVideoPlayerEngine::NewL(*this);

	RPointerArray<MMdfInputPort> inputPorts;

	// Get ports and set observers

	User::LeaveIfError(iDecoderPU->GetInputPorts(inputPorts));

	if (inputPorts.Count()==0)

		{

		inputPorts.Close();

		User::Leave(KErrNotFound);

		}

	iDecoderPUInputPort = inputPorts[0];

	iDecoderPUInputPort->MipSetObserver(*this);

	inputPorts.Close();

	RPointerArray<MMdfOutputPort> outputPorts;

	User::LeaveIfError(iDecoderPU->GetOutputPorts(outputPorts));

	if (outputPorts.Count()==0)

		{

		outputPorts.Close();

		User::Leave(KErrNotFound);

		}

	iDecoderPUOutputPort = outputPorts[0];

	iDecoderPUOutputPort->MopSetObserver(*this);

	outputPorts.Close();

	iState = EProcessingUnitLoaded;

	DEBUG_PRINT(_L("HwDevice: Decoder Processing Unit Loaded"));

	// Create the buffers that are associated with the input and output ports

	iInputBuffer = &iBufferManager->CreateDataBufferL(iDecoderPUInputPort->MipBufferSize());

	iPUInputBuffer = *iInputBuffer;

	User::LeaveIfError(iDecoderPUInputPort->MipUseBuffer(*iPUInputBuffer));		

	CVideoFrameBuffer& frameBuffer = iBufferManager->CreateFrameBufferL(TMMFDisplayModeUtils::DisplayMode(iFormat.iRgbFormat));

	User::LeaveIfError(iDecoderPUOutputPort->MopUseBuffer(frameBuffer));

	// VD: should not move the set up of the state after sending the Initialize() calls???

	iState = EProcessingUnitInitializing;

	// async call, that calls back to InitializeComplete()

	iDecoderPU->Initialize();	

	DEBUG_PRINT(_L("HwDevice: Initialized OK"));

	}

/*

 @see CMMFVideoPlayHwDevice::StartDirectScreenAccessL()

 */

void CMdfVideoDecodeHwDeviceAdapter::StartDirectScreenAccessL(const TRect& aVideoRect, CFbsScreenDevice& aScreenDevice, const TRegion& aClipRegion)

	{

	// ensure SetVideoDestScreenL() has been called

	if(!iDSAEnabled)

		{

		User::Leave(KErrNotReady);

		}

	DEBUG_PRINT(_L("HwDevice: Starting DSA"));

	iDSAStarted = ETrue;

	// the CDirectScreenAccess must be created by the client app.

	// the CFbsScreenDevice (only) is passed across...

	// we need to blit the bitmap into it, i.e. we need to create our own GC

	if(!iScreenDevice) 

		{		

		User::LeaveIfError(aScreenDevice.CreateContext(iScreenDeviceGc));

		iScreenDevice = &aScreenDevice;

		iScreenDeviceRect = aVideoRect;

		iScreenDeviceGc->SetClippingRegion(aClipRegion);

		}

	}

/*

 @see CMMFVideoPlayHwDevice::SetScreenClipRegion()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetScreenClipRegion(const TRegion& aRegion)

	{

	__ASSERT_ALWAYS(iScreenDeviceGc, DevVideoHwDeviceDecoderPanic(0));

	iScreenDeviceGc->SetClippingRegion(aRegion);

	}

/*

 @see CMMFVideoPlayHwDevice::SetPauseOnClipFail()

 */

void CMdfVideoDecodeHwDeviceAdapter::SetPauseOnClipFail(TBool /* aPause */)

	{

	// not implemented - will pause by default

	}

/*

 @see CMMFVideoPlayHwDevice::AbortDirectScreenAccess()

 */

void CMdfVideoDecodeHwDeviceAdapter::AbortDirectScreenAccess()

	{

	DEBUG_PRINT(_L("HwDevice: Stopping DSA"));

	iDSAStarted = EFalse;

	}

/*

 @see CMMFVideoPlayHwDevice::IsPlaying()

 */

TBool CMdfVideoDecodeHwDeviceAdapter::IsPlaying()

	{

	return (iState == EProcessingUnitExecuting ? ETrue : EFalse);

	}

/*

 @see CMMFVideoPlayHwDevice::Redraw()

 */

void CMdfVideoDecodeHwDeviceAdapter::Redraw()

	{

	if(iDSAStarted) 

		{

		DisplayLastFrameDirect(); 

		}

	}

/*

 @see CMMFVideoPlayHwDevice::Start()

 */

void CMdfVideoDecodeHwDeviceAdapter::Start()

	{

	__ASSERT_ALWAYS(iPlayerEngine, DevVideoHwDeviceDecoderPanic(0));

	__ASSERT_ALWAYS(iDecoderPU, DevVideoHwDeviceDecoderPanic(0));

	if(iState != EProcessingUnitExecuting)

		{		

		CVideoFrameBuffer* frameBuffer = NULL;

		TRAPD(err, frameBuffer = &iBufferManager->GetEmptyFrameBufferL(ETrue));

		if (err != KErrNone)

			{

			iProxy->MdvppFatalError(this, err);

			return;

			}

		iDecoderPUOutputPort->MopReadData(*frameBuffer);

		iDecoderPU->Execute();

		TProcessingUnitState puState = iDecoderPU->State();

		if(puState == EProcessingUnitInvalid) 

			{

			return;	

			}

		iState = EProcessingUnitExecuting;

		// if we are using raw decoding, then play as fast as we can,

		// otherwise use the actual frame rate

		TInt playerFrameRate;

		if(iSynchronize) 

			{

			playerFrameRate = TInt(iFrameRate);

			}

		else 

			{

			playerFrameRate = CMdfVideoPlayerEngine::KUnsynchronized;

			}

		TRAP(err, iPlayerEngine->StartL(playerFrameRate));			

		if(err != KErrNone) 

			{

			// the player failed to start. this is a fatal error

			iProxy->MdvppFatalError(this, err);

			}

		else 

			{			

			iProxy->MdvppNewBuffers();

			}

		}

	}

/*

 @see CMMFVideoPlayHwDevice::Stop()

 */

void CMdfVideoDecodeHwDeviceAdapter::Stop()

	{

	if(iState == EProcessingUnitExecuting)

		{

		iPlayerEngine->Stop();

		iDecoderPU->Stop();		

		iState = EProcessingUnitIdle;

		}

	}

/*

 @see CMMFVideoPlayHwDevice::Pause()

 */

void CMdfVideoDecodeHwDeviceAdapter::Pause()

	{

	Stop();

	}

/*

 @see CMMFVideoPlayHwDevice::Resume()

 */