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

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

#include "srtreader.h"

#include "mmfdevsubtitle.h"

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfvideoenums.h>

#endif

const TInt KTestBufferSize = 0x10000; 

_LIT8(KXvidDecoderMimeType,"video/mp4v-es");

_LIT8(KAviVideoCodec,"XVID");

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

_LIT(KSrtExtension, "srt");

_LIT(KSrtDecoder, "srtdecoder");

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

//Table that maps given samplerate with the MMF samplerate

const TSampleRateTable KRateLookup[]=

								 {

									{96000,EMMFSampleRate96000Hz},

        							{88200,EMMFSampleRate88200Hz},

                   					{48000,EMMFSampleRate48000Hz},

			                   		{44100,EMMFSampleRate44100Hz},

				                  	{32000,EMMFSampleRate32000Hz},

				                  	{22050,EMMFSampleRate22050Hz},

				                  	{16000,EMMFSampleRate16000Hz},

				                  	{11025,EMMFSampleRate11025Hz},

				                  	{8000, EMMFSampleRate8000Hz}

                   				 };

//This method generates a panic internal to this dll.

void CAviPlayController::Panic(TInt aPanicCode)

	{

	_LIT(KAviPlayControllerPanicCategory, "AviPlayController");

	User::Panic(KAviPlayControllerPanicCategory, aPanicCode);

	}

//This function creates an object of CAviPlayController.

CAviPlayController* CAviPlayController::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

//Default Constructor of CAviPlayController

CAviPlayController::CAviPlayController() :

	iVideoSurfaceSupport(NULL)

	{

	}

//Destructor of CAviPlayController.

CAviPlayController::~CAviPlayController()

	{

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	delete iSrtReader;

	delete iDevSubtitle;

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	iDisplayRegion.Close();

	iDerivedClipRegion.Close();

	delete iAviReader;

	delete iDevVideoPlay;

	delete iMessage;

	delete iEventHandler;

	delete iScreenGc;

	delete iScreenDev;

	RFbsSession::Disconnect();

	}

//This constructs the custom command parsers of CAviPlayController.

void CAviPlayController::ConstructL()

	{

	CMMFVideoPlayControllerCustomCommandParser* vidPlayConParser = CMMFVideoPlayControllerCustomCommandParser::NewL(*this);

	CleanupStack::PushL(vidPlayConParser);

	AddCustomCommandParserL(*vidPlayConParser);

	CleanupStack::Pop(vidPlayConParser);

	CMMFVideoControllerCustomCommandParser* vidConParser = CMMFVideoControllerCustomCommandParser::NewL(*this);

	CleanupStack::PushL(vidConParser);

	AddCustomCommandParserL(*vidConParser);

	CleanupStack::Pop(vidConParser);

	CMMFAudioPlayDeviceCustomCommandParser* audPlayDevParser = CMMFAudioPlayDeviceCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayDevParser);

	AddCustomCommandParserL(*audPlayDevParser);

	CleanupStack::Pop(audPlayDevParser);

	CMMFResourceNotificationCustomCommandParser* notiParser = CMMFResourceNotificationCustomCommandParser::NewL(*this);

	CleanupStack::PushL(notiParser);

	AddCustomCommandParserL(*notiParser);

	CleanupStack::Pop(notiParser);//audio resource Notification Parser

	CMMFVideoSetInitScreenCustomCommandParser* vidScrDevParser = CMMFVideoSetInitScreenCustomCommandParser::NewL(*this);

	CleanupStack::PushL(vidScrDevParser);

	AddCustomCommandParserL(*vidScrDevParser);

	CleanupStack::Pop(vidScrDevParser);

	CMMFVideoPlayControllerExtCustomCommandParser* vidPlayExtParser = CMMFVideoPlayControllerExtCustomCommandParser::NewL(*this);

	CleanupStack::PushL(vidPlayExtParser);

	AddCustomCommandParserL(*vidPlayExtParser);

	CleanupStack::Pop(vidPlayExtParser);

#ifdef SYMBIAN_BUILD_GCE	

	CMMFVideoPlaySurfaceSupportCustomCommandParser* vidPlaySurfaceSupParser = CMMFVideoPlaySurfaceSupportCustomCommandParser::NewL(*this);

	CleanupStack::PushL(vidPlaySurfaceSupParser);

	AddCustomCommandParserL(*vidPlaySurfaceSupParser);

	CleanupStack::Pop(vidPlaySurfaceSupParser);

