// 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 "mdfvideoencodehwdeviceadapter.h"

 #include <mmf/server/mmfdatabuffer.h>

 #include <mmf/devvideo/devvideobase.h>

 #include <mmf/devvideo/devvideopuconfig.h>

 #include <mmf/server/mmfdatabuffer.h>

 // Literal descriptor for the encoder's info

 _LIT8(KEncoderInfoCSInfo, "Coded by Symbian");

 // Literal descriptor for the encoder's implementation info

 _LIT8(KEncoderInfoISInfo, "Implemented by Symbian");

 // Literal descriptor for the video encoder panic

 _LIT(KDevVideoEncoderPanicCategory, "DevVideoEncoder");

 // Processing unit's input port index

 const TInt KEncoderPUInputPortIndex  = 0;

 // Processing unit's output port index

 const TInt KEncoderPUOutputPortIndex = 0;

 // Processing unit's major version number

 const TInt KEncoderPUInfoVersionMaj = 0;

 // Processing unit's minor version number

 const TInt KEncoderPUInfoVersionMin = 1;

 // Processing unit's build version number

 const TInt KEncoderPUInfoVersionBuild = 1;

 // Bytes per pixel

 const TInt KBytesPerPixel = 3;

 void DevVideoEncoderPanic(TInt aReason)

 	{

 	User::Panic(KDevVideoEncoderPanicCategory, aReason);

 	}

 /** 

  Constructs a new instance of CMdfVideoEncodeHwDeviceAdapter.

  @return    "CMdfVideoEncodeHwDeviceAdapter*"

             A pointer to the newly constructed HwDevice

  */

 CMdfVideoEncodeHwDeviceAdapter* CMdfVideoEncodeHwDeviceAdapter::NewL()

 	{

 	CMdfVideoEncodeHwDeviceAdapter* self = new(ELeave) CMdfVideoEncodeHwDeviceAdapter;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

  Default constructor

 */

 CMdfVideoEncodeHwDeviceAdapter::CMdfVideoEncodeHwDeviceAdapter()

 	{

 	}

 /**

  Safe contructor for CMdfVideoEncodeHwDeviceAdapter.

 */

 void CMdfVideoEncodeHwDeviceAdapter::ConstructL()

 	{

 	// Load the PU Loader plugin

 	iPuLoader = static_cast<CMdfPuLoader*>

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

 	}

 /**

  Default destructor

 */

 CMdfVideoEncodeHwDeviceAdapter::~CMdfVideoEncodeHwDeviceAdapter()

 	{

 	if(iEncoderPU) 

 		{

 		iPuLoader->UnloadProcessingUnit(iEncoderPU);		

 		}

 	delete iPuLoader;

 	delete iPuData;

 	delete iManufacturer;

 	REComSession::DestroyedImplementation(iPuLoaderDtorKey);

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

 		{

 		delete iOutputVideoFormats[i];

 		}

 	iEncoderPUOutputPortsArray.Reset();

 	iEncoderPUOutputPortsArray.Close();

 	iEncoderPUInputPortsArray.Reset();

 	iEncoderPUInputPortsArray.Close();

 	iPictureRates.Reset();

 	iPictureRates.Close();

 	iInputVideoFormats.Reset();

 	iInputVideoFormats.Close();

 	iOutputVideoFormats.Reset();

 	iOutputVideoFormats.Close();

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

 		{

 		User::Free((TAny*)iDataBuffers[i].iData.Ptr());

 		}

 	iDataBuffers.Reset();

 	iDataBuffers.Close();

 	delete iInputBuffer;

 	delete iOutputBuffer;

 	}

 void CMdfVideoEncodeHwDeviceAdapter::LoadProcessingUnitL(const CImplementationInformation& aImplInfo)

 	{

 	iPuUid = aImplInfo.ImplementationUid();

 	iEncoderPU = 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());

 	}

 // private method : body of Initialize()

 void CMdfVideoEncodeHwDeviceAdapter::InitializeL()

 	{

 	if (!iEncoderPU)

 		{

 		iProxy->MdvrpInitializeComplete(this, KErrNotFound);

 		return;	

 		}

 	// we have to pre-check that the image format is set correctly,

 	// else an attempt to set it into the config will panic.

 	switch(iFormat.iDataFormat) 

 		{

 		case 0:

 			User::Leave(KErrNotReady);

 			break;

 		case ERgbRawData:

 		case ERgbFbsBitmap:

 		case EYuvRawData:

 			break;

 		default:

 			User::Leave(KErrNotSupported);

 			break;

 		}

 	// get the encoder input ports

 	User::LeaveIfError(iEncoderPU->GetInputPorts(iEncoderPUInputPortsArray));

 	// set the observer for the encoder input ports

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

 		{

 		iEncoderPUInputPortsArray[i]->MipSetObserver(*this);

 		}

 	// get the encoder output ports

 	User::LeaveIfError(iEncoderPU->GetOutputPorts(iEncoderPUOutputPortsArray));

 	// set the observer for the encoder input ports

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

 		{

 		iEncoderPUOutputPortsArray[i]->MopSetObserver(*this);

 		}

 	TInt bufSize = iPictureSize.iHeight * iPictureSize.iWidth * KBytesPerPixel;

 	iDataBuffers.Reset();

 	// create the buffer. zero out all fields

 	TVideoOutputBuffer buf;

 	memset(&buf, 0, sizeof(buf));

 	TUint8* bufData = (TUint8*)User::AllocL(bufSize);

 	CleanupStack::PushL(bufData);

 	buf.iData.Set(bufData, bufSize);

 	iDataBuffers.AppendL(buf);

 	CleanupStack::Pop(bufData); // don't destroy - owned by iDataBuffers

 	TDevVideoRecordPuConfig config;

 	config.iFrameSize = iPictureSize;

 	config.iImageFormat = iFormat;

 	config.iFrameRate = iFrameRate;

 	TPuConfigDevVideoRecord puConfig(config);

 	// initialize with config info.

 	iEncoderPU->Configure(puConfig);

 	// create input buffer

 	iInputBuffer = CMMFDescriptorBuffer::NewL(bufSize);

 	iEncoderPUInputPortsArray[KEncoderPUInputPortIndex]->MipUseBuffer(*iInputBuffer);

 	// create output buffer 

 	TUint32 outputPortBufferSize = 

 		iEncoderPUOutputPortsArray[KEncoderPUOutputPortIndex]->MopBufferSize();

 	iOutputBuffer = CMMFDescriptorBuffer::NewL(outputPortBufferSize);

 	iEncoderPUOutputPortsArray[KEncoderPUOutputPortIndex]->MopUseBuffer(*iOutputBuffer);

 	// initialize the encoder PU

 	iEncoderPU->Initialize();

 	}

 /**

  @see CMMFVideoHwDevice

  */

 TAny* CMdfVideoEncodeHwDeviceAdapter::CustomInterface(TUid aInterface)

 	{

 	if (aInterface.iUid == KUidDevVideoHwDeviceAdapterSetup)

 		{

 		return static_cast<MDevVideoHwDeviceAdapterSetup*>(this);

 		}

 	return NULL;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 CPreProcessorInfo* CMdfVideoEncodeHwDeviceAdapter::PreProcessorInfoLC()

 	{

 	// we have no preprocessor info

 	return NULL;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetInputFormatL(const TUncompressedVideoFormat& aFormat, const TSize& aPictureSize)

 	{

 	iFormat = aFormat;

 	iPictureSize = aPictureSize;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetSourceCameraL(TInt /* aCameraHandle */, TReal /* aPictureRate */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetSourceMemoryL(TReal aMaxPictureRate, TBool /* aConstantPictureRate */, TBool /* aProcessRealtime */)

 	{

 	iFrameRate = (TInt)aMaxPictureRate;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Initialize()

 	{

 	TRAPD(err, InitializeL());

 	if(err != KErrNone) 

 		{

 		iProxy->MdvrpInitializeComplete(this, err);

 		}

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::WritePictureL(TVideoPicture* aPicture)

 	{

 	__ASSERT_ALWAYS(iEncoderPU, DevVideoEncoderPanic(0));

 	if(!aPicture) 

 		{

 		User::Leave(KErrArgument);

 		}

 	// the picture size MUST be the same as the size the encoder has

 	// been initialized with. 

 	if(aPicture->iData.iDataSize != iPictureSize) 

 	{

 		User::Leave(KErrArgument);

 	}

 	// Picture received : increment picture count

 	iPictureCounters.iInputPictures++;

 	iCurrentPicture = aPicture;

 	TDes8& data = iInputBuffer->Data();

 	data.SetLength((*aPicture->iData.iRawData).Length());

 	data.Copy(*aPicture->iData.iRawData);

 	iEncoderPUInputPortsArray[KEncoderPUInputPortIndex]->MipWriteData(*iInputBuffer);

 	iEncoderPUOutputPortsArray[KEncoderPUOutputPortIndex]->MopReadData(*iOutputBuffer);	

 	// Picture encoded : increment picture count

 	iPictureCounters.iPicturesProcessed++;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::InputEnd()

 	{

 	// The client has notified us it has reached the end of the input stream

 	iInputStreamEnd = ETrue;

 	iProxy->MdvrpStreamEnd();

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Start()

 	{

 	__ASSERT_ALWAYS(iEncoderPU, DevVideoEncoderPanic(0));

 	iEncoderPU->Execute();

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Stop()

 	{

 	iProxy->MdvrpFatalError(this, KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Pause()

 	{

 	iProxy->MdvrpFatalError(this, KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Resume()

 	{

 	iProxy->MdvrpFatalError(this, KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Freeze()

 	{

 	iProxy->MdvrpFatalError(this, KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::ReleaseFreeze()

 	{

 	iProxy->MdvrpFatalError(this, KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 TTimeIntervalMicroSeconds CMdfVideoEncodeHwDeviceAdapter::RecordingPosition()

 	{

 	// return picture count times frame rate

 	return iPictureCounters.iPicturesProcessed * (1000000 / iFrameRate);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::GetPictureCounters(CMMFDevVideoRecord::TPictureCounters& aCounters)

 	{

 	aCounters = iPictureCounters;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::GetFrameStabilisationOutput(TRect& aRect)

 	{

 	aRect = TRect(iPictureSize);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 TUint CMdfVideoEncodeHwDeviceAdapter::NumComplexityLevels()

 	{

 	// separate complexity levels are not available; return 1

 	return 1;

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

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

 	{

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 CVideoEncoderInfo* CMdfVideoEncodeHwDeviceAdapter::VideoEncoderInfoLC()

 	{

 	//if PU is not loaded panic

 	if(iPuData == NULL)	

 		{

 		DevVideoEncoderPanic(KErrNotReady);	

 		}

 	// output formats array

 	iOutputVideoFormats.Reset();

 	CCompressedVideoFormat* videoCV = NULL;

 	videoCV = CCompressedVideoFormat::NewL(iPuData->OutputDataType() , KNullDesC8);

 	CleanupStack::PushL(videoCV);

 	iOutputVideoFormats.AppendL(videoCV);

 	// Note; CCompressedVideo object is destroyed in destructor

 	CleanupStack::Pop(videoCV);

 	// input formats array

 	iInputVideoFormats.Reset();

 	TUncompressedVideoFormat inputFormats[3];

 	inputFormats[0].iDataFormat = ERgbRawData;

 	inputFormats[0].iRgbFormat = ERgb16bit565;

 	iInputVideoFormats.AppendL(inputFormats[0]);

 	inputFormats[1].iDataFormat = ERgbFbsBitmap;

 	inputFormats[1].iRgbFormat = EFbsBitmapColor16M;

 	iInputVideoFormats.AppendL(inputFormats[1]);

 	inputFormats[2].iDataFormat = EYuvRawData;

     memset(&inputFormats[2].iYuvFormat, 0, sizeof(TYuvFormat));

 	iInputVideoFormats.AppendL(inputFormats[2]);

 	// construct the video Encoder info object

 	CVideoEncoderInfo* vInfo = CVideoEncoderInfo::NewL(

 		iPuUid,

 		*iManufacturer,

 		KNullDesC,

 		TVersion(KEncoderPUInfoVersionMaj, KEncoderPUInfoVersionMin, KEncoderPUInfoVersionBuild),

 		EFalse, // not accelerated

 		EFalse, // does not support direct capture

 		iInputVideoFormats.Array(),

 		iOutputVideoFormats.Array(),

 		iPuData->MaxPictureSize(),

 		EDuCodedPicture, // data unit type(s)

 		EDuElementaryStream, // data encapsulation type

 		1, // num bitrate layers

 		EFalse, // does not support supplemental enhancement info

 		1, // unequal error protection levels not supported

 		KMaxTUint32, // max bitrate supported

 		iPuData->MaxPictureRates().Array(),

 		1, // in-layer scalability not supported

 		0, // no supported picture options

 		EFalse, // picture loss not supported,

 		EFalse, // slice loss not supported,

 		KEncoderInfoCSInfo,

 		KEncoderInfoISInfo);

 	CleanupStack::PushL(vInfo);

 	return vInfo;

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetOutputFormatL(const CCompressedVideoFormat& /* aFormat */, 

 					  TVideoDataUnitType /* aDataUnitType */, 					

 					  TVideoDataUnitEncapsulation /* aDataEncapsulation */,

 					  TBool /* aSegmentationAllowed */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetOutputRectL(const TRect& /* aRect */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetInputDevice(CMMFVideoPreProcHwDevice* /*aDevice*/)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetErrorsExpected(TBool /* aBitErrors */, TBool /* aPacketLosses */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetMinRandomAccessRate(TReal /* aRate */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetNumBitrateLayersL(TUint /* aNumLayers */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetScalabilityLayerTypeL(TUint /* aLayer */, TScalabilityType /* aScalabilityType */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetGlobalReferenceOptions(TUint /* aMaxReferencePictures */, TUint /* aMaxPictureOrderDelay */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetLayerReferenceOptions(TUint /* aLayer */, TUint /* aMaxReferencePictures */, TUint /* aMaxPictureOrderDelay */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetBufferOptionsL(const TEncoderBufferOptions& /* aOptions */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetCodingStandardSpecificOptionsL(const TDesC8& /* aOptions */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetImplementationSpecificEncoderOptionsL(const TDesC8& /* aOptions */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 HBufC8* CMdfVideoEncodeHwDeviceAdapter::CodingStandardSpecificInitOutputLC()

 	{

 	User::Leave(KErrNotSupported);

 	return NULL;

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 HBufC8* CMdfVideoEncodeHwDeviceAdapter::ImplementationSpecificInitOutputLC()

 	{

 	User::Leave(KErrNotSupported);

 	return NULL;

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetErrorProtectionLevelsL(TUint /* aNumLevels */, TBool /* aSeparateBuffers */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetErrorProtectionLevelL(TUint /* aLevel */, TUint /* aBitrate */, TUint /* aStrength */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetChannelPacketLossRate(TUint /* aLevel */, 

 							  TReal /* aLossRate */, 

 							  TTimeIntervalMicroSeconds32 /* aLossBurstLength */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetChannelBitErrorRate(TUint /* aLevel */, TReal /* aErrorRate */, TReal /* aStdDeviation */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetSegmentTargetSize(TUint /* aLayer */, TUint /* aSizeBytes */, TUint /* aSizeMacroblocks */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetRateControlOptions(TUint /* aLayer */, const TRateControlOptions& /* aOptions */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetInLayerScalabilityL(TUint /* aLayer */, TUint /* aNumSteps */,

 							TInLayerScalabilityType /* aScalabilityType */,

 							const TArray<TUint>& /* aBitrateShare */,

 							const TArray<TUint>& /* aPictureShare */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetLayerPromotionPointPeriod(TUint /* aLayer */, TUint /* aPeriod */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 HBufC8* CMdfVideoEncodeHwDeviceAdapter::CodingStandardSpecificSettingsOutputLC()

 	{

 	User::Leave(KErrNotSupported);

 	return NULL;

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 HBufC8* CMdfVideoEncodeHwDeviceAdapter::ImplementationSpecificSettingsOutputLC()

 	{

 	User::Leave(KErrNotSupported);

 	return NULL;

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SendSupplementalInfoL(const TDesC8& /* aData */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SendSupplementalInfoL(const TDesC8& /* aData */, const TTimeIntervalMicroSeconds& /* aTimestamp */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::CancelSupplementalInfo()

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::GetOutputBufferStatus(TUint& aNumFreeBuffers, TUint& aTotalFreeBytes)

 	{

 	// We have one output buffer, which has a max size of one raw frame.

 	aNumFreeBuffers = 1;

 	aTotalFreeBytes = iDataBuffers[0].iData.Size();

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::ReturnBuffer(TVideoOutputBuffer* /*aBuffer*/)

 	{

 	// Receive a used output buffer (from DevVideoRecord)

 	// We do nothing - we have one buffer, which is going to be re-used.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::PictureLoss()

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::PictureLoss(const TArray<TPictureId>& /* aPictures */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SliceLoss(TUint /* aFirstMacroblock */, TUint /* aNumMacroblocks */, const TPictureId& /* aPicture */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::ReferencePictureSelection(const TDesC8& /* aSelectionData */)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::CommitL()

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::Revert()

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoEncodeHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetProxy(MMMFDevVideoRecordProxy& aProxy)

 	{

 	ASSERT(!iProxy);

 	iProxy = &aProxy;

 	}

 void CMdfVideoEncodeHwDeviceAdapter::MipoWriteDataComplete(const MMdfInputPort* aInputPort, CMMFBuffer* aBuffer, TInt aErrorCode) 

 	{

 	if (aErrorCode != KErrNone)

 		{

 		iProxy->MdvrpFatalError(this, aErrorCode);

 		return;

 		}

 	if (aInputPort == iEncoderPUInputPortsArray[KEncoderPUInputPortIndex])

 		{

 		if (aBuffer->LastBuffer())

 			{

 			iEncoderPU->Stop();

 			}	

 		else

 			{

 			iProxy->MdvrpReturnPicture(iCurrentPicture);

 			iCurrentPicture = NULL;		

 			}

 		}

 	}

 void CMdfVideoEncodeHwDeviceAdapter::MipoDisconnectTunnelComplete(const MMdfInputPort* /*aInputPort*/, TInt aErrorCode)

 	{

 	if (aErrorCode != KErrNone)

 		{

 		iProxy->MdvrpFatalError(this, aErrorCode);

 		}	

 	}

 void CMdfVideoEncodeHwDeviceAdapter::MopoDisconnectTunnelComplete(const MMdfOutputPort* /*aOutputPort*/, TInt aErrorCode)

 	{

 	if (aErrorCode != KErrNone)

 		{

 		iProxy->MdvrpFatalError(this, aErrorCode);

 		}		

 	}	

 void CMdfVideoEncodeHwDeviceAdapter::MopoReadDataComplete(const MMdfOutputPort* aOutputPort, CMMFBuffer* aBuffer, TInt aErrorCode)

 	{

 	if (aErrorCode != KErrNone)

 		{

 		iProxy->MdvrpFatalError(this, aErrorCode);

 		return;

 		}		

 	if (aOutputPort == iEncoderPUOutputPortsArray[KEncoderPUOutputPortIndex])

 		{

 		TVideoOutputBuffer buf;

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

 		TUint bufSize = dataBuffer->BufferSize();

 		buf.iData.Set(const_cast<TUint8*>((dataBuffer->Data()).Ptr()), dataBuffer->BufferSize());

 		if (aBuffer->LastBuffer())

 			{

 			iEncoderPU->Stop();

 			iProxy->MdvrpStreamEnd();

 			}	

 		else

 			{

 			if (!iInputStreamEnd)

 				{

 				// still expecting more buffers, so let client know

 				iProxy->MdvrpNewBuffer(&buf);

 				}

 			else

 				{

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

 				dataBuffer->SetLastBuffer(ETrue);

 				// Write a zero sized input buffer to the port, with the last buffer flag set

 				iEncoderPUInputPortsArray[KEncoderPUInputPortIndex]->MipWriteData(*iInputBuffer);

 				}

 			}

 		}		

 	}

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

 	{

 	// KB: We have an error code, so use it not fatal error in this case	

 	iProxy->MdvrpInitializeComplete(this, aErrorCode);

 	}

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

 	{

 	if (aErrorCode != KErrNone)

 		{

 		iProxy->MdvrpFatalError(this, aErrorCode);

 		return;

 		}				

 	}

 void CMdfVideoEncodeHwDeviceAdapter::MipoRestartTunnelComplete(const MMdfInputPort* /*aInputPort*/, TInt /*aErrorCode*/)

 	{

 	// Function is not supported.

 	}	

 void CMdfVideoEncodeHwDeviceAdapter::MopoRestartTunnelComplete(const MMdfOutputPort* /*aOutputPort*/,  TInt /*aErrorCode*/)

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetClockSource(MMMFClockSource* /* aClock */) 

 	{

 	// Function is not supported.

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetPreProcessTypesL(TUint32 /* aPreProcessTypes */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetRgbToYuvOptionsL(TRgbRange /* aRange */, const TYuvFormat& /* aOutputFormat */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetYuvToYuvOptionsL(const TYuvFormat& /* aInputFormat */, const TYuvFormat& /* aOutputFormat */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

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

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

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

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

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

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

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

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetOutputPadOptionsL(const TSize& /* aOutputSize */, const TPoint& /* aPicturePos */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetColorEnhancementOptionsL(const TColorEnhancementOptions& /* aOptions */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetFrameStabilisationOptionsL(const TSize& /* aOutputSize */, TBool /* aFrameStabilisation */)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /**

  @see CMMFVideoRecordHwDevice

  */

 void CMdfVideoEncodeHwDeviceAdapter::SetCustomPreProcessOptionsL(const TDesC8& /* aOptions */)

 	{

 	User::Leave(KErrNotSupported);

 	}