// 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()

  */

 void CMdfVideoDecodeHwDeviceAdapter::Resume()

 	{

 	Start();

 	}

 /*

  @see CMMFVideoPlayHwDevice::SetPosition()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SetPosition(const TTimeIntervalMicroSeconds& aPlaybackPosition)

 	{

 	TPuConfigTimestamp timeStamp(aPlaybackPosition);

 	// we have no way report a failure here, and it is not a fatal error so any error is ignored

 	iDecoderPU->Configure(timeStamp);

 	}

 /*

  @see CMMFVideoPlayHwDevice::FreezePicture()

  */

 void CMdfVideoDecodeHwDeviceAdapter::FreezePicture(const TTimeIntervalMicroSeconds& /* aTimestamp */)

 	{

 	// not supported; we have no presentation timestamps

 	// however should not cause a fatal error

 	}

 /*

  @see CMMFVideoPlayHwDevice::ReleaseFreeze()

  */

 void CMdfVideoDecodeHwDeviceAdapter::ReleaseFreeze(const TTimeIntervalMicroSeconds& /* aTimestamp */)

 	{

 	// not supported; we have no presentation timestamps

 	// however should not cause a fatal error

 	}

 /*

  @see CMMFVideoPlayHwDevice::PlaybackPosition()

  */

 TTimeIntervalMicroSeconds CMdfVideoDecodeHwDeviceAdapter::PlaybackPosition()

 	{

 	if(iFrameRate == 0.0) 

 		{

 		return 0;

 		}

 	// this is the total number of pictures displayed or discarded

 	// NB it is NOT equivalent to the number of pictures decoded, as the

 	// player may be running a few frames behind the decoder	

 	return ((iPictureCounters.iPicturesDisplayed + iPictureCounters.iPicturesSkipped) * (KOneSecond / (TInt)iFrameRate));

 	}

 /*

  @see CMMFVideoPlayHwDevice::PictureBufferBytes()

  */

 TUint CMdfVideoDecodeHwDeviceAdapter::PictureBufferBytes()

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	return (iBufferManager->FrameBufferSize() * iBufferManager->MaxFrameBuffers());

 	}

 /*

  @see CMMFVideoPlayHwDevice::GetPictureCounters()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetPictureCounters(CMMFDevVideoPlay::TPictureCounters& aCounters)

 	{

 	aCounters = iPictureCounters;

 	}

 /*

  @see CMMFVideoPlayHwDevice::SetComplexityLevel()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SetComplexityLevel(TUint /* aLevel */)

 	{

 	// separate complexity levels are not available; ignored

 	}

 /*

  @see CMMFVideoPlayHwDevice::NumComplexityLevels()

  */

 TUint CMdfVideoDecodeHwDeviceAdapter::NumComplexityLevels()

 	{

 	// separate complexity levels are not available; return 1

 	return 1;

 	}

 /*

  @see CMMFVideoPlayHwDevice::GetComplexityLevelInfo()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetComplexityLevelInfo(TUint aLevel, CMMFDevVideoPlay::TComplexityLevelInfo& aInfo)

 	{

 	// ignore call if aLevel is not 0

 	if(aLevel == 0) 

 		{

 		aInfo = iComplexityLevelInfo;

 		}

 	}

 /*

  @see CMMFVideoPlayHwDevice::ReturnPicture()

  */

 void CMdfVideoDecodeHwDeviceAdapter::ReturnPicture(TVideoPicture* aPicture)

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	// return the frame buffer that has been emptied

 	TRAPD(err, iBufferManager->ReturnFrameBufferL(*aPicture, CVideoFrameBuffer::EEmptied));

 	if (err == KErrNone)

 		{

 		if (!iLastFrameBufferReceived)

 			{

 			// request the next empty frame buffer

 			CVideoFrameBuffer* frameBuffer = NULL;

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

 			if (err == KErrNone)

 				{

 				CMMFBuffer* buffer = *frameBuffer;

 				iDecoderPUOutputPort->MopReadData(*buffer);

 				}

 			}

 		// DoPostPictureNotify() will handle MdvppStreamEnd()	

 		}

 	else

 		{

 		iProxy->MdvppFatalError(this, err);

 		}

 	ASSERT(err == KErrNone);

 	DoPostPictureNotify();

 	}

 /*

  @see CMMFVideoPlayHwDevice::GetSnapshotL()

  */

 TBool CMdfVideoDecodeHwDeviceAdapter::GetSnapshotL(TPictureData& /*aPictureData*/, const TUncompressedVideoFormat& /*aFormat*/)

 	{

 	// not supported - no presentation timestamps

 	User::Leave(KErrNotSupported);

 	return EFalse;

 	}

 /*

  @see CMMFVideoPlayHwDevice::GetTimedSnapshotL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetTimedSnapshotL(TPictureData* /*aPictureData*/, const TUncompressedVideoFormat& /*aFormat*/, const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/)

 	{

 	// this method should be called on the post processor not on the decoder

 	// ending up here is a programming error and hence a PANIC condition

 	DevVideoHwDeviceDecoderPanic(0);

 	}

 /*

  @see CMMFVideoPlayHwDevice::GetTimedSnapshotL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetTimedSnapshotL(TPictureData* /*aPictureData*/, const TUncompressedVideoFormat& /*aFormat*/, const TPictureId& /*aPictureId*/)

 	{

 	// this method should be called on the post processor not on the decoder

 	// ending up here is a programming error and hence a PANIC condition

 	DevVideoHwDeviceDecoderPanic(0);

 	}

 /*

  @see CMMFVideoPlayHwDevice::CancelTimedSnapshot()

  */

 void CMdfVideoDecodeHwDeviceAdapter::CancelTimedSnapshot()

 	{

 	// this method should be called on the post processor not on the decoder

 	// ending up here is a programming error and hence a PANIC condition

 	DevVideoHwDeviceDecoderPanic(0);

 	}

 /*

  @see CMMFVideoPlayHwDevice::GetSupportedSnapshotFormatsL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetSupportedSnapshotFormatsL(RArray<TUncompressedVideoFormat>& /*aFormats*/)

 	{

 	// this method should be called on the post processor not on the decoder

 	// ending up here is a programming error and hence a PANIC condition

 	DevVideoHwDeviceDecoderPanic(0);

 	}

 /*

  @see CMMFVideoPlayHwDevice::InputEnd()

  */

 void CMdfVideoDecodeHwDeviceAdapter::InputEnd()

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	DEBUG_PRINT(_L("HwDevice: Input end"));

 	iInputEnd = ETrue;

 	// if there isn't an outstanding write to the PU, write

 	// an empty buffer	

 	if(!iWriteRequestOutstanding) 

 		{

 		SendLastBuffer();

 		}

 	}

 /*

  @see CMMFVideoDecodeHwDevice::VideoDecoderInfoLC()

  */

 CVideoDecoderInfo* CMdfVideoDecodeHwDeviceAdapter::VideoDecoderInfoLC()

 	{

 	// this is a complicated structure, ensure all fields are

 	// filled with some valid value

 	//if PU is not loaded panic

 	if(iPuData == NULL)	

 		{

 		DevVideoHwDeviceDecoderPanic(KErrNotReady);	

 		}

 	// supported formats array

 	iInputVidFormats.Reset();

 	CCompressedVideoFormat* vidCV = NULL;

 	vidCV = CCompressedVideoFormat::NewL(iPuData->InputDataType() , KNullDesC8);

 	CleanupStack::PushL(vidCV);

 	iInputVidFormats.AppendL(vidCV);

 	CleanupStack::Pop(vidCV);	// CCompressedVideo object is destroyed in destructor

 	// construct the video decoder info object

 	CVideoDecoderInfo* vInfo = CVideoDecoderInfo::NewL(

 		iPuUid, 

 		*iManufacturer,

 		KNullDesC,

 		TVersion(KVideoDecoderInfoVersionMaj, KVideoDecoderInfoVersionMin, KVideoDecoderInfoVersionBuild),

 		iInputVidFormats.Array(),

 		EFalse, // not accelerated

 		ETrue, // supports direct screen access

 		iMaxPictureSize, 

 		KMaxTUint32, // max bitrate supported

 		iPuData->MaxPictureRates().Array(),

 		EFalse, // picture loss not supported,

 		EFalse, // slice loss not supported,

 		KVideoDecoderInfoCSInfo,

 		KVideoDecoderInfoISInfo );

 	CleanupStack::PushL(vInfo);

 	return vInfo;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::GetHeaderInformationL()

  */

 TVideoPictureHeader* CMdfVideoDecodeHwDeviceAdapter::GetHeaderInformationL(TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation, TVideoInputBuffer* aDataUnit)

 	{

 	// NB this may be called EITHER before OR after the decoder is initialized.

 	// ensure at least that SetOutputFormatL() has been called before this, 

 	// as the decoder requires it to be able to initialize.

 	__ASSERT_ALWAYS(iFormat.iDataFormat, DevVideoHwDeviceDecoderPanic(0));

 	TDevVideoHeaderPuConfig header;

 	header.iDataUnitType = aDataUnitType;

 	header.iDataUnitEncapsulation = aEncapsulation;

 	header.iHeaderData.Set(aDataUnit->iData.Ptr(),aDataUnit->iData.Size());

 	TPuConfigVideoHeader headerConfig(header);

 	// Configure the decoder with the Header Information

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

 	// retrieve the picture information from the config structure

 	TPuConfigVideoPictureHeader pict; 

 	User::LeaveIfError(iDecoderPU->GetConfig(pict));

 	delete iPictureHeader;

 	iPictureHeader = NULL;

 	// Create a new header from the returned data

 	iPictureHeader = new (ELeave)TVideoPictureHeader(

 							*TPuConfigVideoPictureHeader::GetStructure(pict));

 	iFrameSize = iPictureHeader->iSizeInMemory;

 	return iPictureHeader;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::ConfigureDecoderL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::ConfigureDecoderL(const TVideoPictureHeader& /* aVideoPictureHeader */)

 	{

 	// there is nothing configurable

 	User::Leave(KErrNotSupported);

 	}

 /*

  @see CMMFVideoDecodeHwDevice::ReturnHeader()

  */

 void CMdfVideoDecodeHwDeviceAdapter::ReturnHeader(TVideoPictureHeader* aHeader)

 	{

 	if(aHeader == iPictureHeader) // only free our created header

 		{

 		delete iPictureHeader;

 		iPictureHeader = NULL;	

 		}

 	}

 /*

  @see CMMFVideoDecodeHwDevice::SetInputFormatL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SetInputFormatL(const CCompressedVideoFormat& aFormat, TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation, TBool aDataInOrder)

 	{

 	// EDuCodedPicture, EDuElementaryStream, aDataInOrder == ETrue

 	if(aFormat.MimeType() != iPuData->InputDataType()) 

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	if(aDataUnitType != EDuCodedPicture) 

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	if(aEncapsulation != EDuElementaryStream) 

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	if(!aDataInOrder) 

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	}

 /*

  @see CMMFVideoDecodeHwDevice::SynchronizeDecoding()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SynchronizeDecoding(TBool aSynchronize)

 	{

 	iSynchronize = aSynchronize;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::SetBufferOptionsL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SetBufferOptionsL(const CMMFDevVideoPlay::TBufferOptions& aOptions)

 	{

 	// check values are within the constraints of this device

 	if(aOptions.iPreDecoderBufferPeriod != 0) 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(aOptions.iMaxPostDecodeBufferSize != 0) 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(aOptions.iPreDecoderBufferPeriod != 0) 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(aOptions.iPostDecoderBufferPeriod != 0) 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(aOptions.iMaxInputBufferSize > KVideoDecoderMaxDataBufferSize) 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(aOptions.iMinNumInputBuffers > 1) 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	// input is OK; write it

 	iBufferOptions = aOptions;	

 	}

 /*

  @see CMMFVideoDecodeHwDevice::GetBufferOptions()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetBufferOptions(CMMFDevVideoPlay::TBufferOptions& aOptions)

 	{

 	aOptions = iBufferOptions;	

 	}

 /*

  @see CMMFVideoDecodeHwDevice::SetHrdVbvSpec()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SetHrdVbvSpec(THrdVbvSpecification /* aHrdVbvSpec */, const TDesC8& /* aHrdVbvParams */)

 	{

 	// the decoder is not configurable

 	// however this should not cause a fatal error

 	}

 /*

  @see CMMFVideoDecodeHwDevice::SetOutputDevice()

  */

 void CMdfVideoDecodeHwDeviceAdapter::SetOutputDevice(CMMFVideoPostProcHwDevice* aDevice)

 	{

 	// we allow output to be sent to a post-processor,

 	// even though this plugin doesn not itself provide one

 	iPostProcOutputDevice = aDevice;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::DecodingPosition()

  */

 TTimeIntervalMicroSeconds CMdfVideoDecodeHwDeviceAdapter::DecodingPosition()

 	{

 	if(iFrameRate == 0.0) 

 		{

 		return 0;

 		}

 	// this is the total number of pictures decoded	

 	return (iPictureCounters.iPicturesDecoded * (KOneSecond / (TInt)iFrameRate));

 	}

 /*

  @see CMMFVideoDecodeHwDevice::PreDecoderBufferBytes()

  */

 TUint CMdfVideoDecodeHwDeviceAdapter::PreDecoderBufferBytes()

 	{

 	return 0;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::GetBitstreamCounters()

  */

 void CMdfVideoDecodeHwDeviceAdapter::GetBitstreamCounters(CMMFDevVideoPlay::TBitstreamCounters& aCounters)

 	{

 	aCounters = iBitstreamCounters;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::NumFreeBuffers()

  */

 TUint CMdfVideoDecodeHwDeviceAdapter::NumFreeBuffers()

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	if(!FrameBufferAvailable()) 

 		{

 		// if there are too many output buffers waiting, we refuse an input buffer

 		// until some output buffers have been processed.

 		return 0;

 		}

 	else 

 		{

 		return (iBufferManager->DataBuffersAvailable());

 		}

 	}

 /*

  @see CMMFVideoDecodeHwDevice::GetBufferL()

  This will return a buffer of the requested size, within min/max constraints

  */

 TVideoInputBuffer* CMdfVideoDecodeHwDeviceAdapter::GetBufferL(TUint /* aBufferSize */)

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	TVideoInputBuffer& buf = iBufferManager->GetDataBufferL();

 	return &buf;

 	}

 /*

  @see CMMFVideoDecodeHwDevice::WriteCodedDataL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::WriteCodedDataL(TVideoInputBuffer* aInputBuffer)

 	{

 	// Leave on null input buffer

 	if(!aInputBuffer) 

 		{

 		User::Leave(KErrArgument);

 		}

 	// increment received buffer count

 	iBitstreamCounters.iTotalPackets++;

 	CMMFDataBuffer* dataBuffer = static_cast<CMMFDataBuffer*>(iPUInputBuffer);

 	dataBuffer->Data().SetLength(aInputBuffer->iData.Length());

 	dataBuffer->SetPosition(0);

 	iDecoderPUInputPort->MipWriteData(*iPUInputBuffer);

 	iWriteRequestOutstanding = ETrue;	

 	}

 /*

  @see CMMFVideoPlayHwDevice::CommitL()

  */

 void CMdfVideoDecodeHwDeviceAdapter::CommitL()

 	{

 	// the decoder is not configurable

 	User::Leave(KErrNotSupported);

 	}

 /*

  @see CMMFVideoPlayHwDevice::Revert()

  */

 void CMdfVideoDecodeHwDeviceAdapter::Revert()

 	{

 	// the decoder is not configurable

 	// however this should not cause a fatal error

 	}

 void CMdfVideoDecodeHwDeviceAdapter::SetProxy(MMMFDevVideoPlayProxy& aProxy)

 	{

 	ASSERT(!iProxy);

 	iProxy = &aProxy;

 	}

 /*

  @see MMdfDecoderHwDeviceObserver::FrameBufferAvailable()

  */

 TBool CMdfVideoDecodeHwDeviceAdapter::FrameBufferAvailable() const

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	return (iBufferManager->EmptyFrameBuffersAvailable() > 0);

 	}

 /*

  @see MMdfVideoPlayerHwDeviceObserver::Time()

  */

 TUint CMdfVideoDecodeHwDeviceAdapter::Time() const 

 	{

 	if(iClockSource) 

 		{

 		return iClockSource->Time().Int64();

 		}

 	else 

 		{

 		// system clock without HAL

 		TInt64 tt64;

 		TTime ttime;

 		ttime.HomeTime();

 		tt64 = ttime.Int64();

 		return (tt64 - iSystemClock);

 		}

 	}

 /*

  @see MMdfVideoPlayerHwDeviceObserver::DisplayFrame()

  */

 void CMdfVideoDecodeHwDeviceAdapter::DisplayFrame()

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	CVideoFrameBuffer* frameBuffer = NULL;

 	TRAPD(err, frameBuffer = &iBufferManager->GetFilledFrameBufferL(EFalse));

 	if(err != KErrNone) 

 		{

 		// the buffer manager has failed

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

 		iProxy->MdvppFatalError(this, err);

 		}

 	else	

 		{

 		// is this the last buffer?

 		iLastFrameBufferReceived = frameBuffer->LastBuffer();

 		TVideoPicture& thePicture = *frameBuffer;

 		// increment picture counter

 		CMMFBuffer& theBuffer = *frameBuffer;

 		if(theBuffer.BufferSize()) 

 			{

 			iPictureCounters.iPicturesDisplayed++;

 			}

 		iDisplayPictureAvailable = EFalse;

 		// send it to post-processor output, DSA, or the client

 		if(iPostProcOutputDevice) 

 			{

 			TRAP(err, iPostProcOutputDevice->WritePictureL(&thePicture));

 			}

 		else if(iDSAStarted) 

 			{

 			DisplayFrameDirect(&thePicture);

 			TRAP(err, iBufferManager->ReturnFrameBufferL(thePicture, CVideoFrameBuffer::EEmptied));

 			if (!iLastFrameBufferReceived)

 				{

 				CVideoFrameBuffer* frameBuffer = NULL;

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

 				if (err == KErrNone)

 					{

 					iDecoderPUOutputPort->MopReadData(*frameBuffer);

 					}

 				else 

 					{

 					iProxy->MdvppFatalError(this, err);		

 					return;

 					}

 				}

 			// DoPostPictureNotify() will handle MdvppStreamEnd()	

 			// NB we need to notify the client here as there will be no callback

 			DoPostPictureNotify(); 

 			}

 		else 

 			{

 			iProxy->MdvppNewPicture(&thePicture);

 			}

 		}

 	}

 /*

  @see MMdfVideoPlayerHwDeviceObserver::DiscardFrame()

  */

 void CMdfVideoDecodeHwDeviceAdapter::DiscardFrame()

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

 	CVideoFrameBuffer* frameBuffer = NULL;

 	TVideoPicture* thePicture = NULL;

 	TRAPD(err, frameBuffer = &iBufferManager->GetFilledFrameBufferL(EFalse));

 	if(err != KErrNone) 

 		{

 		// the buffer manager has failed

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

 		iProxy->MdvppFatalError(this, err);

 		}

 	else	

 		{

 		thePicture = *frameBuffer;

 		// increment picture counter

 		CMMFBuffer& theBuffer = *frameBuffer;

 		if(theBuffer.BufferSize()) 

 			{

 			iPictureCounters.iPicturesSkipped++;	

 			}

 		iDisplayPictureAvailable = EFalse;

 		// this should never leave, as thePicture has been given to us by 

 		// iBufferManager to start with.

 		TRAP(err, iBufferManager->ReturnFrameBufferL(*thePicture, CVideoFrameBuffer::EEmptied));

 		if (err != KErrNone)

 			{			

 			DEBUG_PRINT(_L("HwDevice: ReturnFrameBufferL failed"));

 			iProxy->MdvppFatalError(this, err);

 			}		

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

 		if (err == KErrNone)

 			{

 			iDecoderPUOutputPort->MopReadData(*frameBuffer);

 			}

 		// NB we need to notify the client here as there will be no callback

 		DoPostPictureNotify(); 

 		}

 	}

 /*

  @see MMdfVideoPlayerHwDeviceObserver::FrameAvailable()

  */

 TBool CMdfVideoDecodeHwDeviceAdapter::FrameAvailable() const

 	{

 	return iDisplayPictureAvailable;

 	}

 /*

  @see MMdfInputPortObserver::MipoWriteDataComplete()

  */

 void CMdfVideoDecodeHwDeviceAdapter::MipoWriteDataComplete(const MMdfInputPort* aInputPort,

 		CMMFBuffer* /* aBuffer */, TInt aErrorCode)

 	{

 	iWriteRequestOutstanding = EFalse;

 	__ASSERT_ALWAYS(aInputPort == iDecoderPUInputPort, DevVideoHwDeviceDecoderPanic(0));

 	if (aErrorCode != KErrNone)

 		{

 		iProxy->MdvppFatalError(this, aErrorCode);

 		return;

 		}

 	// Return the data buffer, the position tells us how much data

 	// was used	

 	if (!iInputEnd)

 		{

 		TRAPD(err, iBufferManager->ReturnDataBufferL(*iInputBuffer));

 		if(err == KErrNone)

 			{

 			iProxy->MdvppNewBuffers();

 			}	

 		else

 			{

 			iProxy->MdvppFatalError(this, err);

 			}

 		}

 	else

 		{

 		// Send an empty buffer to the decoder to signal the

 		// end of the stream

 		SendLastBuffer();

 		}

 	}

 /*

  @see MMdfInputPortObserver::MipoStopComplete()

  */		

 void CMdfVideoDecodeHwDeviceAdapter::MipoDisconnectTunnelComplete(const MMdfInputPort* /* aInputPort */,

 	TInt /* aErrorCode */)

 	{	

 	}

 /*

  @see MMdfInputPortObserver::MipoRestartComplete()

  */		

 void CMdfVideoDecodeHwDeviceAdapter::MipoRestartTunnelComplete(const MMdfInputPort* /* aInputPort */,

 	TInt /* aErrorCode */)

 	{	

 	}

 /*

  @see MMdfOutputPortObserver::MopoReadDataComplete()

  */

 void CMdfVideoDecodeHwDeviceAdapter::MopoReadDataComplete(const MMdfOutputPort* aOutputPort,

 	CMMFBuffer* aBuffer, TInt aErrorCode)	

 	{

 	if(aErrorCode != KErrNone)

 		{

 		iProxy->MdvppFatalError(this, aErrorCode);

 		return;

 		}

 	if(aOutputPort != iDecoderPUOutputPort)

 		{

 		iProxy->MdvppFatalError(this, KErrArgument);

 		return;

 		}

 	// increment iPicturesDecoded

 	if(aBuffer->BufferSize())

 		{

 		iPictureCounters.iPicturesDecoded++; 

 		}

 	iDisplayPictureAvailable = ETrue;

 	TRAPD(err, iBufferManager->ReturnFrameBufferL(aBuffer, CVideoFrameBuffer::EFilled, aBuffer->LastBuffer()));

 	if(err != KErrNone)

 		{

 		iProxy->MdvppFatalError(this, err);

 		}			

 	}

 /*

  @see MMdfOutputPortObserver::MopoStopComplete()

  */	

 void CMdfVideoDecodeHwDeviceAdapter::MopoDisconnectTunnelComplete(const MMdfOutputPort* /* aOutputPort */,

 	TInt /* aErrorCode */)

 	{	

 	}

 /*

  @see MMdfOutputPortObserver::MopoRestartComplete()

  */	

 void CMdfVideoDecodeHwDeviceAdapter::MopoRestartTunnelComplete(const MMdfOutputPort* /* aOutputPort */,

 	TInt /* aErrorCode */)

 	{	

 	}

 /*

  @see MMdfProcessingUnitObserver::InitializeComplete()

  */	

 void CMdfVideoDecodeHwDeviceAdapter::InitializeComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode)

 	{

 	__ASSERT_ALWAYS(aPu == iDecoderPU, DevVideoHwDeviceDecoderPanic(0));

 	if(aErrorCode != KErrNone)

 		{

 		iProxy->MdvppFatalError(this, aErrorCode);

 		return;

 		}

 	iPUInitialized = ETrue;	

 	}

 /*

  @see MMdfProcessingUnitObserver::ExecuteComplete()

  */	

 void CMdfVideoDecodeHwDeviceAdapter::ExecuteComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode)

 	{

 	__ASSERT_ALWAYS(aPu == iDecoderPU, DevVideoHwDeviceDecoderPanic(0));

 	if(aErrorCode != KErrNone)

 		{

 		iProxy->MdvppFatalError(this, aErrorCode);

 		return;

 		}	

 	if (iState == EProcessingUnitExecuting)

 		{

 		DEBUG_PRINT(_L("HwDevice: 3() - Stream end"));

 		iProxy->MdvppStreamEnd();

 		iState = EProcessingUnitIdle;

 		}			

 	}	

 // private method - DoPostPictureNotify

 void CMdfVideoDecodeHwDeviceAdapter::DoPostPictureNotify()

 	{

 	__ASSERT_ALWAYS(iBufferManager, DevVideoHwDeviceDecoderPanic(0));

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

 	// notify the client that an input buffer is available if we weren't able to

 	// do it before

 	if(iInputBufferWaiting && iBufferManager->DataBuffersAvailable()) 

 		{

 		iInputBufferWaiting = EFalse;

 		iProxy->MdvppNewBuffers();

 		}

 	// at this point, if there are no frames left, the input buffer is free

 	// and InputEnd() has been called, then we have finished.

 	if(iInputEnd && !iBufferManager->FilledFrameBuffersAvailable() && iBufferManager->DataBuffersAvailable()) 

 		{

 		iLastFrameBufferReceived = ETrue;

 		}

 	// NB iLastFrameBufferReceived may have been set beforehand

 	if(iLastFrameBufferReceived)

 		{

 		DEBUG_PRINT(_L("HwDevice: Stream end"));

 		iProxy->MdvppStreamEnd();

 		}

 	}

 // private method - display the frame using direct screen access

 void CMdfVideoDecodeHwDeviceAdapter::DisplayFrameDirect(TVideoPicture* aPicture) 

 	{

 	__ASSERT_ALWAYS(iScreenDevice, DevVideoHwDeviceDecoderPanic(0));

 	DEBUG_PRINT(_L("HwDevice: Displaying frame using DSA"));

 	// draw into our GC

 	// NB this will only work if the picture is a CFbsBitmap

 	CFbsBitmap* theBitmap = aPicture->iData.iRgbBitmap;

 	iScreenDeviceGc->DrawBitmap(iScreenDeviceRect, theBitmap);

 	iScreenDevice->Update();	

 	}

 // private method - display the last frame using direct screen access

 void CMdfVideoDecodeHwDeviceAdapter::DisplayLastFrameDirect() 

 	{

 	__ASSERT_ALWAYS(iScreenDevice, DevVideoHwDeviceDecoderPanic(0));

 	DEBUG_PRINT(_L("HwDevice: Redrawing last frame using DSA"));

 	// redraw

 	// NB this will only work if the picture is a CFbsBitmap

 	const TPictureData* lastFrame = NULL;

 	TRAPD(err, lastFrame = &iBufferManager->LastPictureL());

 	if(!err) 

 		{

 		CFbsBitmap* theBitmap = lastFrame->iRgbBitmap;

 		iScreenDeviceGc->DrawBitmap(iScreenDeviceRect, theBitmap);

 		iScreenDevice->Update();

 		}

 	}

 void CMdfVideoDecodeHwDeviceAdapter::LoadProcessingUnitL(const CImplementationInformation& aImplInfo)

 	{

 	__ASSERT_ALWAYS(iPuLoader, DevVideoHwDeviceDecoderPanic(0));

 	iPuUid = aImplInfo.ImplementationUid();

 	iDecoderPU = iPuLoader->LoadProcessingUnitL(*this, iPuUid);	

 	// store the opaque data associated with this PU so we can extract information about 

 	// the PU later

 	iPuData = CCodecApiVideoOpaqueData::NewL(aImplInfo.OpaqueData());

 	iManufacturer = HBufC::NewL(iPuData->Manufacturer().Length());

 	iManufacturer->Des().Copy(iPuData->Manufacturer());

 	iMaxPictureSize = iPuData->MaxPictureSize();

 	}

 void CMdfVideoDecodeHwDeviceAdapter::SendLastBuffer()

 	{

 	__ASSERT_ALWAYS(iPUInputBuffer, DevVideoHwDeviceDecoderPanic(0));

 	__ASSERT_ALWAYS(iDecoderPUInputPort, DevVideoHwDeviceDecoderPanic(0));

 	// Send an empty buffer to the decoder to signal the

 	// end of the stream

 	iPUInputBuffer->SetLastBuffer(ETrue);

 	CMMFDataBuffer* dataBuffer = static_cast<CMMFDataBuffer*>(iPUInputBuffer);

 	dataBuffer->Data().SetLength(0);

 	dataBuffer->SetPosition(0);

 	iDecoderPUInputPort->MipWriteData(*iPUInputBuffer);	

 	}