#endif // SYMBIAN_BUILD_GCE

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	CMMFVideoPlaySubtitleSupportCustomCommandParser * vidPlaySubtitleSupParser = CMMFVideoPlaySubtitleSupportCustomCommandParser::NewL(*this);

	CleanupStack::PushL(vidPlaySubtitleSupParser);

	AddCustomCommandParserL(*vidPlaySubtitleSupParser);

	CleanupStack::Pop(vidPlaySubtitleSupParser);

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	iEventHandler = new(ELeave) CSourceSinkEventHandler(*this);

	iAudioEnabled = EFalse;

	User::LeaveIfError(RFbsSession::Connect());

	}

//Adds a data source to the controller

void CAviPlayController::AddDataSourceL(MDataSource& aDataSource)

	{

	if (iState != EStopped) 

		{

		User::Leave(KErrNotReady);

		}

	if (iClip)

		{

		User::Leave(KErrAlreadyExists);

		}

	if (aDataSource.DataSourceType()==KUidMmfFileSource)

		{

		iClip = static_cast<CMMFFile*>(&aDataSource);

		iAviReader = CAviReader::NewL(*iClip,*this);

		User::LeaveIfError(iClip->SourceThreadLogon(*iEventHandler));

		iAviReader->AudioEnabled(iAudioEnabled);

		}

	else 

		{

		User::Leave(KErrNotSupported);

		}

	TMMFEvent controllerEvent;

	controllerEvent.iEventType = KMMFEventCategoryVideoOpenComplete;

	controllerEvent.iErrorCode = KErrNone;

	DoSendEventToClient(controllerEvent);		

	}

//Adds a data sink to the controller

void CAviPlayController::AddDataSinkL(MDataSink& aDataSink)

	{

	if (iState != EStopped) 

    	{

    	User::Leave(KErrNotReady);	

    	}

    if(iDevSound)

    	{

    	User::Leave(KErrAlreadyExists);

    	}

    if (aDataSink.DataSinkType()!=KUidMmfAudioOutput) 

    	{

    	User::Leave(KErrNotSupported);	

    	}

	MMMFAudioOutput* audioOutput = static_cast<MMMFAudioOutput*>(&aDataSink);

    User::LeaveIfError(audioOutput->SinkThreadLogon(*iEventHandler));

    iDevSound = &(audioOutput->SoundDevice());

	iDevSound->SetPrioritySettings(iPrioritySettings);

	if (IsSecureDrmModeL())

		{

		User::LeaveIfError(iDevSound->SetClientThreadInfo(ClientThreadIdL()));

		}

	delete iScreenDev;

	iScreenDev = NULL;

	TRAPD(err, iScreenDev = CFbsScreenDevice::NewL(iScreenNumber,EColor16MA));

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(iScreenNumber,EColor16M));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(iScreenNumber,EColor64K));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(iScreenNumber,EColor4K));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(iScreenNumber,EColor256));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(iScreenNumber,EColor16MAP));

		}

	User::LeaveIfError(err);

	delete iScreenGc;

	iScreenGc = NULL;

	User::LeaveIfError(iScreenDev->CreateContext(iScreenGc));

	iScreenGc->SetPenColor(KRgbBlack);

	iScreenGc->SetBrushColor(KRgbWhite);

	iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	delete iDevVideoPlay;

	iDevVideoPlay = NULL;

	iDevVideoPlay = CMMFDevVideoPlay::NewL(*this);

	iVideoDecoderInitialized = EFalse;

	}

//Removes the data source from the controller

void CAviPlayController::RemoveDataSourceL(MDataSource& aDataSource)

	{

	if (iState != EStopped) 

    	{

    	User::Leave(KErrNotReady);	

    	}

   	if (!iClip)

    	{

    	User::Leave(KErrNotReady);

    	}

    if (iClip != &aDataSource) 

	 	{

    	User::Leave(KErrArgument);

    	}

    else

    	{

    	delete iAviReader;

    	iAviReader = NULL;

    	iClip = NULL;

   		}

	}

//Removes the data sink from the controller

void CAviPlayController::RemoveDataSinkL(MDataSink& aDataSink)

	{

	if ((!iDevSound) || (iState!= EStopped))

		{

    	User::Leave(KErrNotReady);

    	}

	if (aDataSink.DataSinkType() !=	KUidMmfAudioOutput) 

		{

	   	User::Leave(KErrNotSupported);	

	   	}

	MMMFAudioOutput* audioOutput = static_cast<MMMFAudioOutput*>(&aDataSink);

	CMMFDevSound& devSound = audioOutput->SoundDevice();

	if (iDevSound != &devSound) 

		{

		User::Leave(KErrArgument);

		}

	else

		{

		iDevSound = NULL;

		}

	delete iDevVideoPlay;

   	iDevVideoPlay = NULL;

	delete iScreenDev;

	iScreenDev = NULL;

	}

//Resets the controller

void CAviPlayController::ResetL()

	{

	StopL();

	iDevSound = NULL;

	delete iDevVideoPlay;

   	iDevVideoPlay = NULL;

    iClip=NULL;

    delete iAviReader;

    iAviReader = NULL;

    delete iMessage;

    iMessage = NULL;

	}	

//Primes the controller

void CAviPlayController::PrimeL(TMMFMessage& aMessage)

	{

	if (iState != EStopped)  

		{

		User::Leave( KErrNotReady );	

		}

	if (!iClip)

		{

		User::Leave(KErrNotReady);

		}

	if(iAudioEnabled)

    	{

    	if(!iDevSound)

    		{

    		User::Leave(KErrNotReady);

    		}

    	}

    __ASSERT_ALWAYS((!iMessage),Panic(EBadCall));	

    iMessage = CMMFMessageHolder::NewL(aMessage);	

	TRAPD(err,StartPrimeL());

	if(err != KErrNone)

		{

		SendErrorToClient(err);

		}

	}

void CAviPlayController::PrimeL()

    {

    Panic(EBadCall);

    }

//Primes the controller

void CAviPlayController::StartPrimeL()

	{

	CheckAviReaderPresentL();

	CheckDevVideoPresentL();

    iAviReader->AudioEnabled(iAudioEnabled);

    iClip->SourcePrimeL();

    // Initialise Devsound

 	if (iAudioEnabled)

		{

		iDevSound->InitializeL(*this, EMMFStatePlaying);

	  	}

	if(!iVideoDecoderInitialized)

		{

		if (!iVideoSurfaceSupport)

			{

			if (LocateDecoderL(EFalse))

				{

				// Set the video destination as Screen.This will leave if the

				// plug-in does not support DSA.

				iDevVideoPlay->SetVideoDestScreenL(ETrue);

				// Initialize devvideoPlay

				iDevVideoPlay->Initialize();

				}

			else

				{

				// Inform client if we couldn't find a suitable decoder.

				SendErrorToClient(KErrNotFound);

				}

			}

		else

			{

			// Decoder already located, done in UseSurfaces

			iDevVideoPlay->Initialize();

			}

		}

	else

		{

		if(iAudioEnabled)

			{

			iDevVideoInitialized = ETrue;

			}

		else

			{

			if (iMessage)

				{

				iMessage->Complete(KErrNone);

				delete iMessage;

				iMessage = NULL;

				}

			}

		iState = EPrimed;

 		}

	}

TBool CAviPlayController::LocateDecoderL(TBool aUseSurfaces)

	{

	// Find the Decoder

 	RArray<TUid> foundDecodersArray;

	CleanupClosePushL(foundDecodersArray);

	iDevVideoPlay->FindDecodersL(KXvidDecoderMimeType,

								 0, //  post-processing

									//  support is not needed

								 foundDecodersArray,

								 EFalse);

	TBool suitableDecoderFound = EFalse;

	if(foundDecodersArray.Count() > 0)

		{

		TUncompressedVideoFormat reqOutFormat;

		// Prefer RGB over YUV in case of graphics surfaces.

		if (aUseSurfaces)

			{

			reqOutFormat.iDataFormat = ERgbRawData;	

			reqOutFormat.iRgbFormat = ERgb32bit888;

			}

		else

			{

			reqOutFormat.iDataFormat = ERgbFbsBitmap;	

			reqOutFormat.iRgbFormat = EFbsBitmapColor16M;

			}

		// Here, we pick a decoder that can handle the output format

		// required

		suitableDecoderFound =

			SelectFirstSuitableDecoderL(foundDecodersArray, reqOutFormat, aUseSurfaces);

		}

	CleanupStack::PopAndDestroy(&foundDecodersArray);

	return suitableDecoderFound;

	}

// Selection of a suitable decoder based on the output format required

TBool CAviPlayController::SelectFirstSuitableDecoderL(

	const RArray<TUid>& aDecodersArray,

	const TUncompressedVideoFormat& aRequiredOutputFormat,

#ifdef SYMBIAN_BUILD_GCE

	TBool aUseSurfaces

#else

	TBool /* aUseSurfaces */

#endif // SYMBIAN_BUILD_GCE

	)

	{

	RArray<TUncompressedVideoFormat> outputFormatsArray;

	CleanupClosePushL(outputFormatsArray);

	TBool suitableDecoderFound = EFalse;

	TInt numDecoders = aDecodersArray.Count();

	for (TInt i = 0; !suitableDecoderFound && i < numDecoders; i++)

		{

		iDecoderDeviceId = iDevVideoPlay->SelectDecoderL(aDecodersArray[i]);

		#ifdef SYMBIAN_BUILD_GCE	

			if (aUseSurfaces)

				{

				// try to access the interface for video surfaces in dev video

				iVideoSurfaceSupport = static_cast<MMMFVideoSurfaceSupport*>(iDevVideoPlay->CustomInterface(iDecoderDeviceId, KUidMMFVideoSurfaceSupport));

				if (!iVideoSurfaceSupport)

					{

					continue;

					}

				}

		#endif // SYMBIAN_BUILD_GCE

		iDevVideoPlay->GetOutputFormatListL(iDecoderDeviceId,

											outputFormatsArray);

		if (outputFormatsArray.Find(aRequiredOutputFormat) !=

			KErrNotFound)

			{

			iDevVideoPlay->SetOutputFormatL(iDecoderDeviceId,

											aRequiredOutputFormat);

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

			CVideoDecoderInfo* pCVideoDecoderInfo =

				iDevVideoPlay->VideoDecoderInfoLC(aDecodersArray[i]);

			RArray<TInt> supportedScreensArray;

			CleanupClosePushL(supportedScreensArray);

			pCVideoDecoderInfo->GetSupportedScreensL(supportedScreensArray);

			// If supportedScreensArray.Count() is zero, it implies that

			// decoder does not support any specific screens and it should be

			// able to support any screen. Continue to initialize DevVideoPlay.

			TInt err = KErrNone;

			if(supportedScreensArray.Count() > 0)

				{

				// The decoder supports specific screens. Check if it supports

				// the screen number set by the client.

				err = supportedScreensArray.Find(iScreenNumber);

				}

			// If err is KErrNotFound, it implies that the decoder does not

			// support the given screen and hence not suitable for the client.

			// check if the next decoder in the list is suitable.

			if(KErrNotFound != err)

				{

				// Suitable decoder is found.

				iDevVideoInitialized = EFalse;

				suitableDecoderFound = ETrue;

				}

			// supportedScreensArray, pCVideoDecoderInfo

			CleanupStack::PopAndDestroy(2, pCVideoDecoderInfo);

#else

			iDevVideoInitialized = EFalse;

			suitableDecoderFound = ETrue;

#endif

			}

		outputFormatsArray.Reset();

		}

	CleanupStack::PopAndDestroy(&outputFormatsArray);

	return suitableDecoderFound;

	}

//Starts playing and transfers the data from data source to data sink.

void CAviPlayController::PlayL()

	{

	if (iState != EPrimed )

    	{

    	User::Leave(KErrNotReady);

    	}

	iClip->SourcePlayL();

	if (iVideoSurfaceSupport == NULL)

		{

		iDevVideoPlay->StartDirectScreenAccessL(iScreenRect,*iScreenDev,iDerivedClipRegion);

		}

    iDevVideoPlay->Start();	

    if(iAudioEnabled)

  		{

    	iDevSound->PlayInitL();	

    	iState = EAudioReadyToPlay;

    	}

    else

    	{

    	iState = EPlaying;

    	}	

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

    if (iDevSubtitle)

    	{

    	// subtitle enabled

    	iDevSubtitle->SetVideoPositionL(0);

    	iDevSubtitle->Start();

    	iDevSubtitleStarted = ETrue;

    	}

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

   	}

//Pause playing and the data transfer from data source to data sink.

void CAviPlayController::PauseL()

    {

    User::Leave(KErrNotSupported);

	}

//Stops playing and the data transfer from data source to data sink.

void CAviPlayController::StopL()

	{

	if (iState == EStopped)

    	{

    	return;

    	}

	StopAudioL();

	StopVideoL();

	StopAviReaderL();

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

    StopSubtitles();

#endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

    iState = EStopped;

	}

//Returns the current playing position from devvideoplay.

TTimeIntervalMicroSeconds CAviPlayController::PositionL() const

	{

 	if (iState == EStopped)

    	{

    	return 0;

    	}

	CheckDevVideoPresentL();	

    return iDevVideoPlay->PlaybackPosition();

	}

//Set the position to play from.

void CAviPlayController::SetPositionL(const TTimeIntervalMicroSeconds& /*aPosition*/)

	{

	//This will leave with KErrNotsupported as there is no support for seeking 

	//position in an .avi file.

	User::Leave(KErrNotSupported);

	}

//Returns the duration of the clip.

TTimeIntervalMicroSeconds CAviPlayController::DurationL() const

	{

	CheckAviReaderPresentL();

	return iAviReader->Duration();

	}

//Handles a custom command.

void CAviPlayController::CustomCommand(TMMFMessage& aMessage)

	{

	aMessage.Complete(KErrNotSupported);

	}

//Sets the priority settings for devsound.

void CAviPlayController::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

	{

 	iPrioritySettings = aPrioritySettings;

    if (iDevSound)

    	{

    	iDevSound->SetPrioritySettings(aPrioritySettings);

    	}

	}

//Gets the number of meta entries in the clip.

void CAviPlayController::GetNumberOfMetaDataEntriesL(TInt& /*aNumberOfEntries*/)

	{

	//Support to get meta data is not present.so this will leave with KErrNotSupported.

	User::Leave(KErrNotSupported);

	}

//Gets a meta entry at a specified index.

CMMFMetaDataEntry* CAviPlayController::GetMetaDataEntryL(TInt /*aIndex*/)

	{

	//Support to get meta data is not present.so this will leave with KErrNotSupported. 

	User::Leave(KErrNotSupported);

	return NULL;

	}

//----------------------------------------------- //

// MMMFVideoPlayControllerCustomCommandImplementor //

//-----------------------------------------------//

//Sets the screen clip region

void CAviPlayController::MvpcUpdateDisplayRegionL(const TRegion& aRegion)

	{

	// Only update display region if not using graphics surfaces

	if (!iVideoSurfaceSupport)

		{

		iDisplayRegion.Copy(aRegion);

		UpdateClipRegion();

		}

	}

//Gets the previously requested frame

void CAviPlayController::MvpcGetFrameL(MMMFVideoFrameMessage& aMessage)

	{

	CFbsBitmap& bitmap = aMessage.GetBitmap();

	TRAPD(err, CopyFrameL(bitmap));

	aMessage.FrameReady(err);	

	}

//Copies the previously requested frame

void CAviPlayController::CopyFrameL(CFbsBitmap& aBitmap)

	{

	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(aBitmap.Resize(bitmap->SizeInPixels()));

	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(&aBitmap);

	CleanupStack::PushL(bitmapDevice);

	CFbsBitGc* gc = NULL;

	User::LeaveIfError(bitmapDevice->CreateContext(gc));

	gc->DrawBitmap(TPoint(0,0), bitmap);

	gc->Clear();

	delete gc;

	CleanupStack::PopAndDestroy(2,bitmap);//for bitmapdevice and bitmap.

	}

//Gets if audio is enabled during playing.

void CAviPlayController::MvpcGetAudioEnabledL(TBool& aEnabled)

	{

	CheckAviReaderPresentL();

	iAviReader->AudioEnabled(iAudioEnabled);

	aEnabled = iAudioEnabled;

	}

//Sets the display window on the screen.

void CAviPlayController::MvpcSetDisplayWindowL(const TRect& aWindowRect, const TRect& aClipRect)

	{

	if (iVideoSurfaceSupport != NULL)

		{

		User::Leave(KErrNotSupported);

		}

	iScreenRect= aWindowRect;

	iClipRect = aClipRect;

	ASSERT(iScreenGc);

	UpdateClipRegion();

	}

//Aborts or resumes direct screen access depends on the DSA event received

void CAviPlayController::MvpcDirectScreenAccessEventL(const TMMFDSAEvent aDSAEvent)

	{

	if (iVideoSurfaceSupport != NULL)

		{

		User::Leave(KErrNotSupported);

		}

	CheckDevVideoPresentL();

	if (aDSAEvent == EAbortDSA)

		{

		if(iState == EPlaying)

			{

			iDevVideoPlay->AbortDirectScreenAccess();

			}

		}

	else if (aDSAEvent == EResumeDSA)

		{

		if((iState == EPrimed)||(iState == EPlaying))

			{

			iDevVideoPlay->StartDirectScreenAccessL(iScreenRect,*iScreenDev,iDerivedClipRegion);

			}

		}

	}

//Plays videoclip within the playwindow set

void CAviPlayController::MvpcPlayL(const TTimeIntervalMicroSeconds& /*aBegin*/,const TTimeIntervalMicroSeconds& /*aEnd*/)

	{

	//This will leave with KErrNotSupported as there is no provision to

	// seek the position in an .avi file.

	User::Leave(KErrNotSupported);

	}

//Redraws the current frame

void CAviPlayController::MvpcRefreshFrameL()

	{

	CheckDevVideoPresentL();

	iDevVideoPlay->Redraw();

	}

//Gets the progress of loading video clip

void CAviPlayController::MvpcGetLoadingProgressL(TInt& /*aPercentage*/)

	{

	//This will leave with KErrNotSuuported as there is no support 

	User::Leave(KErrNotSupported);

	}

//Prepares the controller for recording.

void CAviPlayController::MvpcPrepare()

	{

	TMMFEvent controllerEvent;

	controllerEvent.iEventType = KMMFEventCategoryVideoPrepareComplete;

	controllerEvent.iErrorCode = KErrNone;

	DoSendEventToClient(controllerEvent);		

	}

//Rotates the video file on the screen with the rotation angle given.

void CAviPlayController::MvpcSetRotationL(TVideoRotation aRotation)

	{

	//this will leave with KErrNotSupported as the Xvid Hwdevice does not support post processing.

	iRotation = aRotation;

	User::Leave(KErrNotSupported);

	}

//Gets the rotation applied to the video file.

void CAviPlayController::MvpcGetRotationL(TVideoRotation& aRotation)

	{

	//this will leave with KErrNotSupported as the Xvid Hwdevice does not support post processing.

	aRotation = iRotation;

	User::Leave(KErrNotSupported);

	}

//Scales the the video file on the screen with the scaling parameters given.

void CAviPlayController::MvpcSetScaleFactorL(TReal32 aWidthPercentage, TReal32 aHeightPercentage, TBool aAntiAliasFiltering)

	{

	//this will leave with KErrNotSupported as the Xvid Hwdevice does not support post processing.

	iWidthPercentage = aWidthPercentage;

	iHeightPercentage = aHeightPercentage;

	iAntiAliasFiltering = aAntiAliasFiltering;

	User::Leave(KErrNotSupported);	

	}

//Gets the scale factor applied for the video file.

void CAviPlayController::MvpcGetScaleFactorL(TReal32& aWidthPercentage, TReal32& aHeightPercentage, TBool& aAntiAliasFiltering)

	{

	//this will leave with KErrNotSupported as the Xvid Hwdevice does not support post processing.

	aWidthPercentage = iWidthPercentage;

	aHeightPercentage = iHeightPercentage;

	aAntiAliasFiltering = iAntiAliasFiltering;

	User::Leave(KErrNotSupported);

	}

//Sets the crop options for the image.

void CAviPlayController::MvpcSetCropRegionL(const TRect& aCropRegion)

	{

	//this will leave with KErrNotSupported as the Xvid Hwdevice does not support post processing.

	iCropRect = aCropRegion;

	User::Leave(KErrNotSupported);

	}

//Gets the crop options of the image.

void CAviPlayController::MvpcGetCropRegionL(TRect& aCropRegion)

	{

	//this will leave with KErrNotSupported as the Xvid Hwdevice does not support post processing.

	aCropRegion = iCropRect;

	User::Leave(KErrNotSupported);

	}

//Sets the video frame rate for recording.

void CAviPlayController::MvcSetFrameRateL(TReal32 /*aFramesPerSecond*/)

	{

	//There are no apis available at devvideo level to do this.

	//so, this will leave with KErrNotSupported.

	User::Leave(KErrNotSupported);

	}

//Gets the video frame rate applied for playing 

void CAviPlayController::MvcGetFrameRateL(TReal32& aFramesPerSecond)

	{

	CheckAviReaderPresentL();

	iAviReader->FrameRate(aFramesPerSecond);

	}

//Gets the audio codec used for playing.

void CAviPlayController::MvcGetAudioCodecL(TFourCC& aCodec)

	{

	if (iAudioEnabled)

		{

		aCodec = KMMFFourCCCodePCM16;

		CheckAviReaderPresentL();

	 	iAviReader->AudioCodec(aCodec);

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	}

//Gets the video codec used for playing.

void CAviPlayController::MvcGetVideoMimeTypeL(TDes8& aMimeType)

	{

	CheckAviReaderPresentL();

	aMimeType = KAviVideoCodec;

	iAviReader->VideoMimeType(aMimeType);

	}

//Gets the video bit rate used for playing.

void CAviPlayController::MvcGetVideoBitRateL(TInt& /*aBitRate*/)

	{

	//There are no devvideo api's to do this.

	//so, leave with KErrNotSuported.

	User::Leave(KErrNotSupported);

	}

//Gets the audio bit rate used for playing.

void CAviPlayController::MvcGetAudioBitRateL(TInt& aBitRate)

	{

	CheckAviReaderPresentL();

	if(iAudioEnabled)

		{

		aBitRate = (iAviReader->BitsPerSample() * iAviReader->SampleRate()* iAviReader->Channels());

		}

	else

		{

		User::Leave(KErrNotSupported);	

		}	

	}

//Returns the video framesize of the file.

void CAviPlayController::MvcGetVideoFrameSizeL(TSize& aSize)

	{

	CheckAviReaderPresentL();

	iAviReader->VideoFrameSize(aSize);

	}

//Sets the volume during playing.

void CAviPlayController::MapdSetVolumeL(TInt aVolume)

	{

	if (iAudioEnabled)

		{

		CheckDevSoundPresentL();

		TInt maxVolume = iDevSound->MaxVolume();

		iDevSound->SetVolume(aVolume);

		}

	else

		{

		User::Leave(KErrNotSupported);

		}	

	}

//Gets the maximum audio volume for playing.

void CAviPlayController::MapdGetMaxVolumeL(TInt& aMaxVolume)

	{

	if(iAudioEnabled)

		{

		CheckDevSoundPresentL();

		aMaxVolume = iDevSound->MaxVolume();

		}

	else

		{

		User::Leave(KErrNotSupported);

		}	

	}

//Gets the volume for playing

void CAviPlayController::MapdGetVolumeL(TInt& aVolume)

	{

	if (iAudioEnabled)

		{

		CheckDevSoundPresentL();

		aVolume = iDevSound->Volume();

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	}

//Gets the volume ramp for playing

void CAviPlayController::MapdSetVolumeRampL(const TTimeIntervalMicroSeconds& aRampDuration)

	{

	if (iAudioEnabled)

		{

		CheckDevSoundPresentL();

		iDevSound->SetVolumeRamp(aRampDuration);

		}

	else

		{

		User::Leave(KErrNotSupported);

		}	

	}

//Set the audio balance for playing.

void CAviPlayController::MapdSetBalanceL(TInt aBalance)

	{

	if (iAudioEnabled)

		{

		CheckDevSoundPresentL();

		if (aBalance < KMMFBalanceMaxLeft)

			{

    		aBalance = KMMFBalanceMaxLeft;	

    		}

		else if (aBalance > KMMFBalanceMaxRight)

			{

			aBalance = KMMFBalanceMaxRight;

			}

		TInt left = (100 * (aBalance-KMMFBalanceMaxRight)) / (KMMFBalanceMaxLeft-KMMFBalanceMaxRight);

		TInt right = 100 - left;

		iDevSound->SetPlayBalanceL(left, right);

		}

	else

		{

		User::Leave(KErrNotSupported);

		}	

	}

//Get the audio balance applied for playing

void CAviPlayController::MapdGetBalanceL(TInt& aBalance)

	{

	if (iAudioEnabled)

		{