Symaptic: os/mm/mmapitest/devvideohaitest/src/H264DecTestEngine.cpp@260cb5ec6c19 (annotated)

sl@0	1	/*
sl@0	2	* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
sl@0	3	* All rights reserved.
sl@0	4	* This component and the accompanying materials are made available
sl@0	5	* under the terms of "Eclipse Public License v1.0"
sl@0	6	* which accompanies this distribution, and is available
sl@0	7	* at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	8	*
sl@0	9	* Initial Contributors:
sl@0	10	* Nokia Corporation - initial contribution.
sl@0	11	*
sl@0	12	* Contributors:
sl@0	13	*
sl@0	14	* Description:
sl@0	15	*
sl@0	16	*/
sl@0	17
sl@0	18
sl@0	19
sl@0	20	// INCLUDE FILES
sl@0	21	#include "H264DecTestEngine.h"
sl@0	22	#include "T_DevVideoConstants.h"
sl@0	23
sl@0	24	#ifdef __CI_HEADERS__
sl@0	25	#include <buffermanagementci.h> // Custom interface buffre management
sl@0	26
sl@0	27	#endif
sl@0	28
sl@0	29
sl@0	30	#ifdef __SECUREOUTPUTCI__
sl@0	31	#include <secureoutputci.h>
sl@0	32	#endif
sl@0	33
sl@0	34	#include <Devvideoplay.h>
sl@0	35	#include <Devvideobase.h>
sl@0	36	#include <Devvideoconstants.h>
sl@0	37	#include <hal.h>
sl@0	38	#include <hal_data.h>
sl@0	39	//#define __MEM_CHECK_
sl@0	40
sl@0	41
sl@0	42	// Ecom
sl@0	43	#include <ecom.h>
sl@0	44
sl@0	45
sl@0	46	/* ----------------------------------------------------------------------------
sl@0	47	* Name: CVDecTestEngine::~CVDecTestEngine()
sl@0	48	* Purpose: Deconstructor
sl@0	49	* Parameters: None
sl@0	50	* Return: None
sl@0	51	* --------------------------------------------------------------------------*/
sl@0	52
sl@0	53	CVDecTestEngine::~CVDecTestEngine ()
sl@0	54	{
sl@0	55	delete iDecTestAO;
sl@0	56	delete iClock;
sl@0	57	}
sl@0	58
sl@0	59
sl@0	60	/* ----------------------------------------------------------------------------
sl@0	61	* Name: CVDecTestEngine:NewL()
sl@0	62	* Purpose: Create instance of test engine
sl@0	63	* Parameters: MVDecEngineObserver& aTestClass
sl@0	64	* Return: CVDecTestEngine*
sl@0	65	* --------------------------------------------------------------------------*/
sl@0	66
sl@0	67	CVDecTestEngine* CVDecTestEngine::NewL(MVDecEngineObserver& aTestClass)
sl@0	68	{
sl@0	69	CVDecTestEngine* self = new(ELeave) CVDecTestEngine;
sl@0	70
sl@0	71	CleanupStack::PushL( self );
sl@0	72	self->ConstructL(aTestClass);
sl@0	73	CleanupStack::Pop();
sl@0	74
sl@0	75	return self;
sl@0	76	}
sl@0	77
sl@0	78
sl@0	79	/* ----------------------------------------------------------------------------
sl@0	80	* Name: CVDecTestEngine::ConstructL()
sl@0	81	* Purpose: Symbian second phase constructor, which may leave
sl@0	82	* Parameters: MVDecEngineObserver& aTestClass
sl@0	83	* Return: None
sl@0	84	* --------------------------------------------------------------------------*/
sl@0	85
sl@0	86
sl@0	87	void CVDecTestEngine::ConstructL(MVDecEngineObserver& aTestClass)
sl@0	88	{
sl@0	89	iState = EStateNone;
sl@0	90	iTestClass = &aTestClass;
sl@0	91	iScreenDevice = NULL;
sl@0	92
sl@0	93	//Create Active object
sl@0	94	iDecTestAO = new(ELeave) CVDecTestAO(this);
sl@0	95
sl@0	96	//clock source from system clock
sl@0	97	iClock = CSystemClockSource::NewL();
sl@0	98	}
sl@0	99
sl@0	100
sl@0	101	/* ----------------------------------------------------------------------------
sl@0	102	* Name: CVDecTestEngine::AssertTIntEqualL()
sl@0	103	* Purpose:
sl@0	104	*
sl@0	105	* Parameters: TInt aExpected, TInt aActual
sl@0	106	* Return: None
sl@0	107	* --------------------------------------------------------------------------*/
sl@0	108
sl@0	109	void CVDecTestEngine::AssertTIntEqualL(TInt aExpected, TInt aActual)
sl@0	110	{
sl@0	111	if ( aExpected != aActual )
sl@0	112	{
sl@0	113	User::Leave(aActual);
sl@0	114	}
sl@0	115	}
sl@0	116
sl@0	117	/* ----------------------------------------------------------------------------
sl@0	118	* Name: CVDecTestEngine::SetUp()
sl@0	119	* Purpose: Create DevVideoPlay, Initilize Engine paramters
sl@0	120	* Parameters: TSize aSize, TBool aScreenAccess, TBool aSynchronized, TBool aCIBuffMgmt
sl@0	121	* Return: None
sl@0	122	* --------------------------------------------------------------------------*/
sl@0	123
sl@0	124	void CVDecTestEngine::SetUpL(TSize aSize, TBool aScreenAccess, TBool aCIBuffMgmt)
sl@0	125	{
sl@0	126
sl@0	127	iMemAlloc = 0;
sl@0	128	iMemDelete = 0;
sl@0	129	//Create DevVideoPlay
sl@0	130	iDevvp = CMMFDevVideoPlay::NewL(*this);
sl@0	131	PRINT((_L("CVDecTestEngine::SetUpL, DevVideo Created")))
sl@0	132	#ifdef __MEM_CHECK_
sl@0	133	PRINT((_L("CVDecTestEngine::SetUpL, mem alloc, iDevvp") ))
sl@0	134	#endif
sl@0	135	iMemAlloc++;
sl@0	136	iState = ECreated;
sl@0	137
sl@0	138	// Initilize Engine parameters
sl@0	139	iError = KErrNone;
sl@0	140	iDecHWDevId = 0;
sl@0	141	iPostProcId = 0;
sl@0	142	iInBuffSize = 0;
sl@0	143	iRawDataArea = NULL;
sl@0	144	iCodecType = ENoCodec;
sl@0	145	iInputEnd = EFalse;
sl@0	146	iFrameMatch = EFalse;
sl@0	147	iFrameJump = 0;
sl@0	148	iFrameJumpCounter = 0;
sl@0	149	iCorruptMarker = EFalse;
sl@0	150	iOutCorruptedFileOpen = EFalse;
sl@0	151	iFrameCounter = 0;
sl@0	152	iCorruptCounter = 0;
sl@0	153	iFlvCounter = 0;
sl@0	154	iFrameDropCounter = 0;
sl@0	155	iFrameDropInterval = 0;
sl@0	156	iFrameDropNum = 0;
sl@0	157	iFrameDropMarker = EFalse;
sl@0	158	iCurrentFilePos = 0;
sl@0	159	iFrameDropNumCounter = 0;
sl@0	160	iSetPassword = EFalse;
sl@0	161	iUseSecondScreen = EFalse;
sl@0	162
sl@0	163
sl@0	164	#ifdef __CI_HEADERS__
sl@0	165	iCIBuffMgmtOn = aCIBuffMgmt;
sl@0	166	#endif
sl@0	167
sl@0	168	iDirectScreenAccess = aScreenAccess;
sl@0	169	iSynchronized = EFalse;
sl@0	170	iLandscapeMode =EFalse;
sl@0	171
sl@0	172	PRINT((_L("CVDecTestEngine::SetUpL, reserving data chunk")));
sl@0	173
sl@0	174
sl@0	175	if (aSize.iWidth > 720 && aSize.iWidth > 576 )
sl@0	176	{
sl@0	177	iDataChunkSize = KMP4MaxCodedSize720P*4;
sl@0	178	iDataThreshold = KMP4MaxCodedSize720P;
sl@0	179	}
sl@0	180	else if (aSize.iWidth > 640 && aSize.iWidth > 480 )
sl@0	181	{
sl@0	182	iDataChunkSize = KMP4MaxCodedSizePAL*4;
sl@0	183	iDataThreshold = KMP4MaxCodedSizePAL;
sl@0	184	}
sl@0	185	else if (aSize.iWidth > 352 && aSize.iWidth > 288 )
sl@0	186	{
sl@0	187	iDataChunkSize = KMP4MaxCodedSizeVGA*4;
sl@0	188	iDataThreshold = KMP4MaxCodedSizeVGA;
sl@0	189	}
sl@0	190	else if (aSize.iWidth <= 352 && aSize.iWidth > 176)
sl@0	191	{
sl@0	192	iDataChunkSize = KMP4MaxCodedSizeCIF*4;
sl@0	193	iDataThreshold = KMP4MaxCodedSizeCIF;
sl@0	194	}
sl@0	195	else
sl@0	196	{
sl@0	197	iDataChunkSize = KMP4MaxCodedSizeQCIF*4;
sl@0	198	iDataThreshold = KMP4MaxCodedSizeQCIF;
sl@0	199	}
sl@0	200	PRINT((_L("CVDecTestEngine::SetUpL, Data chunk size is [%d]"), iDataChunkSize));
sl@0	201	PRINT((_L("CVDecTestEngine::SetUpL, Data threshold [%d]"), iDataThreshold));
sl@0	202	iDataChunk = new (ELeave) TUint8[iDataChunkSize];
sl@0	203	iMemAlloc++;
sl@0	204	#ifdef __MEM_CHECK_
sl@0	205	PRINT((_L("CVDecTestEngine::SetUpL, mem alloc, iDataChunk") ));
sl@0	206	#endif
sl@0	207	iReadDataChunk = iDataChunk;
sl@0	208	iWriteDataChunk = iDataChunk;
sl@0	209
sl@0	210
sl@0	211	iPictureSize.SetSize(aSize.iWidth,aSize.iHeight);
sl@0	212	TRect rect(iPictureSize);
sl@0	213	iDispRect = rect;
sl@0	214	iFrameMeasurement = EFalse;
sl@0	215	iDsaStarted = EFalse;
sl@0	216
sl@0	217	if ( aScreenAccess )
sl@0	218	{
sl@0	219	User::LeaveIfError( FbsStartup() );
sl@0	220	PRINT((_L("CVDecTestEngine::SetUpL, Fbs server started:")))
sl@0	221	}
sl@0	222
sl@0	223	//Open File session
sl@0	224	TInt err;
sl@0	225
sl@0	226	if ( (err = iFs.Connect()) != KErrNone )
sl@0	227	{
sl@0	228	PRINT((_L("CVDecTestEngine::SetUpL, Open File server session fail ")))
sl@0	229	User::Leave(err);
sl@0	230	}
sl@0	231	}
sl@0	232
sl@0	233	/* ----------------------------------------------------------------------------
sl@0	234	* Name: CVDecTestEngine::EnableFrameMeasurementTest
sl@0	235	* Purpose: Enable Perforamce test flag
sl@0	236	* Note
sl@0	237	* Parameters: TBool a Enable
sl@0	238	* Return: None
sl@0	239	* --------------------------------------------------------------------------*/
sl@0	240
sl@0	241	void CVDecTestEngine::EnableFrameMeasurementTest(TBool aEnable)
sl@0	242	{
sl@0	243	iFrameMeasurement = aEnable;
sl@0	244	}
sl@0	245
sl@0	246	/* ----------------------------------------------------------------------------
sl@0	247	* Name: CVDecTestEngine::SetInputBufferSize
sl@0	248	* Purpose:
sl@0	249	* Note
sl@0	250	* Parameters: TBool a Enable
sl@0	251	* Return: None
sl@0	252	* --------------------------------------------------------------------------*/
sl@0	253
sl@0	254	void CVDecTestEngine::SetInputBufferSize(TInt aSize)
sl@0	255	{
sl@0	256	iInBuffSize = aSize;
sl@0	257	if ( iCIBuffMgmtOn ) //Custom interfarce Buffer management is used
sl@0	258	{
sl@0	259	PRINT((_L("CVDecTestEngine::SetInputBufferSize, CI Buffer management")))
sl@0	260	#ifdef __CI_HEADERS__
sl@0	261	iCIBuffMgmt = (MMmfVideoBufferManagement*)iDevvp->CustomInterface(iPostProcId, KMmfVideoBuffermanagementUid);
sl@0	262	iCIBuffMgmt->MmvbmSetObserver(this);
sl@0	263	iCIBuffMgmt->MmvbmEnable(ETrue);
sl@0	264
sl@0	265	MMmfVideoBufferManagement::TBufferOptions options;
sl@0	266	options.iNumInputBuffers = KNumOfInputBuffers;
sl@0	267	options.iBufferSize = iPictureSize;
sl@0	268
sl@0	269	iCIBuffMgmt->MmvbmSetBufferOptionsL(options);
sl@0	270
sl@0	271	PRINT((_L("CVDecTestEngine::SetInputBufferSize, CI Buffer management Set, Buff size:[%d],[%d]"),iPictureSize.iWidth,iPictureSize.iHeight))
sl@0	272	#endif
sl@0	273	}
sl@0	274
sl@0	275	else //Use default Devvideo API for buffer management
sl@0	276	{
sl@0	277
sl@0	278	iRawInBuffer = new(ELeave) TVideoPicture;
sl@0	279	iMemAlloc++;
sl@0	280	#ifdef __MEM_CHECK_
sl@0	281	PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem alloc, iRawInBuffer") ));
sl@0	282	#endif
sl@0	283	TUint8* ptr = new (ELeave) TUint8[iInBuffSize];
sl@0	284	iMemAlloc++;
sl@0	285	#ifdef __MEM_CHECK_
sl@0	286	PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem alloc, ptr") ));
sl@0	287	#endif
sl@0	288	TPtr8* temp = new (ELeave) TPtr8(ptr, 0, iInBuffSize);
sl@0	289	iMemAlloc++;
sl@0	290	#ifdef __MEM_CHECK_
sl@0	291	PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem alloc, temp") ));
sl@0	292	#endif
sl@0	293	iRawInBuffer->iData.iRawData = temp;
sl@0	294
sl@0	295	iRawInBuffer->iData.iDataSize.SetSize(iPictureSize.iWidth,iPictureSize.iHeight); //set picture size
sl@0	296
sl@0	297	iRawInBuffer->iOptions = 0;
sl@0	298	iRawInBuffer->iTimestamp = 0;
sl@0	299	delete ptr;
sl@0	300	iMemDelete++;
sl@0	301	delete temp;
sl@0	302	iMemDelete++;
sl@0	303	#ifdef __MEM_CHECK_
sl@0	304	PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem del, ptr & temp") ));
sl@0	305	#endif
sl@0	306	PRINT((_L("CVDecTestEngine::SetInputBufferSize, Buffer created: Size[%d]"),iInBuffSize))
sl@0	307	}
sl@0	308	}
sl@0	309
sl@0	310
sl@0	311	/* ----------------------------------------------------------------------------
sl@0	312	* Name: CVDecTestEngine::GetHeaderInformationL()
sl@0	313	* Purpose: Ritrieve header Information
sl@0	314	* Parameters: TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation
sl@0	315	* Return: None
sl@0	316	---------------------------------------------------------------------------/
sl@0	317
sl@0	318	void CVDecTestEngine::GetHeaderInformationL(TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation)
sl@0	319	{
sl@0	320	TInt err = KErrNone;
sl@0	321	TVideoPictureHeader* headerInfo = NULL;
sl@0	322	HBufC8* tempBuff = NULL;
sl@0	323
sl@0	324	//Read Picture header : Size is not known
sl@0	325	TVideoInputBuffer* codedBuffer = new(ELeave) TVideoInputBuffer;
sl@0	326	iMemAlloc++;
sl@0	327	CleanupStack::PushL( codedBuffer );
sl@0	328	#ifdef __MEM_CHECK_
sl@0	329	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, codedBuffer") ))
sl@0	330	#endif
sl@0	331	iInBuffSize = KMaxCodedSize;
sl@0	332	err = KErrOverflow;
sl@0	333
sl@0	334	while ( (err == KErrOverflow) && (iInBuffSize <= KMaxCodedSize) )
sl@0	335	{
sl@0	336	tempBuff = HBufC8::NewL(iInBuffSize);
sl@0	337	iMemAlloc++;
sl@0	338	CleanupStack::PushL( tempBuff );
sl@0	339	#ifdef __MEM_CHECK_
sl@0	340	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, codedBuffer") ))
sl@0	341	#endif
sl@0	342	codedBuffer->iData.Set(tempBuff->Des());
sl@0	343	if ( iFrameSizeList.Count() > 0 )
sl@0	344	{
sl@0	345	err = ReadOneCodedPicture(codedBuffer, iFrameSizeList[0] );
sl@0	346	}
sl@0	347	else
sl@0	348	{
sl@0	349	err = ReadOneCodedPicture(codedBuffer);
sl@0	350	}
sl@0	351
sl@0	352	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, return err [%d]"),err))
sl@0	353	TInt pos =0;
sl@0	354	if ( iInFile.Seek(ESeekStart,pos) )
sl@0	355	{
sl@0	356	err = KErrGeneral;
sl@0	357	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, err = KErrGeneral")))
sl@0	358	}
sl@0	359
sl@0	360	if ( iInputEnd )
sl@0	361	{
sl@0	362	err = KErrNotFound;
sl@0	363	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, err = KErrNotFound")))
sl@0	364	}
sl@0	365
sl@0	366	if ( err < 0 )
sl@0	367	{
sl@0	368	CleanupStack::PopAndDestroy(tempBuff);
sl@0	369	iMemDelete++;
sl@0	370	#ifdef __MEM_CHECK_
sl@0	371	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff") ))
sl@0	372	#endif
sl@0	373	iInBuffSize = 4*iInBuffSize;
sl@0	374	}
sl@0	375	}
sl@0	376
sl@0	377	// Reitrieve header information from bitstream
sl@0	378	if ( err < 0 )
sl@0	379	{
sl@0	380	CleanupStack::PopAndDestroy(codedBuffer);
sl@0	381	iMemDelete++;
sl@0	382	#ifdef __MEM_CHECK_
sl@0	383	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, codedBuffer") ))
sl@0	384	#endif
sl@0	385	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Reading input data fail")))
sl@0	386	}
sl@0	387	else
sl@0	388	{
sl@0	389	err = KErrNone;
sl@0	390	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, call adaptation layer")))
sl@0	391	headerInfo = iDevvp->GetHeaderInformationL(aDataUnitType,aDataUnitEncapsulation,codedBuffer);
sl@0	392
sl@0	393	CleanupStack::PopAndDestroy(tempBuff);
sl@0	394	iMemDelete++;
sl@0	395	CleanupStack::PopAndDestroy(codedBuffer);
sl@0	396	iMemDelete++;
sl@0	397	#ifdef __MEM_CHECK_
sl@0	398	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff & codedBuffer") ))
sl@0	399	#endif
sl@0	400	//Check Header info
sl@0	401	if ( !err && headerInfo )
sl@0	402	{
sl@0	403	//Size in Memory
sl@0	404	iPictureSize = headerInfo->iDisplayedRect.Size();
sl@0	405	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Picture Size :width[%d], height[%d]"),iPictureSize.iWidth,iPictureSize.iHeight))
sl@0	406
sl@0	407	// Display rect
sl@0	408	iDispRect = headerInfo->iDisplayedRect;
sl@0	409	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Displayed image portion: Width[%d] to Height[%d]"),headerInfo->iDisplayedRect.Width(),headerInfo->iDisplayedRect.Height()))
sl@0	410
sl@0	411	//return headerInfo
sl@0	412	iDevvp->ReturnHeader(headerInfo);
sl@0	413
sl@0	414	}
sl@0	415	else //temp modify because MP4HwDevice of Emuzed returns null information in 1st release
sl@0	416	{
sl@0	417	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Get header info fail")))
sl@0	418	err = KErrGeneral;
sl@0	419	}
sl@0	420	}
sl@0	421
sl@0	422	AssertTIntEqualL(KErrNone, err);
sl@0	423
sl@0	424	}
sl@0	425
sl@0	426
sl@0	427	/* ----------------------------------------------------------------------------
sl@0	428	* Name: CVDecTestEngine::GetHeaderInformationL()
sl@0	429	* Purpose: Retrieve header Information
sl@0	430	* Parameters: None
sl@0	431	* Return: None
sl@0	432	---------------------------------------------------------------------------/
sl@0	433
sl@0	434	void CVDecTestEngine::GetHeaderInformationL()
sl@0	435	{
sl@0	436	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, In")))
sl@0	437	TInt err = KErrNone;
sl@0	438	TVideoPictureHeader* headerInfo = NULL;
sl@0	439	HBufC8* tempBuff = NULL;
sl@0	440
sl@0	441	//Read Picture header : Size is not known
sl@0	442	TVideoInputBuffer* codedBuffer = new(ELeave) TVideoInputBuffer;
sl@0	443	iMemAlloc++;
sl@0	444	CleanupStack::PushL( codedBuffer );
sl@0	445	#ifdef __MEM_CHECK_
sl@0	446	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, codedBuffer") ))
sl@0	447	#endif
sl@0	448	iInBuffSize = KMaxCodedSize;
sl@0	449	err = KErrOverflow;
sl@0	450
sl@0	451	while ( (err == KErrOverflow) && (iInBuffSize <= KMaxCodedSize) )
sl@0	452	{
sl@0	453	tempBuff = HBufC8::NewL(iInBuffSize);
sl@0	454	iMemAlloc++;
sl@0	455	CleanupStack::PushL( tempBuff );
sl@0	456	#ifdef __MEM_CHECK_
sl@0	457	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, tempBuff") ))
sl@0	458	#endif
sl@0	459	codedBuffer->iData.Set(tempBuff->Des());
sl@0	460
sl@0	461	if ( iFrameSizeList.Count() > 0 )
sl@0	462	{
sl@0	463	err = ReadOneCodedPicture(codedBuffer, iFrameSizeList[0] );
sl@0	464	}
sl@0	465	else
sl@0	466	{
sl@0	467	err = ReadOneCodedPicture(codedBuffer);
sl@0	468	}
sl@0	469
sl@0	470
sl@0	471	TInt pos =0;
sl@0	472	if ( iInFile.Seek(ESeekStart,pos) )
sl@0	473	{
sl@0	474	err = KErrGeneral;
sl@0	475	}
sl@0	476
sl@0	477	if ( iInputEnd )
sl@0	478	{
sl@0	479	err = KErrNotFound;
sl@0	480	}
sl@0	481
sl@0	482	if ( err < 0 )
sl@0	483	{
sl@0	484	CleanupStack::PopAndDestroy(tempBuff);
sl@0	485	iMemDelete++;
sl@0	486	#ifdef __MEM_CHECK_
sl@0	487	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff") ))
sl@0	488	#endif
sl@0	489	iInBuffSize = 4*iInBuffSize;
sl@0	490	}
sl@0	491	}
sl@0	492
sl@0	493
sl@0	494	// Reitrieve header information from bitstream
sl@0	495	if ( err < 0 )
sl@0	496	{
sl@0	497	CleanupStack::PopAndDestroy(codedBuffer);
sl@0	498	iMemDelete++;
sl@0	499	#ifdef __MEM_CHECK_
sl@0	500	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, codedBuffer") ))
sl@0	501	#endif
sl@0	502	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Reading input data fail")))
sl@0	503	}
sl@0	504	else
sl@0	505	{
sl@0	506	err = KErrNone;
sl@0	507
sl@0	508	headerInfo = iDevvp->GetHeaderInformationL(EDuCodedPicture,EDuElementaryStream,codedBuffer);
sl@0	509
sl@0	510	CleanupStack::PopAndDestroy(tempBuff);
sl@0	511	CleanupStack::PopAndDestroy(codedBuffer);
sl@0	512	iMemDelete++;
sl@0	513	iMemDelete++;
sl@0	514	#ifdef __MEM_CHECK_
sl@0	515	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff & codedBuffer") ))
sl@0	516	#endif
sl@0	517
sl@0	518	//Check Header info
sl@0	519	if ( headerInfo )
sl@0	520	{
sl@0	521	//Size in Memory
sl@0	522	iPictureSize = headerInfo->iDisplayedRect.Size();
sl@0	523	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Picture Size :width[%d], height[%d]"),iPictureSize.iWidth,iPictureSize.iHeight))
sl@0	524
sl@0	525	// Display rect
sl@0	526	iDispRect = headerInfo->iDisplayedRect;
sl@0	527	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Displayed image portion: Width[%d] to Height[%d]"),headerInfo->iDisplayedRect.Width(),headerInfo->iDisplayedRect.Height()))
sl@0	528
sl@0	529	iDevvp->ReturnHeader(headerInfo);
sl@0	530
sl@0	531	}
sl@0	532	else
sl@0	533	{
sl@0	534	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Get header info fail")))
sl@0	535	err = KErrGeneral;
sl@0	536	}
sl@0	537
sl@0	538	}
sl@0	539
sl@0	540	// Set size of decoder input buffer
sl@0	541	if ( iCodecType == EH263 )
sl@0	542	{
sl@0	543	if ( (iPictureSize.iWidth <= 176 ) && (iPictureSize.iHeight <= 144) )
sl@0	544	{
sl@0	545	iInBuffSize = KH263MaxCodedSizeQCIF;
sl@0	546	}
sl@0	547	else
sl@0	548	{
sl@0	549	iInBuffSize = KH263MaxCodedSizeCIF;
sl@0	550	}
sl@0	551	}
sl@0	552	else //Mpeg4
sl@0	553	{
sl@0	554	if ( (iPictureSize.iWidth <= 176 ) && (iPictureSize.iHeight <= 144) )
sl@0	555	{
sl@0	556	iInBuffSize = KMP4MaxCodedSizeQCIF;
sl@0	557	}
sl@0	558	else if ( (iPictureSize.iWidth <= 352 ) && (iPictureSize.iHeight <= 288) )
sl@0	559	{
sl@0	560	iInBuffSize = KMP4MaxCodedSizeCIF;
sl@0	561	}
sl@0	562
sl@0	563	else
sl@0	564	{
sl@0	565	iInBuffSize = KMP4MaxCodedSizeVGA;
sl@0	566	}
sl@0	567
sl@0	568	}
sl@0	569
sl@0	570	AssertTIntEqualL(KErrNone, err);
sl@0	571	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Out")))
sl@0	572	}
sl@0	573
sl@0	574	/* ----------------------------------------------------------------------------
sl@0	575	* Name: CVDecTestEngine::SetCodecType
sl@0	576	* Purpose: Set Cotec type
sl@0	577	* Parameters: TVideoCodec aCodec
sl@0	578	*
sl@0	579	* Return: None
sl@0	580	* --------------------------------------------------------------------------*/
sl@0	581
sl@0	582	void CVDecTestEngine::SetCodecType(TVideoCodec aCodec)
sl@0	583	{
sl@0	584	iCodecType = aCodec;
sl@0	585	}
sl@0	586
sl@0	587	/* ----------------------------------------------------------------------------
sl@0	588	* Name: CVDecTestEngine::GetBitstreamCountersL()
sl@0	589	* Purpose:
sl@0	590	* Parameters:
sl@0	591	*
sl@0	592	* Return: None
sl@0	593	* --------------------------------------------------------------------------*/
sl@0	594
sl@0	595	void CVDecTestEngine::GetBitstreamCountersL()
sl@0	596	{
sl@0	597	PRINT((_L("CVDecTestEngine::GetBitstreamCountersL In")))
sl@0	598
sl@0	599	CMMFDevVideoPlay::TBitstreamCounters lCounters;
sl@0	600
sl@0	601	iDevvp->GetBitstreamCounters(lCounters);
sl@0	602
sl@0	603	PRINT((_L("CVDecTestEngine::GetBitstreamCountersL, Lost Packets = %d"),lCounters.iLostPackets))
sl@0	604	PRINT((_L("CVDecTestEngine::GetBitstreamCountersL, Total Packets = %d"), lCounters.iTotalPackets))
sl@0	605
sl@0	606	PRINT((_L("CVDecTestEngine::GetBitstreamCountersL Out")))
sl@0	607	}
sl@0	608
sl@0	609	/* ----------------------------------------------------------------------------
sl@0	610	* Name: CVDecTestEngine::PreDecoderBufferBytes()
sl@0	611	* Purpose:
sl@0	612	* Parameters:
sl@0	613	*
sl@0	614	* Return: None
sl@0	615	* --------------------------------------------------------------------------*/
sl@0	616
sl@0	617	void CVDecTestEngine::PreDecoderBufferBytes()
sl@0	618	{
sl@0	619	PRINT((_L("CVDecTestEngine::PreDecoderBufferBytes, In")))
sl@0	620
sl@0	621	TUint lBufferBytes = iDevvp->PreDecoderBufferBytes();
sl@0	622	PRINT((_L("CVDecTestEngine::PreDecoderBufferBytes, Number of bytes of data in the pre-decoder buffer = %d"), lBufferBytes))
sl@0	623
sl@0	624	PRINT((_L("CVDecTestEngine::PreDecoderBufferBytes, Out")))
sl@0	625	}
sl@0	626
sl@0	627	/* ----------------------------------------------------------------------------
sl@0	628	* Name: CVDecTestEngine::PictureBufferBytes()
sl@0	629	* Purpose:
sl@0	630	* Parameters:
sl@0	631	*
sl@0	632	* Return: None
sl@0	633	* --------------------------------------------------------------------------*/
sl@0	634
sl@0	635	void CVDecTestEngine::PictureBufferBytes()
sl@0	636	{
sl@0	637	PRINT((_L("CVDecTestEngine::PictureBufferBytes, In")))
sl@0	638
sl@0	639	TUint buffbyte = iDevvp->PictureBufferBytes();
sl@0	640	PRINT((_L("CVDecTestEngine::PictureBufferBytes: total amount of memory allocated [%d]"),buffbyte))
sl@0	641
sl@0	642	PRINT((_L("CVDecTestEngine::PictureBufferBytes, Out")))
sl@0	643	}
sl@0	644
sl@0	645	/* ----------------------------------------------------------------------------
sl@0	646	* Name: CVDecTestEngine::SetPostProcessTypesL()
sl@0	647	* Purpose: Set combination of postprocessor
sl@0	648	*
sl@0	649	* Parameters: TUint32 aCombination
sl@0	650	* Return: None
sl@0	651	* --------------------------------------------------------------------------*/
sl@0	652
sl@0	653	void CVDecTestEngine::SetPostProcessTypesL(TInt aHWDevice, TUint32 aCombination)
sl@0	654	{
sl@0	655	PRINT((_L("CVDecTestEngine::SetPostProcessTypesL, In")))
sl@0	656
sl@0	657	if (aHWDevice == EPostProcessor)
sl@0	658	{
sl@0	659	iDevvp->SetPostProcessTypesL(iPostProcId,aCombination);
sl@0	660	}
sl@0	661	else
sl@0	662	{
sl@0	663	iDevvp->SetPostProcessTypesL(iDecHWDevId,aCombination);
sl@0	664	}
sl@0	665
sl@0	666	PRINT((_L("CVDecTestEngine::SetPostProcessTypesL, Out")))
sl@0	667	}
sl@0	668
sl@0	669
sl@0	670	/* ----------------------------------------------------------------------------
sl@0	671	* Name: CVDecTestEngine::SetInputCropOptionsL()
sl@0	672	* Purpose: Set input crop
sl@0	673	*
sl@0	674	* Parameters: TRect aCrop
sl@0	675	* Return: None
sl@0	676	* --------------------------------------------------------------------------*/
sl@0	677
sl@0	678	void CVDecTestEngine::SetInputCropOptionsL(TInt aHWDevice, TRect aCrop)
sl@0	679	{
sl@0	680	PRINT((_L("CVDecTestEngine::SetInputCropOptionsL, In")))
sl@0	681
sl@0	682	if (aHWDevice == EPostProcessor)
sl@0	683	{
sl@0	684	iDevvp->SetInputCropOptionsL(iPostProcId,aCrop);
sl@0	685	}
sl@0	686	else
sl@0	687	{
sl@0	688	iDevvp->SetInputCropOptionsL(iDecHWDevId,aCrop);
sl@0	689	}
sl@0	690
sl@0	691	PRINT((_L("CVDecTestEngine::SetInputCropOptionsL, Out")))
sl@0	692	}
sl@0	693
sl@0	694	/* ----------------------------------------------------------------------------
sl@0	695	* Name: CVDecTestEngine::SetYuvToRgbOptionsL()
sl@0	696	* Purpose: Set Yuv to Rgb options
sl@0	697	*
sl@0	698	* Parameters: TYuvToRgbOptions aOptions
sl@0	699	* Return: None
sl@0	700	* --------------------------------------------------------------------------*/
sl@0	701
sl@0	702	void CVDecTestEngine::SetYuvToRgbOptionsL(TInt aHWDevice, TYuvToRgbOptions aOptions)
sl@0	703	{
sl@0	704	PRINT((_L("CVDecTestEngine::SetYuvToRgbOptionsL, In")))
sl@0	705
sl@0	706	if (aHWDevice == EPostProcessor)
sl@0	707	{
sl@0	708	iDevvp->SetYuvToRgbOptionsL(iPostProcId, aOptions);
sl@0	709	}
sl@0	710	else
sl@0	711	{
sl@0	712	iDevvp->SetYuvToRgbOptionsL(iDecHWDevId, aOptions);
sl@0	713	}
sl@0	714
sl@0	715	PRINT((_L("CVDecTestEngine::SetYuvToRgbOptionsL, Out")))
sl@0	716	}
sl@0	717
sl@0	718
sl@0	719	/* ----------------------------------------------------------------------------
sl@0	720	* Name: CVDecTestEngine::SetRotateOptionsL()
sl@0	721	* Purpose: Set Rotation
sl@0	722	*
sl@0	723	* Parameters: TRotationType aRotation
sl@0	724	* Return: None
sl@0	725	* --------------------------------------------------------------------------*/
sl@0	726	void CVDecTestEngine::SetRotateOptionsL(TInt aHWDevice, TRotationType aRotation)
sl@0	727	{
sl@0	728	PRINT((_L("CVDecTestEngine::SetRotateOptionsL, In")))
sl@0	729
sl@0	730	if (aHWDevice == EPostProcessor)
sl@0	731	{
sl@0	732	iDevvp->SetRotateOptionsL(iPostProcId, aRotation);
sl@0	733	}
sl@0	734	else
sl@0	735	{
sl@0	736	iDevvp->SetRotateOptionsL(iDecHWDevId, aRotation);
sl@0	737	}
sl@0	738
sl@0	739	PRINT((_L("CVDecTestEngine::SetRotateOptionsL, Out")))
sl@0	740	}
sl@0	741
sl@0	742
sl@0	743	/* ----------------------------------------------------------------------------
sl@0	744	* Name: CVDecTestEngine::SetScaleOptionsL()
sl@0	745	* Purpose: Set Scale with multiply factor
sl@0	746	*
sl@0	747	* Parameters: TSize aSize, TBool aAntiAliasFiltering
sl@0	748	* Return: None
sl@0	749	* --------------------------------------------------------------------------*/
sl@0	750	void CVDecTestEngine::SetScaleOptionsL(TInt aHWDevice, TSize aSize, TBool aAntiAliasFiltering)
sl@0	751	{
sl@0	752	PRINT((_L("CVDecTestEngine::SetScaleOptionsL, In")));
sl@0	753
sl@0	754	if (aHWDevice == EPostProcessor)
sl@0	755	{
sl@0	756	iDevvp->SetScaleOptionsL(iPostProcId, aSize, aAntiAliasFiltering);
sl@0	757	}
sl@0	758	else
sl@0	759	{
sl@0	760	iDevvp->SetScaleOptionsL(iDecHWDevId, aSize, aAntiAliasFiltering);
sl@0	761	}
sl@0	762
sl@0	763	PRINT((_L("CVDecTestEngine::SetScaleOptionsL, Scale option is set:width[%d],height[%d]"), aSize.iWidth,aSize.iHeight))
sl@0	764
sl@0	765	PRINT((_L("CVDecTestEngine::SetScaleOptionsL, Out")));
sl@0	766	}
sl@0	767
sl@0	768	/* ----------------------------------------------------------------------------
sl@0	769	* Name: CVDecTestEngine::SetScaleOptionsL()
sl@0	770	* Purpose: Set Scale with multiply factor
sl@0	771	*
sl@0	772	* Parameters: TInt aNumFactor,TInt aDenoFactor, TBool aAntiAliasFiltering
sl@0	773	* Return: None
sl@0	774	* --------------------------------------------------------------------------*/
sl@0	775	void CVDecTestEngine::SetScaleOptionsL(TInt aNumFactor,TInt aDenoFactor, TBool aAntiAliasFiltering)
sl@0	776	{
sl@0	777	PRINT((_L("CVDecTestEngine::SetScaleOptionsL, Out")));
sl@0	778
sl@0	779	TInt width = static_cast<TInt>(iPictureSize.iWidth*aNumFactor/aDenoFactor);
sl@0	780	TInt height = static_cast<TInt>(iPictureSize.iHeight*aNumFactor/aDenoFactor);
sl@0	781
sl@0	782	TSize target(width, height);
sl@0	783
sl@0	784	iDevvp->SetScaleOptionsL(iPostProcId, target, aAntiAliasFiltering);
sl@0	785	PRINT((_L("CVDecTestEngine::SetScaleOptionsL, Scale option is set:width[%d],height[%d]"),target.iWidth,target.iHeight))
sl@0	786
sl@0	787	PRINT((_L("CVDecTestEngine::SetScaleOptionsL, Out")));
sl@0	788	}
sl@0	789
sl@0	790
sl@0	791	/* ----------------------------------------------------------------------------
sl@0	792	* Name: CVDecTestEngine::SetOutputCropOptionsL()
sl@0	793	* Purpose: Set output crop
sl@0	794	*
sl@0	795	* Parameters: TRect aCrop
sl@0	796	* Return: None
sl@0	797	* --------------------------------------------------------------------------*/
sl@0	798	void CVDecTestEngine::SetOutputCropOptionsL(TInt aHWDevice, TRect aCrop)
sl@0	799	{
sl@0	800	PRINT((_L("CVDecTestEngine::SetOutputCropOptionsL, In")));
sl@0	801
sl@0	802	if (aHWDevice == EPostProcessor)
sl@0	803	{
sl@0	804	iDevvp->SetOutputCropOptionsL(iPostProcId, aCrop);
sl@0	805	}
sl@0	806	else
sl@0	807	{
sl@0	808	iDevvp->SetOutputCropOptionsL(iDecHWDevId, aCrop);
sl@0	809	}
sl@0	810
sl@0	811	PRINT((_L("CVDecTestEngine::SetOutputCropOptionsL, Out")));
sl@0	812	}
sl@0	813
sl@0	814
sl@0	815	/* ----------------------------------------------------------------------------
sl@0	816	* Name: CVDecTestEngine::CommitL()
sl@0	817	* Purpose: commit change of postprocessors after intialization or revert
sl@0	818	*
sl@0	819	* Parameters: None
sl@0	820	* Return: None
sl@0	821	* --------------------------------------------------------------------------*/
sl@0	822
sl@0	823	void CVDecTestEngine::CommitL()
sl@0	824	{
sl@0	825	PRINT((_L("CVDecTestEngine::CommitL, In")));
sl@0	826
sl@0	827	iDevvp->CommitL();
sl@0	828
sl@0	829	PRINT((_L("CVDecTestEngine::CommitL, Out")));
sl@0	830	}
sl@0	831
sl@0	832	/* ----------------------------------------------------------------------------
sl@0	833	* Name: CVDecTestEngine::Revert()
sl@0	834	* Purpose: Revert any configuration changes that have not yet been committed
sl@0	835	*
sl@0	836	* Parameters: None
sl@0	837	* Return: None
sl@0	838	* --------------------------------------------------------------------------*/
sl@0	839	void CVDecTestEngine::Revert()
sl@0	840	{
sl@0	841	PRINT((_L("CVDecTestEngine::Revert, In")));
sl@0	842
sl@0	843	iDevvp->Revert();
sl@0	844
sl@0	845	PRINT((_L("CVDecTestEngine::Revert, Out")));
sl@0	846	}
sl@0	847
sl@0	848	/* ----------------------------------------------------------------------------
sl@0	849	* Name: CVDecTestEngine::SetClockSource()
sl@0	850	* Purpose: Set SetHrdVbvSpec
sl@0	851	* Note: This is called before initilaized
sl@0	852	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	853	* Return: None
sl@0	854	* --------------------------------------------------------------------------*/
sl@0	855
sl@0	856	void CVDecTestEngine::SetClockSource()
sl@0	857	{
sl@0	858	PRINT((_L("CVDecTestEngine::SetClockSource, In")))
sl@0	859
sl@0	860	iDevvp->SetClockSource(iClock);
sl@0	861
sl@0	862	PRINT((_L("CVDecTestEngine::SetClockSource, Out")))
sl@0	863	}
sl@0	864
sl@0	865	/* ----------------------------------------------------------------------------
sl@0	866	* Name: CVDecTestEngine::SetHrdVbvSpec()
sl@0	867	* Purpose: Set SetHrdVbvSpec
sl@0	868	* Note: This is called before initilaized
sl@0	869	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	870	* Return: None
sl@0	871	* --------------------------------------------------------------------------*/
sl@0	872
sl@0	873	void CVDecTestEngine::SetHrdVbvSpec(THrdVbvSpecification aHrdVbvSpec, const TDesC8& aHrdVbvParams)
sl@0	874	{
sl@0	875	PRINT((_L("CVDecTestEngine::SetHrdVbvSpec, In")))
sl@0	876
sl@0	877	iDevvp->SetHrdVbvSpec(aHrdVbvSpec, aHrdVbvParams);
sl@0	878
sl@0	879	PRINT((_L("CVDecTestEngine::SetHrdVbvSpec, Out")))
sl@0	880	}
sl@0	881
sl@0	882	/* ----------------------------------------------------------------------------
sl@0	883	* Name: CVDecTestEngine::SetPostProcSpecificOptionsL()
sl@0	884	* Purpose: Set SetHrdVbvSpec
sl@0	885	* Note: This is called before initilaized
sl@0	886	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	887	* Return: None
sl@0	888	* --------------------------------------------------------------------------*/
sl@0	889
sl@0	890	void CVDecTestEngine::SetPostProcSpecificOptionsL(TInt aHWDevice, const TDesC8& aOptions)
sl@0	891	{
sl@0	892	PRINT((_L("CVDecTestEngine::SetPostProcSpecificOptionsL, In")))
sl@0	893
sl@0	894	if (aHWDevice == EPostProcessor)
sl@0	895	{
sl@0	896	iDevvp->SetPostProcSpecificOptionsL(iPostProcId, aOptions);
sl@0	897	}
sl@0	898	else
sl@0	899	{
sl@0	900	iDevvp->SetPostProcSpecificOptionsL(iDecHWDevId, aOptions);
sl@0	901	}
sl@0	902
sl@0	903	PRINT((_L("CVDecTestEngine::SetPostProcSpecificOptionsL, Out")))
sl@0	904	}
sl@0	905
sl@0	906	/* ----------------------------------------------------------------------------
sl@0	907	* Name: CVDecTestEngine::SetScreenClipRegion()
sl@0	908	* Purpose: Set SetHrdVbvSpec
sl@0	909	* Note: This is called before initilaized
sl@0	910	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	911	* Return: None
sl@0	912	* --------------------------------------------------------------------------*/
sl@0	913
sl@0	914	void CVDecTestEngine::SetScreenClipRegion(TRegion& aRegion)
sl@0	915	{
sl@0	916	PRINT((_L("CVDecTestEngine::SetScreenClipRegion, In")))
sl@0	917
sl@0	918	iDevvp->SetScreenClipRegion(aRegion);
sl@0	919
sl@0	920	PRINT((_L("CVDecTestEngine::SetScreenClipRegion, Out")))
sl@0	921	}
sl@0	922
sl@0	923	/* ----------------------------------------------------------------------------
sl@0	924	* Name: CVDecTestEngine::SetPauseOnClipFail()
sl@0	925	* Purpose: Set SetHrdVbvSpec
sl@0	926	* Note: This is called before initilaized
sl@0	927	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	928	* Return: None
sl@0	929	* --------------------------------------------------------------------------*/
sl@0	930
sl@0	931	void CVDecTestEngine::SetPauseOnClipFail(TBool aPause)
sl@0	932	{
sl@0	933	PRINT((_L("CVDecTestEngine::SetPauseOnClipFail, In")))
sl@0	934
sl@0	935	iDevvp->SetPauseOnClipFail(aPause);
sl@0	936
sl@0	937	PRINT((_L("CVDecTestEngine::SetPauseOnClipFail, Out")))
sl@0	938	}
sl@0	939
sl@0	940	/* ----------------------------------------------------------------------------
sl@0	941	* Name: CVDecTestEngine::IsPlaying()
sl@0	942	* Purpose: Set SetHrdVbvSpec
sl@0	943	* Note: This is called before initilaized
sl@0	944	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	945	* Return: None
sl@0	946	* --------------------------------------------------------------------------*/
sl@0	947
sl@0	948	void CVDecTestEngine::IsPlaying()
sl@0	949	{
sl@0	950	PRINT((_L("CVDecTestEngine::IsPlaying, In")))
sl@0	951
sl@0	952	TUint playing = iDevvp->IsPlaying();
sl@0	953	PRINT((_L("CVDecTestEngine::IsPlaying, [%d]"), playing))
sl@0	954
sl@0	955	PRINT((_L("CVDecTestEngine::IsPlaying, Out")))
sl@0	956
sl@0	957	}
sl@0	958
sl@0	959	/* ----------------------------------------------------------------------------
sl@0	960	* Name: CVDecTestEngine::GetPictureCounters()
sl@0	961	* Purpose: Set SetHrdVbvSpec
sl@0	962	* Note: This is called before initilaized
sl@0	963	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	964	* Return: None
sl@0	965	* --------------------------------------------------------------------------*/
sl@0	966
sl@0	967	void CVDecTestEngine::GetPictureCounters()
sl@0	968	{
sl@0	969	PRINT((_L("CVDecTestEngine::GetPictureCounters, In")))
sl@0	970
sl@0	971	CMMFDevVideoPlay::TPictureCounters counters;
sl@0	972	iDevvp->GetPictureCounters(counters);
sl@0	973
sl@0	974	PRINT((_L("CVDecTestEngine::GetPictureCounters, iPicturesSkipped, [%d]"), counters.iPicturesSkipped))
sl@0	975	PRINT((_L("CVDecTestEngine::GetPictureCounters, iPicturesDecoded, [%d]"), counters.iPicturesDecoded))
sl@0	976	PRINT((_L("CVDecTestEngine::GetPictureCounters, iPicturesDisplayed, [%d]"), counters.iPicturesDisplayed))
sl@0	977	PRINT((_L("CVDecTestEngine::GetPictureCounters, iTotalPictures, [%d]"), counters.iTotalPictures))
sl@0	978
sl@0	979	PRINT((_L("CVDecTestEngine::GetPictureCounters, Out")))
sl@0	980	}
sl@0	981
sl@0	982	/* ----------------------------------------------------------------------------
sl@0	983	* Name: CVDecTestEngine::NumFreeBuffers()
sl@0	984	* Purpose: Set SetHrdVbvSpec
sl@0	985	* Note: This is called before initilaized
sl@0	986	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	987	* Return: None
sl@0	988	* --------------------------------------------------------------------------*/
sl@0	989
sl@0	990	void CVDecTestEngine::NumFreeBuffers()
sl@0	991	{
sl@0	992	PRINT((_L("CVDecTestEngine::NumFreeBuffers, In")))
sl@0	993
sl@0	994	TUint playing = iDevvp->NumFreeBuffers();
sl@0	995	PRINT((_L("CVDecTestEngine::NumFreeBuffers, [%d]"), playing))
sl@0	996
sl@0	997	PRINT((_L("CVDecTestEngine::NumFreeBuffers, Out")))
sl@0	998
sl@0	999	}
sl@0	1000
sl@0	1001	/* ----------------------------------------------------------------------------
sl@0	1002	* Name: CVDecTestEngine::NumComplexityLevels()
sl@0	1003	* Purpose: Set SetHrdVbvSpec
sl@0	1004	* Note: This is called before initilaized
sl@0	1005	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1006	* Return: None
sl@0	1007	* --------------------------------------------------------------------------*/
sl@0	1008
sl@0	1009	void CVDecTestEngine::NumComplexityLevels(TInt aHWDevice)
sl@0	1010	{
sl@0	1011	PRINT((_L("CVDecTestEngine::NumComplexityLevels, In")))
sl@0	1012
sl@0	1013	TUint number = 0;
sl@0	1014	if (aHWDevice == EPostProcessor)
sl@0	1015	{
sl@0	1016	number = iDevvp->NumComplexityLevels(iPostProcId);
sl@0	1017	}
sl@0	1018	else
sl@0	1019	{
sl@0	1020	number = iDevvp->NumComplexityLevels(iDecHWDevId);
sl@0	1021	}
sl@0	1022
sl@0	1023	PRINT((_L("CVDecTestEngine::NumComplexityLevels, [%d]"), number))
sl@0	1024
sl@0	1025	PRINT((_L("CVDecTestEngine::NumComplexityLevels, Out")))
sl@0	1026	}
sl@0	1027
sl@0	1028	/* ----------------------------------------------------------------------------
sl@0	1029	* Name: CVDecTestEngine::InputEnd()
sl@0	1030	* Purpose: Set SetHrdVbvSpec
sl@0	1031	* Note: This is called before initilaized
sl@0	1032	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1033	* Return: None
sl@0	1034	* --------------------------------------------------------------------------*/
sl@0	1035
sl@0	1036	void CVDecTestEngine::InputEnd()
sl@0	1037	{
sl@0	1038	PRINT((_L("CVDecTestEngine::InputEnd, In")))
sl@0	1039
sl@0	1040	iDevvp->InputEnd();
sl@0	1041
sl@0	1042	PRINT((_L("CVDecTestEngine::InputEnd, Out")))
sl@0	1043	}
sl@0	1044
sl@0	1045	/* ----------------------------------------------------------------------------
sl@0	1046	* Name: CVDecTestEngine::GetNewPictureInfo()
sl@0	1047	* Purpose: Set SetHrdVbvSpec
sl@0	1048	* Note: This is called before initilaized
sl@0	1049	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1050	* Return: None
sl@0	1051	* --------------------------------------------------------------------------*/
sl@0	1052
sl@0	1053	void CVDecTestEngine::GetNewPictureInfo(TTimeIntervalMicroSeconds& aEarliestTimestamp,
sl@0	1054	TTimeIntervalMicroSeconds& aLatestTimestamp)
sl@0	1055	{
sl@0	1056	PRINT((_L("CVDecTestEngine::GetNewPictureInfo, In")))
sl@0	1057
sl@0	1058	TUint numbers = 0;
sl@0	1059	iDevvp->GetNewPictureInfo(numbers, aEarliestTimestamp, aLatestTimestamp);
sl@0	1060	PRINT((_L("CVDecTestEngine::GetNewPictureInfo, [%d]"), numbers))
sl@0	1061
sl@0	1062	PRINT((_L("CVDecTestEngine::GetNewPictureInfo, Out")))
sl@0	1063	}
sl@0	1064
sl@0	1065
sl@0	1066	/* ----------------------------------------------------------------------------
sl@0	1067	* Name: CVDecTestEngine::GetTimedSnapshotL()
sl@0	1068	* Purpose: Set SetHrdVbvSpec
sl@0	1069	* Note: This is called before initilaized
sl@0	1070	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1071	* Return: None
sl@0	1072	* --------------------------------------------------------------------------*/
sl@0	1073
sl@0	1074	void CVDecTestEngine::GetTimedSnapshotL(const TUncompressedVideoFormat& aFormat,
sl@0	1075	const TTimeIntervalMicroSeconds& aPresentationTimestamp)
sl@0	1076	{
sl@0	1077	PRINT((_L("CVDecTestEngine::GetTimedSnapshotL, In")))
sl@0	1078
sl@0	1079	iPictureDataSnapshot.iDataFormat = aFormat.iDataFormat;
sl@0	1080	iPictureDataSnapshot.iDataSize = iPictureSize;
sl@0	1081
sl@0	1082	PrintUncompressedFormat(aFormat);
sl@0	1083
sl@0	1084	iDevvp->GetTimedSnapshotL(&iPictureDataSnapshot, aFormat, aPresentationTimestamp);
sl@0	1085
sl@0	1086	PRINT((_L("CVDecTestEngine::GetTimedSnapshotL, Out")))
sl@0	1087	}
sl@0	1088
sl@0	1089	/* ----------------------------------------------------------------------------
sl@0	1090	* Name: CVDecTestEngine::GetTimedSnapshotL()
sl@0	1091	* Purpose: Set SetHrdVbvSpec
sl@0	1092	* Note: This is called before initilaized
sl@0	1093	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1094	* Return: None
sl@0	1095	* --------------------------------------------------------------------------*/
sl@0	1096
sl@0	1097	void CVDecTestEngine::GetTimedSnapshotL(const TUncompressedVideoFormat& aFormat,
sl@0	1098	const TPictureId& aPictureId)
sl@0	1099	{
sl@0	1100	PRINT((_L("CVDecTestEngine::GetTimedSnapshotL, In")))
sl@0	1101
sl@0	1102	iPictureDataSnapshot.iDataFormat = aFormat.iDataFormat;
sl@0	1103	iPictureDataSnapshot.iDataSize = iPictureSize;
sl@0	1104
sl@0	1105	PrintUncompressedFormat(aFormat);
sl@0	1106
sl@0	1107	iDevvp->GetTimedSnapshotL(&iPictureDataSnapshot, aFormat, aPictureId);
sl@0	1108
sl@0	1109	PRINT((_L("CVDecTestEngine::GetTimedSnapshotL, Out")))
sl@0	1110	}
sl@0	1111
sl@0	1112	/* ----------------------------------------------------------------------------
sl@0	1113	* Name: CVDecTestEngine::CancelTimedSnapshot()
sl@0	1114	* Purpose: Set SetHrdVbvSpec
sl@0	1115	* Note: This is called before initilaized
sl@0	1116	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1117	* Return: None
sl@0	1118	* --------------------------------------------------------------------------*/
sl@0	1119
sl@0	1120	void CVDecTestEngine::CancelTimedSnapshot()
sl@0	1121	{
sl@0	1122	PRINT((_L("CVDecTestEngine::CancelTimedSnapshot, In")))
sl@0	1123
sl@0	1124	iDevvp->CancelTimedSnapshot();
sl@0	1125
sl@0	1126	PRINT((_L("CVDecTestEngine::CancelTimedSnapshot, Out")))
sl@0	1127	}
sl@0	1128
sl@0	1129	/* ----------------------------------------------------------------------------
sl@0	1130	* Name: CVDecTestEngine::GetSupportedSnapshotFormatsL()
sl@0	1131	* Purpose: Set SetHrdVbvSpec
sl@0	1132	* Note: This is called before initilaized
sl@0	1133	* Parameters: THrdVbvSpecification aHrdVbvSpec
sl@0	1134	* Return: None
sl@0	1135	* --------------------------------------------------------------------------*/
sl@0	1136
sl@0	1137	void CVDecTestEngine::GetSupportedSnapshotFormatsL()
sl@0	1138	{
sl@0	1139	PRINT((_L("CVDecTestEngine::GetSupportedSnapshotFormatsL, In")))
sl@0	1140
sl@0	1141	RArray<TUncompressedVideoFormat> formats;
sl@0	1142	CleanupClosePushL(formats);
sl@0	1143
sl@0	1144	iDevvp->GetSupportedSnapshotFormatsL(formats);
sl@0	1145
sl@0	1146	for (TUint i = 0; i < formats.Count(); i++)
sl@0	1147	{
sl@0	1148	PRINT((_L("CVDecTestEngine::GetSupportedSnapshotFormatsL, Format No.%d"), i))
sl@0	1149	PrintUncompressedFormat(formats[i]);
sl@0	1150	}
sl@0	1151	CleanupStack::PopAndDestroy(&formats);
sl@0	1152
sl@0	1153	PRINT((_L("CVDecTestEngine::GetSupportedSnapshotFormatsL, Out")))
sl@0	1154	}
sl@0	1155
sl@0	1156
sl@0	1157	/* ----------------------------------------------------------------------------
sl@0	1158	* Name: CVDecTestEngine::SetComplexityLevel()
sl@0	1159	* Purpose: Set Complexity Level of Decode and postprocessor
sl@0	1160	* Note: This is called after initilaized
sl@0	1161	* Parameters: TInt aDecLevel, TInt aPostProcLevel
sl@0	1162	* Return: None
sl@0	1163	* --------------------------------------------------------------------------*/
sl@0	1164
sl@0	1165	void CVDecTestEngine::SetComplexityLevel(TInt aHWDevice, TInt aLevel)
sl@0	1166	{
sl@0	1167	PRINT((_L("CVDecTestEngine::SetComplexityLevel, In")))
sl@0	1168
sl@0	1169	if (aHWDevice == EPostProcessor)
sl@0	1170	{
sl@0	1171	iDevvp->SetComplexityLevel(iPostProcId, aLevel);
sl@0	1172	}
sl@0	1173	else
sl@0	1174	{
sl@0	1175	iDevvp->SetComplexityLevel(iDecHWDevId, aLevel);
sl@0	1176	}
sl@0	1177
sl@0	1178	PRINT((_L("CVDecTestEngine::SetComplexityLevel, Out")))
sl@0	1179	}
sl@0	1180
sl@0	1181
sl@0	1182
sl@0	1183	/* ----------------------------------------------------------------------------
sl@0	1184	* Name: CVDecTestEngine::GetComplexityLevelInfo()
sl@0	1185	* Purpose: Get number and information of Complexity Level of Decode and postprocessor
sl@0	1186	* Note: This is called after initilaized
sl@0	1187	* Parameters: None
sl@0	1188	* Return: None
sl@0	1189	* --------------------------------------------------------------------------*/
sl@0	1190
sl@0	1191	void CVDecTestEngine::GetComplexityLevelInfo(TInt aHWDevice, TInt aLevel)
sl@0	1192	{
sl@0	1193	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, In")))
sl@0	1194
sl@0	1195	CMMFDevVideoPlay::TComplexityLevelInfo info;
sl@0	1196
sl@0	1197	if (aHWDevice == EPostProcessor)
sl@0	1198	{
sl@0	1199	iDevvp->GetComplexityLevelInfo(iPostProcId, aLevel, info);
sl@0	1200	}
sl@0	1201	else
sl@0	1202	{
sl@0	1203	iDevvp->GetComplexityLevelInfo(iDecHWDevId, aLevel, info);
sl@0	1204	}
sl@0	1205
sl@0	1206	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, dec complexy level info[%x]"),info.iOptions))
sl@0	1207	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, iAvgPictureRate [%f]"),info.iAvgPictureRate))
sl@0	1208	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, iPictureSize width [%d] height[%d]"),info.iPictureSize.iWidth, info.iPictureSize.iHeight))
sl@0	1209	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, iRelativeImageQuality [%f]"),info.iRelativeImageQuality))
sl@0	1210	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, iRequiredMIPS [%d]"),info.iRequiredMIPS))
sl@0	1211	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, iRelativeProcessTime [%f]"),info.iRelativeProcessTime))
sl@0	1212
sl@0	1213	PRINT((_L("CVDecTestEngine::GetComplexityLevelInfo, Out")))
sl@0	1214	}
sl@0	1215
sl@0	1216
sl@0	1217	/* ----------------------------------------------------------------------------
sl@0	1218	* Name: CVDecTestEngine::Redraw()
sl@0	1219	* Purpose: Redraw latest picture
sl@0	1220	* Note: only applicable when DSA is used and after initilaized
sl@0	1221	* Parameters: None
sl@0	1222	* Return: None
sl@0	1223	* --------------------------------------------------------------------------*/
sl@0	1224
sl@0	1225	void CVDecTestEngine::Redraw()
sl@0	1226	{
sl@0	1227	PRINT((_L("CVDecTestEngine::Redraw, In")))
sl@0	1228
sl@0	1229	iDevvp->Redraw();
sl@0	1230
sl@0	1231	PRINT((_L("CVDecTestEngine::Redraw, Out")))
sl@0	1232	}
sl@0	1233
sl@0	1234
sl@0	1235
sl@0	1236	/* ----------------------------------------------------------------------------
sl@0	1237	* Name: CVDecTestEngine::GetSnapshotL()
sl@0	1238	* Purpose:
sl@0	1239	* Note:
sl@0	1240	* Parameters: None
sl@0	1241	* Return: None
sl@0	1242	* --------------------------------------------------------------------------*/
sl@0	1243
sl@0	1244	void CVDecTestEngine::GetSnapshotL(TUncompressedVideoFormat& aFormat)
sl@0	1245	{
sl@0	1246	PRINT((_L("CVDecTestEngine::GetSnapshotL, In")))
sl@0	1247
sl@0	1248	TInt result;
sl@0	1249	TInt err = KErrNone;
sl@0	1250
sl@0	1251	TPictureData picture;
sl@0	1252
sl@0	1253	picture.iDataFormat = aFormat.iDataFormat;
sl@0	1254	picture.iDataSize = iPictureSize;
sl@0	1255
sl@0	1256	PRINT((_L("CVDecTestEngine::GetSnapshotL, before new []")))
sl@0	1257	TUint8* data = new (ELeave)TUint8[iPictureSize.iWidthiPictureSize.iHeight2];
sl@0	1258	PRINT((_L("CVDecTestEngine::GetSnapshotL, after new[]")))
sl@0	1259
sl@0	1260	TPtr8 dataPtr(data, iPictureSize.iWidthiPictureSize.iHeight2);
sl@0	1261	picture.iRawData = &dataPtr;
sl@0	1262
sl@0	1263	CleanupStack::PushL(data);
sl@0	1264	iMemAlloc++;
sl@0	1265	#ifdef __MEM_CHECK_
sl@0	1266	PRINT((_L("CVDecTestEngine::GetSnapshotL, mem alloc, data") ))
sl@0	1267	#endif
sl@0	1268	PRINT((_L("CVDecTestEngine::GetSnapshotL, before snapshot")))
sl@0	1269	result = iDevvp->GetSnapshotL(picture, aFormat);
sl@0	1270
sl@0	1271	PRINT((_L("CVDecTestEngine::GetSnapshotL, snapshot received")))
sl@0	1272	if ( !result )
sl@0	1273	{
sl@0	1274	RFile snapshot;
sl@0	1275
sl@0	1276	TFileName filename;
sl@0	1277	TBuf8<128> newFile;
sl@0	1278	newFile.Append(iInFileName);
sl@0	1279	TBuf16<128> temp2;
sl@0	1280	temp2.Copy(newFile);
sl@0	1281	PRINT((_L("CVDecTestEngine::GetSnapshotL, Opening the file [%S]"), &temp2))
sl@0	1282	newFile.Delete(newFile.Length()-4, 4);
sl@0	1283	newFile.Append(_L8("_snapshot"));
sl@0	1284	newFile.Append(_L8(".yuv"));
sl@0	1285	filename.Copy(newFile);
sl@0	1286
sl@0	1287	TBuf16<128> temp;
sl@0	1288	temp.Copy(newFile);
sl@0	1289
sl@0	1290	PRINT((_L("CVDecTestEngine::GetSnapshotL, Opening the file [%S]"), &temp))
sl@0	1291	err = snapshot.Replace(iFs, filename, EFileShareExclusive\|EFileWrite);
sl@0	1292
sl@0	1293	PRINT((_L("CVDecTestEngine::GetSnapshotL, writing the file")))
sl@0	1294
sl@0	1295	if ( err!= KErrNone )
sl@0	1296	{
sl@0	1297	PRINT((_L("CVDecTestEngine::GetSnapshotL, snapshot file open failed")))
sl@0	1298	snapshot.Close();
sl@0	1299	User::Leave(err);
sl@0	1300	}
sl@0	1301	else
sl@0	1302	{
sl@0	1303	PRINT((_L("CVDecTestEngine::GetSnapshotL, Picture size %d"),picture.iRawData->Size()));
sl@0	1304	PRINT((_L("CVDecTestEngine::GetSnapshotL, Picture length %d"),picture.iRawData->Length()));
sl@0	1305	err = snapshot.Write(*(picture.iRawData),picture.iRawData->Size());
sl@0	1306	if ( err!= KErrNone )
sl@0	1307	{
sl@0	1308	PRINT((_L("CVDecTestEngine::GetSnapshotL, snapshot file write failed [%d]"), picture.iRawData->Size()))
sl@0	1309	snapshot.Close();
sl@0	1310	User::Leave(err);
sl@0	1311	}
sl@0	1312	}
sl@0	1313	PRINT((_L("CVDecTestEngine::GetSnapshotL, Picture size %d"),picture.iRawData->Size()));
sl@0	1314	snapshot.Close();
sl@0	1315
sl@0	1316	}
sl@0	1317	else
sl@0	1318	{
sl@0	1319	PRINT((_L("CVDecTestEngine::GetSnapshotL, Error getting snapshot [%d]"), result))
sl@0	1320	}
sl@0	1321	CleanupStack::PopAndDestroy( data );
sl@0	1322	iMemDelete++;
sl@0	1323	#ifdef __MEM_CHECK_
sl@0	1324	PRINT((_L("CVDecTestEngine::GetSnapShotL, mem del, ") ))
sl@0	1325	#endif
sl@0	1326	PRINT((_L("CVDecTestEngine::GetSnapshotL, Out")))
sl@0	1327	}
sl@0	1328
sl@0	1329
sl@0	1330
sl@0	1331	/* ----------------------------------------------------------------------------
sl@0	1332	* Name: CVDecTestEngine::OpenFileL()
sl@0	1333	* Purpose: Open input File
sl@0	1334	* Note: DSA is used, output is display
sl@0	1335	* Parameters: TFileName& aInFileName
sl@0	1336	* Return: None
sl@0	1337	* --------------------------------------------------------------------------*/
sl@0	1338
sl@0	1339	void CVDecTestEngine::OpenFileL(TFileName& aInFileName)
sl@0	1340	{
sl@0	1341	PRINT((_L("CVDecTestEngine::OpenFileL, In")))
sl@0	1342	TInt err;
sl@0	1343	iInFileName.Copy(aInFileName);
sl@0	1344
sl@0	1345	if ( (err = iInFile.Open(iFs, aInFileName, EFileRead \| EFileShareReadersOnly)) != KErrNone)
sl@0	1346	{
sl@0	1347	PRINT((_L("CVDecTestEngine::OpenFiles, Input File open Failed")));
sl@0	1348	User::Leave(err);
sl@0	1349	}
sl@0	1350	PRINT((_L("CVDecTestEngine::OpenFileL, Out")))
sl@0	1351	}
sl@0	1352
sl@0	1353
sl@0	1354	/* ----------------------------------------------------------------------------
sl@0	1355	* Name: CVDecTestEngine::OpenFileL()
sl@0	1356	* Purpose: Open input and output File
sl@0	1357	* Note: Memory buffer output is used
sl@0	1358	* Parameters: TFileName& aOutFileName, TFileName& aInFileName
sl@0	1359	* Return: None
sl@0	1360	* --------------------------------------------------------------------------*/
sl@0	1361
sl@0	1362
sl@0	1363	void CVDecTestEngine::OpenFileL(TFileName& aOutFileName, TFileName& aInFileName)
sl@0	1364	{
sl@0	1365	PRINT((_L("CVDecTestEngine::OpenFileL, In")))
sl@0	1366	TInt err = KErrNone;
sl@0	1367
sl@0	1368	iInFileName.Copy(aInFileName);
sl@0	1369	iOutFileName.Copy(aOutFileName);
sl@0	1370	err = iInFile.Open(iFs, aInFileName, EFileRead \| EFileShareReadersOnly);
sl@0	1371
sl@0	1372	if ( err != KErrNone)
sl@0	1373	{
sl@0	1374	PRINT((_L("CVDecTestEngine::OpenFiles, Input File open Failed")));
sl@0	1375	}
sl@0	1376
sl@0	1377	else
sl@0	1378	{
sl@0	1379	iOutFileOpen = ETrue;
sl@0	1380	err = iOutFile.Replace(iFs, aOutFileName, EFileShareExclusive\|EFileWrite);
sl@0	1381
sl@0	1382	if ( err!= KErrNone )
sl@0	1383	{
sl@0	1384	PRINT((_L("CVDecTestEngine::OpenFiles, Output File Replace Failed")));
sl@0	1385	iInFile.Close();
sl@0	1386	}
sl@0	1387	}
sl@0	1388
sl@0	1389
sl@0	1390	AssertTIntEqualL(KErrNone,err);
sl@0	1391	PRINT((_L("CVDecTestEngine::OpenFileL, Out")))
sl@0	1392	}
sl@0	1393
sl@0	1394
sl@0	1395
sl@0	1396	/* ----------------------------------------------------------------------------
sl@0	1397	* Name: CVDecTestEngine::CloseFile()
sl@0	1398	* Purpose: Close File
sl@0	1399	* Note:
sl@0	1400	* Parameters:
sl@0	1401	* Return: None
sl@0	1402	* --------------------------------------------------------------------------*/
sl@0	1403
sl@0	1404
sl@0	1405	void CVDecTestEngine::CloseFile()
sl@0	1406	{
sl@0	1407
sl@0	1408	iInFile.Close();
sl@0	1409	if ( iOutFileOpen )
sl@0	1410	{
sl@0	1411	iOutFile.Close();
sl@0	1412
sl@0	1413	PRINT((_L("CVDecTestEngine::CloseFile, Output file closed")))
sl@0	1414	}
sl@0	1415
sl@0	1416	PRINT((_L("CVDecTestEngine::CloseFile, File Closed")))
sl@0	1417
sl@0	1418	if( iCorruptMarker )
sl@0	1419	{
sl@0	1420	iFs.Delete( iOutFileName );
sl@0	1421	}
sl@0	1422
sl@0	1423	}
sl@0	1424
sl@0	1425
sl@0	1426
sl@0	1427	/* ----------------------------------------------------------------------------
sl@0	1428	* Name: CVDecTestEngine::FrameJump()
sl@0	1429	* Purpose: Jump backward or forward a number of frames
sl@0	1430	* Note:
sl@0	1431	* Parameters: TInt aNumToJump
sl@0	1432	* Return: TInt
sl@0	1433	* --------------------------------------------------------------------------*/
sl@0	1434	TInt CVDecTestEngine::FrameJump(TInt aNumToJump )
sl@0	1435	{
sl@0	1436	PRINT((_L("CVDecTestEngine::FrameJump, In")))
sl@0	1437	TInt err = KErrNone;
sl@0	1438
sl@0	1439	if ( iState == ERunning )
sl@0	1440	{
sl@0	1441	if ( iSynchronized )
sl@0	1442	{
sl@0	1443	iClock->Suspend(); //Stop Clock source
sl@0	1444	}
sl@0	1445
sl@0	1446
sl@0	1447	iDevvp->Pause();
sl@0	1448	iState = EPaused;
sl@0	1449	PRINT((_L("CVDecTestEngine::Pause(), Paused")))
sl@0	1450
sl@0	1451
sl@0	1452	iFrameJump = aNumToJump;
sl@0	1453
sl@0	1454
sl@0	1455	if( iFrameJump < 0 )
sl@0	1456	{
sl@0	1457	TInt startFrame = iSentBuffCount + iFrameJump;
sl@0	1458	if( startFrame < 0 )
sl@0	1459	{
sl@0	1460	PRINT((_L("CVDecTestEngine::FrameJump, bad argument")))
sl@0	1461	return KErrArgument;
sl@0	1462	}
sl@0	1463	else
sl@0	1464	{
sl@0	1465	iFrameJump = startFrame;
sl@0	1466	}
sl@0	1467	}
sl@0	1468	TInt beginningPos = 0;
sl@0	1469	iInFile.Seek(ESeekStart, beginningPos);
sl@0	1470	RArray<TInt> vFramesizes;
sl@0	1471	ListFrameSizeL( vFramesizes );
sl@0	1472
sl@0	1473	if( iFrameSizeList.Count() > iFrameJump )
sl@0	1474	{
sl@0	1475	TInt startPosition = 0;
sl@0	1476	for( TInt frameCounter = 0; frameCounter < iFrameSizeList.Count();
sl@0	1477	frameCounter++ )
sl@0	1478	{
sl@0	1479	startPosition += iFrameSizeList[ frameCounter ];
sl@0	1480	}
sl@0	1481	iInFile.Seek(ESeekStart,startPosition);
sl@0	1482	}
sl@0	1483	else
sl@0	1484	{
sl@0	1485	err = KErrGeneral;
sl@0	1486	PRINT((_L("CVDecTestEngine::FrameJump, iFrameSizeList.Count value:[%ld]"),iFrameSizeList.Count()))
sl@0	1487	}
sl@0	1488
sl@0	1489	}
sl@0	1490	else
sl@0	1491	{
sl@0	1492	err = KErrGeneral;
sl@0	1493	}
sl@0	1494
sl@0	1495	PRINT((_L("CVDecTestEngine::FrameJump, iFrameJump value:[%ld]"),iFrameJump))
sl@0	1496	PRINT((_L("CVDecTestEngine::FrameJump, Out")))
sl@0	1497
sl@0	1498	return err;
sl@0	1499	}
sl@0	1500
sl@0	1501
sl@0	1502
sl@0	1503	/* ----------------------------------------------------------------------------
sl@0	1504	* Name: CVDecTestEngine::SetFrameMatch()
sl@0	1505	* Purpose: The test case fails if input and output frame number doesn't
sl@0	1506	* match
sl@0	1507	* Note:
sl@0	1508	* Parameters: TBool aMatch
sl@0	1509	* Return: None
sl@0	1510	* --------------------------------------------------------------------------*/
sl@0	1511	void CVDecTestEngine::SetFrameMatch(TBool aMatch)
sl@0	1512	{
sl@0	1513
sl@0	1514	iFrameMatch = aMatch;
sl@0	1515
sl@0	1516	PRINT((_L("CVDecTestEngine::SetFrameMatch, frame match is set")))
sl@0	1517	}
sl@0	1518
sl@0	1519
sl@0	1520	/* ----------------------------------------------------------------------------
sl@0	1521	* Name: CVDecTestEngine::Initialize()
sl@0	1522	* Purpose: Initilize Decoder/Postprocessor
sl@0	1523	* Note:
sl@0	1524	* Parameters: TBool aSynchronized
sl@0	1525	* Return: None
sl@0	1526	* --------------------------------------------------------------------------*/
sl@0	1527
sl@0	1528
sl@0	1529	TInt CVDecTestEngine::Initialize()
sl@0	1530	{
sl@0	1531	PRINT((_L("CVDecTestEngine::Initialize, In")))
sl@0	1532
sl@0	1533	iError = KErrNone;
sl@0	1534
sl@0	1535	// Do Initialization
sl@0	1536	iDevvp->Initialize();
sl@0	1537	PRINT((_L("CVDecTestEngine::Initialize, Initialize() returned")))
sl@0	1538	if ( (iState != EInitialized) && (iError == KErrNone ) )
sl@0	1539	{
sl@0	1540	iScheduler = new (ELeave) CActiveSchedulerWait;
sl@0	1541	iMemAlloc++;
sl@0	1542	#ifdef __MEM_CHECK_
sl@0	1543	PRINT((_L("CVDecTestEngine::Initialize, mem alloc, iScheduler") ))
sl@0	1544	#endif
sl@0	1545	iRunning = ETrue;
sl@0	1546	iScheduler->Start();
sl@0	1547	}
sl@0	1548	PRINT((_L("CVDecTestEngine::Initialize, out: error[%d]"),iError))
sl@0	1549	return iError;
sl@0	1550	}
sl@0	1551
sl@0	1552	/* ----------------------------------------------------------------------------
sl@0	1553	* Name: CVDecTestEngine::InitializeAndDelete()
sl@0	1554	* Purpose: Initilize Decoder/Postprocessor
sl@0	1555	* Note:
sl@0	1556	* Parameters: TBool aSynchronized
sl@0	1557	* Return: None
sl@0	1558	* --------------------------------------------------------------------------*/
sl@0	1559
sl@0	1560
sl@0	1561	TInt CVDecTestEngine::InitializeAndDelete()
sl@0	1562	{
sl@0	1563	PRINT((_L("CVDecTestEngine::InitializeAndDelete, In")))
sl@0	1564
sl@0	1565	iDeleteDecoderFromInitComp = ETrue;
sl@0	1566
sl@0	1567	TInt err = Initialize();
sl@0	1568
sl@0	1569	PRINT((_L("CVDecTestEngine::InitializeAndDelete, Out")))
sl@0	1570	return err;
sl@0	1571	}
sl@0	1572
sl@0	1573	/* ----------------------------------------------------------------------------
sl@0	1574	* Name: CVDecTestEngine::Start()
sl@0	1575	* Purpose: Start Decoding/Postprocessing
sl@0	1576	* Note:
sl@0	1577	* Parameters: None
sl@0	1578	* Return: None
sl@0	1579	* --------------------------------------------------------------------------*/
sl@0	1580
sl@0	1581
sl@0	1582	TInt CVDecTestEngine::Start(TBool aInputEnd)
sl@0	1583	{
sl@0	1584
sl@0	1585	TInt err = KErrNone;
sl@0	1586	iDisableInputEnd = aInputEnd;
sl@0	1587
sl@0	1588	PRINT((_L("CVDecTestEngine::Start, Devvideo play started")))
sl@0	1589
sl@0	1590	// Start DSA
sl@0	1591	if ( iDirectScreenAccess && !iDsaStarted )
sl@0	1592	{
sl@0	1593	TRAPD(err, StartDirectScreenAccessL());
sl@0	1594	if (err != KErrNone)
sl@0	1595	{
sl@0	1596	return err;
sl@0	1597	}
sl@0	1598
sl@0	1599	}
sl@0	1600
sl@0	1601	// Start DevVideoPlay
sl@0	1602	iDevvp->Start();
sl@0	1603	iState = ERunning;
sl@0	1604
sl@0	1605	//Reset Clock at Stream Start
sl@0	1606	if ( iSynchronized )
sl@0	1607	{
sl@0	1608	TTimeIntervalMicroSeconds offset(KStartOffset);
sl@0	1609	Int64 time = offset.Int64();
sl@0	1610	iClock->Reset(offset);
sl@0	1611	}
sl@0	1612
sl@0	1613
sl@0	1614	// Start Data transfer
sl@0	1615	iDecTestAO->RequestData();
sl@0	1616
sl@0	1617	PRINT((_L("CVDecTestEngine::Start, Start data transfer - start () out")))
sl@0	1618	return err;
sl@0	1619
sl@0	1620	}
sl@0	1621
sl@0	1622
sl@0	1623
sl@0	1624	/* ----------------------------------------------------------------------------
sl@0	1625	* Name: CVDecTestEngine::Stop()
sl@0	1626	* Purpose: Stop Decoding/Postprocessing
sl@0	1627	* Note:
sl@0	1628	* Parameters: None
sl@0	1629	* Return: None
sl@0	1630	* --------------------------------------------------------------------------*/
sl@0	1631
sl@0	1632
sl@0	1633	TInt CVDecTestEngine::Stop()
sl@0	1634	{
sl@0	1635
sl@0	1636	PRINT((_L("CVDecTestEngine::Stop, In ")))
sl@0	1637
sl@0	1638	if ( (iState == ERunning ) \|\| (iState == EPaused) )
sl@0	1639	{
sl@0	1640	//Stop Devvideoplay
sl@0	1641	iDevvp->Stop();
sl@0	1642	iState = EStopped;
sl@0	1643	PRINT((_L("CVDecTestEngine::Stop, Stopped ")))
sl@0	1644	}
sl@0	1645
sl@0	1646	//Stop DSA
sl@0	1647	if ( iDirectScreenAccess && iDsaStarted )
sl@0	1648	{
sl@0	1649	iDevvp->AbortDirectScreenAccess();
sl@0	1650	iDsaStarted = EFalse;
sl@0	1651	PRINT((_L("CVDecTestEngine::Stop, DSA is aborted ")))
sl@0	1652
sl@0	1653	PRINT((_L("CVDecTestEngine::VDecTestStartL, the number of Pictures sent: [%d]"),iSentBuffCount))
sl@0	1654
sl@0	1655	}
sl@0	1656	else if ( iInputEnd )
sl@0	1657	{
sl@0	1658	if ( iSentBuffCount != (iReturnedBuffCount + iPictureLoss) )
sl@0	1659	{
sl@0	1660	if( iFrameMatch )
sl@0	1661	{
sl@0	1662	PRINT((_L("CVDecTestEngine::VDecTestStopL, the number of Pictures sent and returned does not match: ")))
sl@0	1663	return KErrGeneral;
sl@0	1664	}
sl@0	1665	PRINT((_L("CVDecTestEngine::VDecTestStopL, the number of Pictures sent and returned does not match: ")))
sl@0	1666	PRINT((_L("The number of pictures, sent : [%d], returned:[%d] "),iSentBuffCount, iReturnedBuffCount ))
sl@0	1667	}
sl@0	1668	}
sl@0	1669
sl@0	1670	PRINT((_L("CVDecTestEngine::Stop, Out")))
sl@0	1671	return iError;
sl@0	1672	}
sl@0	1673
sl@0	1674
sl@0	1675
sl@0	1676	/* ----------------------------------------------------------------------------
sl@0	1677	* Name: CVDecTestEngine::TearDown()
sl@0	1678	* Purpose: Cleanup resources
sl@0	1679	* Note:
sl@0	1680	* Parameters: None
sl@0	1681	* Return: None
sl@0	1682	* --------------------------------------------------------------------------*/
sl@0	1683
sl@0	1684
sl@0	1685	void CVDecTestEngine::TearDown()
sl@0	1686	{
sl@0	1687	PRINT((_L("CVDecTestEngine::TearDown(),In")))
sl@0	1688
sl@0	1689	if( iInstantFpsEnabled )
sl@0	1690	{
sl@0	1691	iFpsFile.Close();
sl@0	1692	PRINT((_L("CVDecTestEngine::CloseFile, FPS Output file closed")))
sl@0	1693	}
sl@0	1694
sl@0	1695	if ( iDsaStarted )
sl@0	1696	{
sl@0	1697	iDevvp->AbortDirectScreenAccess();
sl@0	1698	PRINT((_L("CVDecTestEngine::TearDown(), Dsa aborted")))
sl@0	1699	}
sl@0	1700
sl@0	1701	// Delete Devvideo play
sl@0	1702	if ( iDevvp )
sl@0	1703	{
sl@0	1704	delete iDevvp;
sl@0	1705	iMemDelete++;
sl@0	1706	#ifdef __MEM_CHECK_
sl@0	1707	PRINT((_L("CVDecTestEngine::TearDown, mem del, iDevvp") ))
sl@0	1708	#endif
sl@0	1709	iDevvp = NULL;
sl@0	1710	iState = EStateNone;
sl@0	1711	PRINT((_L("CVDecTestEngine::TearDown(),DevVideo deleted")))
sl@0	1712	}
sl@0	1713
sl@0	1714
sl@0	1715	//Postproc input buffer
sl@0	1716	if ( !iCIBuffMgmtOn && iRawInBuffer)
sl@0	1717	{
sl@0	1718	delete (TUint8*)iRawInBuffer->iData.iRawData->Ptr();
sl@0	1719	delete iRawInBuffer->iData.iRawData;
sl@0	1720	delete iRawInBuffer;
sl@0	1721	iMemDelete += 3;
sl@0	1722	#ifdef __MEM_CHECK_
sl@0	1723	PRINT((_L("CVDecTestEngine::TearDown, mem del, iRawInBuffer & its 2 pointers") ))
sl@0	1724	#endif
sl@0	1725	iRawInBuffer = NULL;
sl@0	1726	}
sl@0	1727
sl@0	1728	if ( iScreenDevice )
sl@0	1729	{
sl@0	1730	delete iScreenDevice;
sl@0	1731	iScreenDevice = NULL;
sl@0	1732	iMemDelete++;
sl@0	1733	#ifdef __MEM_CHECK_
sl@0	1734	PRINT((_L("CVDecTestEngine::TearDown, mem del, iScreenDevice") ))
sl@0	1735	#endif
sl@0	1736	RFbsSession::Disconnect();
sl@0	1737	}
sl@0	1738
sl@0	1739	delete iDataChunk;
sl@0	1740	iMemDelete++;
sl@0	1741	#ifdef __MEM_CHECK_
sl@0	1742	PRINT((_L("CVDecTestEngine::TearDown, mem del, iDataChunk") ))
sl@0	1743	#endif
sl@0	1744
sl@0	1745	iDataChunk = NULL;
sl@0	1746
sl@0	1747	iFrameSizeList.Close();
sl@0	1748
sl@0	1749	iInstantFpsList.Close();
sl@0	1750
sl@0	1751	iFs.Close();
sl@0	1752
sl@0	1753	REComSession::FinalClose();
sl@0	1754	PRINT( (_L("CVDecTestEngine::TearDown(), mem allocated: %d "), iMemAlloc))
sl@0	1755	PRINT( (_L("CVDecTestEngine::TearDown(), mem deleted: %d "), iMemDelete))
sl@0	1756	PRINT((_L("CVDecTestEngine::TearDown(),Out")))
sl@0	1757	}
sl@0	1758
sl@0	1759
sl@0	1760
sl@0	1761	/* ----------------------------------------------------------------------------
sl@0	1762	* Name: CVDecTestEngine::FillAndSendBufferL()
sl@0	1763	* Purpose: Fill data into input buffer and send to devvideoplay
sl@0	1764	* Note:
sl@0	1765	* Parameters: None
sl@0	1766	* Return: None
sl@0	1767	* --------------------------------------------------------------------------*/
sl@0	1768
sl@0	1769
sl@0	1770	void CVDecTestEngine::FillAndSendBufferL()
sl@0	1771	{
sl@0	1772	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), In")))
sl@0	1773	TInt err = KErrNone;
sl@0	1774
sl@0	1775	if ( iInputEnd)
sl@0	1776	{
sl@0	1777	iLastFrame = EFalse;
sl@0	1778	//iCodedInBuffer->iOptions = TVideoInputBuffer::EDecodingTimestamp;
sl@0	1779	//iCodedInBuffer->iDecodingTimestamp = iSentBuffCount+2;
sl@0	1780	//ReadOneCodedPicture(iCodedInBuffer, 0); // Read compressed data of one picture from file
sl@0	1781	//iDevvp->WriteCodedDataL(iCodedInBuffer); // Input Data Sent to Decoder
sl@0	1782	if (!iDisableInputEnd)
sl@0	1783	{
sl@0	1784	iDevvp->InputEnd();
sl@0	1785	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Input End")))
sl@0	1786	}
sl@0	1787	else
sl@0	1788	{
sl@0	1789	MdvpoStreamEnd();
sl@0	1790	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Stream end")))
sl@0	1791	}
sl@0	1792	return;
sl@0	1793	}
sl@0	1794
sl@0	1795	if ( iDecHWDevId )
sl@0	1796	{
sl@0	1797	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), iDecHWDevID found")))
sl@0	1798	if ( iFrameSizeList.Count() > 0 )
sl@0	1799	{
sl@0	1800	if (iFrameSizeList.Count() <= iSentBuffCount+1)
sl@0	1801	{
sl@0	1802	iInputEnd = ETrue;
sl@0	1803	}
sl@0	1804	TInt size = iFrameSizeList[iSentBuffCount];
sl@0	1805	err = ReadOneCodedPicture(iCodedInBuffer, size); // Read compressed data of one picture from file
sl@0	1806
sl@0	1807	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), 1 picture read")))
sl@0	1808
sl@0	1809	if( iFrameDropMarker )
sl@0	1810	{
sl@0	1811	if( iFrameDropCounter >= iFrameDropInterval )
sl@0	1812	{
sl@0	1813	TInt dropNum = 0;
sl@0	1814	for( ; ;)
sl@0	1815	{
sl@0	1816	TInt size = iFrameSizeList[iSentBuffCount++];
sl@0	1817	err = ReadOneCodedPicture(iCodedInBuffer, size); // Read compressed data of one picture from file
sl@0	1818	dropNum++;
sl@0	1819	iFrameDropNumCounter++;
sl@0	1820	if( iFrameDropNumCounter >= iFrameDropNum )
sl@0	1821	{
sl@0	1822	iFrameDropCounter = 0;
sl@0	1823	iFrameDropNumCounter = 0;
sl@0	1824	break;
sl@0	1825	}
sl@0	1826	}
sl@0	1827	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), [%d] frame(s) dropped"), dropNum))
sl@0	1828	}
sl@0	1829	}
sl@0	1830
sl@0	1831
sl@0	1832	}
sl@0	1833	else
sl@0	1834	{
sl@0	1835	err = ReadOneCodedPicture(iCodedInBuffer); // Read compressed data of one picture from file
sl@0	1836	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), one picture read, err: [%d]"), err))
sl@0	1837
sl@0	1838	if( iFrameDropMarker )
sl@0	1839	{
sl@0	1840	if( iFrameDropCounter >= iFrameDropInterval )
sl@0	1841	{
sl@0	1842	TInt dropNum = 0;
sl@0	1843	for( ; ;)
sl@0	1844	{
sl@0	1845	err = ReadOneCodedPicture(iCodedInBuffer);
sl@0	1846	dropNum++;
sl@0	1847	iFrameDropNumCounter++;
sl@0	1848	if( iFrameDropNumCounter >= iFrameDropNum )
sl@0	1849	{
sl@0	1850	iFrameDropCounter = 0;
sl@0	1851	iFrameDropNumCounter = 0;
sl@0	1852	break;
sl@0	1853	}
sl@0	1854	}
sl@0	1855	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), [%d] frame(s) dropped"), dropNum))
sl@0	1856	}
sl@0	1857	}
sl@0	1858
sl@0	1859
sl@0	1860	}
sl@0	1861	}
sl@0	1862	else // Postproc input case
sl@0	1863	{
sl@0	1864	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), iDecHWDevID not found")))
sl@0	1865	err = ReadRawPicture(); // Read raw data for one picture
sl@0	1866	if( iFrameDropMarker )
sl@0	1867	{
sl@0	1868	if( iFrameDropCounter >= iFrameDropInterval )
sl@0	1869	{
sl@0	1870	TInt dropNum = 0;
sl@0	1871	for( ; ;)
sl@0	1872	{
sl@0	1873	err = ReadRawPicture(); // Read raw data for one picture
sl@0	1874	dropNum++;
sl@0	1875	iFrameDropNumCounter++;
sl@0	1876	if( iFrameDropNumCounter >= iFrameDropNum )
sl@0	1877	{
sl@0	1878	iFrameDropCounter = 0;
sl@0	1879	iFrameDropNumCounter = 0;
sl@0	1880	break;
sl@0	1881	}
sl@0	1882	}
sl@0	1883	PRINT((_L("CVDecTestEngine::FillAndSendBufferL(), [%d] raw picture(s) dropped"), dropNum))
sl@0	1884	}
sl@0	1885	}
sl@0	1886	}
sl@0	1887	if(err == 0){
sl@0	1888	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Empty buffer read skipping")))
sl@0	1889	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Out")))
sl@0	1890	}
sl@0	1891	else if ( err > 0 )
sl@0	1892	{
sl@0	1893	// Corrupt the input if user requires
sl@0	1894	/*
sl@0	1895	if( iCorruptMarker )
sl@0	1896	{
sl@0	1897
sl@0	1898	CorruptEngineL();
sl@0	1899
sl@0	1900	}
sl@0	1901	*/
sl@0	1902	// End of the corrupting operation
sl@0	1903
sl@0	1904	if ( iDecHWDevId )
sl@0	1905	{
sl@0	1906
sl@0	1907	iCodedInBuffer->iOptions = TVideoInputBuffer::EDecodingTimestamp;
sl@0	1908
sl@0	1909	if ( iPostProcId )
sl@0	1910	{
sl@0	1911	iCodedInBuffer->iOptions \|= TVideoInputBuffer::EPresentationTimestamp;
sl@0	1912	}
sl@0	1913
sl@0	1914
sl@0	1915
sl@0	1916	if ( iSynchronized ) // Clock source is set >> real-time synchronization
sl@0	1917	{
sl@0	1918	iCodedInBuffer->iDecodingTimestamp = iTimeStamp;
sl@0	1919	if ( iPostProcId )
sl@0	1920	{
sl@0	1921	iCodedInBuffer->iPresentationTimestamp = iTimeStamp;
sl@0	1922	}
sl@0	1923
sl@0	1924
sl@0	1925	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, iTimestamp added:[%ld]"),iTimeStamp))
sl@0	1926	iTimeStamp += iFrameTimeInterval;
sl@0	1927	}
sl@0	1928	else // Clock source is not set
sl@0	1929	{
sl@0	1930	iCodedInBuffer->iDecodingTimestamp = iSentBuffCount;
sl@0	1931	if ( iPostProcId )
sl@0	1932	{
sl@0	1933	iCodedInBuffer->iPresentationTimestamp = iSentBuffCount;
sl@0	1934	}
sl@0	1935
sl@0	1936	}
sl@0	1937
sl@0	1938	TInt substreamID = 0;
sl@0	1939	// iCodedInBuffer->iUser = (TAny*)(&substreamID);
sl@0	1940	if(iCodedInBuffer->iUser != NULL ){
sl@0	1941	((TInt)iCodedInBuffer->iUser) = substreamID;
sl@0	1942	}
sl@0	1943	#if 0
sl@0	1944	TUint32 msgSize = iCodedInBuffer->iData.Length();
sl@0	1945	TUint8* tmpPtr = const_cast<TUint8 *>(iCodedInBuffer->iData.Ptr());
sl@0	1946	while(msgSize > 0)
sl@0	1947	{
sl@0	1948	if(msgSize >= 16)
sl@0	1949	{
sl@0	1950	PRINT((_L("TX:%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x"),tmpPtr[0],tmpPtr[1],tmpPtr[2],tmpPtr[3],tmpPtr[4],tmpPtr[5],tmpPtr[6],tmpPtr[7],tmpPtr[8],tmpPtr[9],tmpPtr[10],tmpPtr[11],tmpPtr[12],tmpPtr[13],tmpPtr[14],tmpPtr[15]))
sl@0	1951	msgSize -= 16;
sl@0	1952	tmpPtr += 16;
sl@0	1953	}
sl@0	1954	else if(msgSize >= 4)
sl@0	1955	{
sl@0	1956	PRINT((_L("TX:%02x,%02x,%02x,%02x"),tmpPtr[0],tmpPtr[1],tmpPtr[2],tmpPtr[3]))
sl@0	1957	msgSize -= 4;
sl@0	1958	tmpPtr += 4;
sl@0	1959	}
sl@0	1960	else
sl@0	1961	{
sl@0	1962	for(TUint i = 0; i < msgSize; i++)
sl@0	1963	{
sl@0	1964	PRINT((_L("TX: 0x%02x"),*tmpPtr++))
sl@0	1965	}
sl@0	1966	msgSize = 0;
sl@0	1967	}
sl@0	1968	}
sl@0	1969	#endif
sl@0	1970
sl@0	1971	iDevvp->WriteCodedDataL(iCodedInBuffer); // Input Data Sent to Decoder
sl@0	1972	iCodedInBuffer = NULL;
sl@0	1973	}
sl@0	1974	else
sl@0	1975	{
sl@0	1976
sl@0	1977	iRawInBuffer->iData.iDataSize.SetSize(iPictureSize.iWidth,iPictureSize.iHeight);
sl@0	1978
sl@0	1979	iRawInBuffer->iOptions \|= (TVideoPicture::ETimestamp);
sl@0	1980
sl@0	1981	if ( iSynchronized )
sl@0	1982	{
sl@0	1983	//TTimeIntervalMicroSeconds tsValue(iTimeStamp);
sl@0	1984	iRawInBuffer->iTimestamp = iTimeStamp;
sl@0	1985	iTimeStamp += iFrameTimeInterval;
sl@0	1986	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, iTimestamp added:[%ld]"),iTimeStamp))
sl@0	1987	}
sl@0	1988	else
sl@0	1989	{
sl@0	1990	iRawInBuffer->iTimestamp = iSentBuffCount;
sl@0	1991	}
sl@0	1992
sl@0	1993
sl@0	1994	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, data size: w[%d] ,h[%d]"),iRawInBuffer->iData.iDataSize.iWidth, iRawInBuffer->iData.iDataSize.iHeight))
sl@0	1995	iDevvp->WritePictureL(iRawInBuffer); // Input Data Sent to PostProcessor
sl@0	1996
sl@0	1997
sl@0	1998	if (iCIBuffMgmtOn)
sl@0	1999	{
sl@0	2000	iRawInBuffer = NULL;
sl@0	2001	}
sl@0	2002
sl@0	2003	}
sl@0	2004
sl@0	2005	iFrameDropCounter++;
sl@0	2006	iSentBuffCount++;
sl@0	2007	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Sent Frame: [%d] "),iSentBuffCount))
sl@0	2008
sl@0	2009	}
sl@0	2010	else //Error case
sl@0	2011	{
sl@0	2012	iError = err;
sl@0	2013	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Error in reading data: [%d] "),iError))
sl@0	2014	iInputEnd = ETrue;
sl@0	2015	iDevvp->InputEnd();
sl@0	2016	return;
sl@0	2017	}
sl@0	2018
sl@0	2019	// if ( iFrameMeasurement )
sl@0	2020	// return;
sl@0	2021
sl@0	2022	if (iInputEnd)
sl@0	2023	{
sl@0	2024	iLastFrame = ETrue;
sl@0	2025	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Input end: sending last frame 0 ")))
sl@0	2026	iDecTestAO->RequestData(); // Next Input Data for Decoder / PostProc
sl@0	2027	return;
sl@0	2028	}
sl@0	2029
sl@0	2030	if ( iState == ERunning )
sl@0	2031	{
sl@0	2032	if ( iDecHWDevId )
sl@0	2033	{
sl@0	2034	if (iSetFastClient)
sl@0	2035	{
sl@0	2036	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Fast client request")))
sl@0	2037	iDecTestAO->RequestData(); // Next Input Data for Decoder / PostProc
sl@0	2038	}
sl@0	2039	else
sl@0	2040	{
sl@0	2041	if ( iDevvp->NumFreeBuffers() )
sl@0	2042	{
sl@0	2043	iDecTestAO->RequestData(); // Next Input Data for Decoder / PostProc
sl@0	2044	}
sl@0	2045	else
sl@0	2046	{
sl@0	2047	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, No input buffer available now")))
sl@0	2048	iNoBuffAvailable++;
sl@0	2049	}
sl@0	2050	}
sl@0	2051	}
sl@0	2052	}
sl@0	2053
sl@0	2054
sl@0	2055	PRINT((_L("CVDecTestEngine::FillAndSendBufferL, Out")))
sl@0	2056
sl@0	2057	}
sl@0	2058
sl@0	2059
sl@0	2060	/* ----------------------------------------------------------------------------
sl@0	2061	* Name: CVDecTestEngine::GetInputBufferL()
sl@0	2062	* Purpose: Ritreave decoder input buffer
sl@0	2063	* Note:
sl@0	2064	* Parameters: None
sl@0	2065	* Return: None
sl@0	2066	* --------------------------------------------------------------------------*/
sl@0	2067
sl@0	2068
sl@0	2069	void CVDecTestEngine::GetInputBufferL()
sl@0	2070	{
sl@0	2071	TBool buffer = EFalse;
sl@0	2072
sl@0	2073	if ( iState == ERunning )
sl@0	2074	{
sl@0	2075	if ( iDecHWDevId )
sl@0	2076	{
sl@0	2077	iCodedInBuffer = iDevvp->GetBufferL(iInBuffSize);
sl@0	2078	if ( iCodedInBuffer )
sl@0	2079	{
sl@0	2080	buffer = ETrue;
sl@0	2081	}
sl@0	2082
sl@0	2083	}
sl@0	2084	else if ( iCIBuffMgmtOn )
sl@0	2085	{
sl@0	2086	PRINT((_L("CVDecTestEngine::GetInputBufferL(), Getting Input buffer(CI)...")))
sl@0	2087	#ifdef __CI_HEADERS__
sl@0	2088	TVideoPicture* inputBuff = iCIBuffMgmt->MmvbmGetBufferL(iPictureSize);
sl@0	2089	if ( inputBuff )
sl@0	2090	{
sl@0	2091	buffer = ETrue;
sl@0	2092	iRawInBuffer = inputBuff;
sl@0	2093	}
sl@0	2094	#endif
sl@0	2095	}
sl@0	2096	}
sl@0	2097
sl@0	2098	if ( buffer )
sl@0	2099	{
sl@0	2100	PRINT((_L("CVDecTestEngine::GetInputBufferL(), Got Input buffer")))
sl@0	2101	FillAndSendBufferL();
sl@0	2102	}
sl@0	2103	else
sl@0	2104	{
sl@0	2105	PRINT((_L("CVDecTestEngine::GetInputBufferL(), Couldn't get input buffer ")))
sl@0	2106	}
sl@0	2107
sl@0	2108	}
sl@0	2109
sl@0	2110
sl@0	2111
sl@0	2112	/* ----------------------------------------------------------------------------
sl@0	2113	* Name: CVDecTestEngine::ReadOneCodedPicture()
sl@0	2114	* Purpose: Read one coded picture into decoder input buffer
sl@0	2115	* Note:
sl@0	2116	* Parameters: TVideoInputBuffer* aCodedInBuffer
sl@0	2117	* Return: TInt
sl@0	2118	* --------------------------------------------------------------------------*/
sl@0	2119	TInt CVDecTestEngine::ReadOneCodedPicture(TVideoInputBuffer* aCodedInBuffer)
sl@0	2120	{
sl@0	2121	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, In")))
sl@0	2122	TInt buffLength = iInBuffSize;
sl@0	2123	TBool found = EFalse;
sl@0	2124	TInt pos =0;
sl@0	2125	TUint8* testData =NULL;
sl@0	2126	TInt err = KErrNone;
sl@0	2127
sl@0	2128	//Reads VC1 frame
sl@0	2129	if ( iCodecType == EVC1 )
sl@0	2130	{
sl@0	2131	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, VC1")))
sl@0	2132	return LoadNextFrameL(aCodedInBuffer);
sl@0	2133	}
sl@0	2134
sl@0	2135	if ( aCodedInBuffer->iData.MaxLength() < buffLength )
sl@0	2136	{
sl@0	2137	err = KErrOverflow;
sl@0	2138	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Buffer is small, [%d]Byte"),aCodedInBuffer->iData.MaxLength()))
sl@0	2139
sl@0	2140	return err;
sl@0	2141	}
sl@0	2142
sl@0	2143	aCodedInBuffer->iData.SetLength(0);
sl@0	2144
sl@0	2145	//Buffer is not full, reset size of buffer
sl@0	2146	if ( aCodedInBuffer->iData.Length() < buffLength)
sl@0	2147	{
sl@0	2148	buffLength = aCodedInBuffer->iData.Length();
sl@0	2149	}
sl@0	2150
sl@0	2151	testData = const_cast<TUint8*>(aCodedInBuffer->iData.Ptr());
sl@0	2152
sl@0	2153	TUint8* iReadDataChunkTemp = iReadDataChunk;
sl@0	2154
sl@0	2155	TUint8 byte = 0;
sl@0	2156
sl@0	2157	//Check the length of one coded picture
sl@0	2158	if (iCodecType == EH263)
sl@0	2159	{
sl@0	2160	TBool firstStartCode = EFalse;
sl@0	2161	while (!iInputEnd && !found)
sl@0	2162	{
sl@0	2163	TInt zeroCounter = 0;
sl@0	2164	while ((byte = ReadByteFromFile()) == 0x00 && !iInputEnd)
sl@0	2165	{
sl@0	2166	zeroCounter++;
sl@0	2167	pos++;
sl@0	2168	}
sl@0	2169	pos++;
sl@0	2170	if ((zeroCounter >= 2) && ((byte & 0xFC) == 0x80))
sl@0	2171	{
sl@0	2172	if (!firstStartCode)
sl@0	2173	{
sl@0	2174	firstStartCode = ETrue;
sl@0	2175	}
sl@0	2176	else
sl@0	2177	{
sl@0	2178	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, end of h263 picture found")))
sl@0	2179	found = ETrue;
sl@0	2180	}
sl@0	2181	}
sl@0	2182	}
sl@0	2183	if (iInputEnd)
sl@0	2184	{
sl@0	2185	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, inputEndFound, %d"), pos))
sl@0	2186	pos--;
sl@0	2187	}
sl@0	2188	else
sl@0	2189	{
sl@0	2190	pos -= KScLength;
sl@0	2191	}
sl@0	2192	iReadDataChunk = iReadDataChunkTemp;
sl@0	2193	ReadDataToBuffer(aCodedInBuffer, pos);
sl@0	2194
sl@0	2195	}
sl@0	2196	else if ( iCodecType == EMPEG4 )
sl@0	2197	{
sl@0	2198	TBool firstStartCode = EFalse;
sl@0	2199	while (!iInputEnd && !found)
sl@0	2200	{
sl@0	2201	TInt zeroCounter = 0;
sl@0	2202	while ((byte = ReadByteFromFile()) == 0x00 && !iInputEnd)
sl@0	2203	{
sl@0	2204	zeroCounter++;
sl@0	2205	pos++;
sl@0	2206	}
sl@0	2207	pos++;
sl@0	2208	if ((zeroCounter >= 2) && (byte == 0x01))
sl@0	2209	{
sl@0	2210	byte = ReadByteFromFile();
sl@0	2211
sl@0	2212	pos++;
sl@0	2213	if (byte == 0xB6 && !firstStartCode)
sl@0	2214	{
sl@0	2215	firstStartCode = ETrue;
sl@0	2216	}
sl@0	2217	else if (byte != 0xB1 && firstStartCode)
sl@0	2218	{
sl@0	2219	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, end of mpeg-4 picture found [%d]"), pos-4))
sl@0	2220	found = ETrue;
sl@0	2221	}
sl@0	2222	}
sl@0	2223	}
sl@0	2224	if (iInputEnd)
sl@0	2225	{
sl@0	2226	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, inputEndFound, %d"), pos))
sl@0	2227	pos--;
sl@0	2228	}
sl@0	2229	else
sl@0	2230	{
sl@0	2231	pos -= 4;
sl@0	2232	}
sl@0	2233	iReadDataChunk = iReadDataChunkTemp;
sl@0	2234	ReadDataToBuffer(aCodedInBuffer, pos);
sl@0	2235	}
sl@0	2236	else if ( iCodecType == EVP6 )
sl@0	2237	{
sl@0	2238	TUint dataCount = 0;
sl@0	2239	if (iSentBuffCount == 0)
sl@0	2240	{
sl@0	2241	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, First VP6 frame")))
sl@0	2242	//Read signature and version
sl@0	2243	for (TUint i=0; i<5; i++)
sl@0	2244	{
sl@0	2245	byte = ReadByteFromFile();
sl@0	2246	}
sl@0	2247	TUint32 offset = (TUint32)(ReadByteFromFile())<< 24 \| (TUint32)(ReadByteFromFile())<< 16 \|
sl@0	2248	(TUint32)(ReadByteFromFile())<< 8 \| (TUint32)(ReadByteFromFile());
sl@0	2249
sl@0	2250	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, offset %d"), offset))
sl@0	2251	//Jump data after offset
sl@0	2252	for (TUint i=0; i< offset-9; i++ )
sl@0	2253	{
sl@0	2254	byte = ReadByteFromFile();
sl@0	2255	}
sl@0	2256	dataCount += 9+offset-9;
sl@0	2257	//Read previous tag size
sl@0	2258	for (TUint i=0; i< 4; i++ )
sl@0	2259	{
sl@0	2260	byte = ReadByteFromFile();
sl@0	2261	}
sl@0	2262
sl@0	2263	}
sl@0	2264	if (!iInputEnd)
sl@0	2265	{
sl@0	2266
sl@0	2267	TUint8 tagType = ReadByteFromFile();
sl@0	2268
sl@0	2269	if (!iInputEnd)
sl@0	2270	{
sl@0	2271
sl@0	2272	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, tagType %d"), tagType))
sl@0	2273	dataCount += 5;
sl@0	2274	while (tagType != 9 && !iInputEnd)
sl@0	2275	{
sl@0	2276	TUint32 a = (TUint32)(ReadByteFromFile());
sl@0	2277	TUint32 b = (TUint32)(ReadByteFromFile());
sl@0	2278	TUint32 c = (TUint32)(ReadByteFromFile());
sl@0	2279	TUint32 dataSize = (a << 16) \| (b << 8) \| (c);
sl@0	2280	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, dataSize %d"), dataSize))
sl@0	2281	ReadDataToBuffer(aCodedInBuffer, dataSize+7, ETrue);
sl@0	2282	//Previous offset
sl@0	2283	for (TUint i=0; i< 4; i++ )
sl@0	2284	{
sl@0	2285	byte = ReadByteFromFile();
sl@0	2286	}
sl@0	2287	tagType = ReadByteFromFile();
sl@0	2288	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, tagType %d"), tagType))
sl@0	2289	dataCount += dataSize+15;
sl@0	2290	}
sl@0	2291	if(!iInputEnd){
sl@0	2292	TUint32 a = (TUint32)(ReadByteFromFile());
sl@0	2293	TUint32 b = (TUint32)(ReadByteFromFile());
sl@0	2294	TUint32 c = (TUint32)(ReadByteFromFile());
sl@0	2295	TUint32 dataSize = (a << 16) \| (b << 8) \| (c);
sl@0	2296	//Discard timestamp and streamID
sl@0	2297	for (TUint i=0; i< 7; i++ )
sl@0	2298	{
sl@0	2299	byte = ReadByteFromFile();
sl@0	2300	}
sl@0	2301	//Frametype and codec ID
sl@0	2302	byte = ReadByteFromFile();
sl@0	2303	//Read VP6 frame to buffer
sl@0	2304	ReadDataToBuffer(aCodedInBuffer, dataSize-1);
sl@0	2305	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, VP6 frame size %d"), dataSize))
sl@0	2306	dataCount += dataSize+10;
sl@0	2307	//Read previous tag size
sl@0	2308	for (TUint i=0; i< 4; i++ )
sl@0	2309	{
sl@0	2310	byte = ReadByteFromFile();
sl@0	2311	}
sl@0	2312	}
sl@0	2313	else{
sl@0	2314	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, unknown tags at the end of vp6 stream, discard")))
sl@0	2315	dataCount = 0;
sl@0	2316	}
sl@0	2317	}
sl@0	2318	}
sl@0	2319	if (iInputEnd)
sl@0	2320	{
sl@0	2321	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, inputEndFound")))
sl@0	2322	//aCodedInBuffer.iData->Zero();
sl@0	2323	}
sl@0	2324	return dataCount;
sl@0	2325	}
sl@0	2326	else if ( iCodecType == EFLV )
sl@0	2327	{
sl@0	2328	// FLV fileformat has 3 first bytes 'FLV'. Detect if file has container.
sl@0	2329	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, find out bitstream type %d == %d."),iFLVFileType,EFLVNotSet));
sl@0	2330
sl@0	2331
sl@0	2332	if(iFLVFileType == EFLVNotSet)
sl@0	2333	{
sl@0	2334	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, find out bitstream type.")));
sl@0	2335
sl@0	2336	byte = ReadByteFromFile();
sl@0	2337	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, %02x"),byte));
sl@0	2338	TUint8 byte2 = ReadByteFromFile();
sl@0	2339	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, %02x"),byte2));
sl@0	2340	TUint8 byte3 = ReadByteFromFile();
sl@0	2341	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, %02x"),byte3));
sl@0	2342	if ( (byte == 0x46) && (byte2 == 0x4C) && (byte3 == 0x56) )
sl@0	2343	{
sl@0	2344	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, file with container detected.")));
sl@0	2345	iFLVFileType = EFLVContainer;
sl@0	2346	}
sl@0	2347	else
sl@0	2348	{
sl@0	2349	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, file raw bitstream detected.")));
sl@0	2350	iFLVFileType = EFLVRaw;
sl@0	2351	}
sl@0	2352	iReadDataChunk = iReadDataChunkTemp;
sl@0	2353	}
sl@0	2354
sl@0	2355	if (iFLVFileType == EFLVContainer)
sl@0	2356	{
sl@0	2357	// FLV frames have 00 00 x2 00 00 8x startcode, parse it.
sl@0	2358	TBool firstStartCode = EFalse;
sl@0	2359	TBool frameHeaderEnd = EFalse;
sl@0	2360	TBool frameHeader = EFalse;
sl@0	2361	while (!iInputEnd && !found)
sl@0	2362	{
sl@0	2363	TInt zeroCounter = 0;
sl@0	2364	while ((byte = ReadByteFromFile()) == 0x00 && !iInputEnd)
sl@0	2365	{
sl@0	2366	zeroCounter++;
sl@0	2367	pos++;
sl@0	2368	}
sl@0	2369	pos++;
sl@0	2370	if ((zeroCounter >= 2) && ((byte & 0xF8) == 0x80) && frameHeaderEnd)
sl@0	2371	{
sl@0	2372	// FLV frames have some bytes in the beginning which needs to be removed
sl@0	2373	if (!frameHeader)
sl@0	2374	{
sl@0	2375	iReadDataChunk = iReadDataChunkTemp;
sl@0	2376	ReadDataToBuffer(aCodedInBuffer, pos-3);
sl@0	2377
sl@0	2378	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, [%d] bytes of flash video frame header removed."), (iReadDataChunk - iReadDataChunkTemp)));
sl@0	2379	iReadDataChunkTemp = iReadDataChunk;
sl@0	2380	zeroCounter = 0;
sl@0	2381	pos = 0;
sl@0	2382	frameHeader = ETrue;
sl@0	2383	}
sl@0	2384	else if (!firstStartCode)
sl@0	2385	{
sl@0	2386	firstStartCode = ETrue;
sl@0	2387	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, start of flash video picture found [%d]."), pos-3))
sl@0	2388
sl@0	2389	}
sl@0	2390	else
sl@0	2391	{
sl@0	2392	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, end of flash video picture found [%d]"), pos-3))
sl@0	2393	found = ETrue;
sl@0	2394	}
sl@0	2395	}
sl@0	2396	else if ((zeroCounter >= 2) && ((byte & 0x03) == 0x02))
sl@0	2397	{
sl@0	2398	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, found frame end code at [%d]"), pos-3))
sl@0	2399
sl@0	2400	frameHeaderEnd = ETrue;
sl@0	2401	}
sl@0	2402	else
sl@0	2403	{
sl@0	2404	frameHeaderEnd = EFalse;
sl@0	2405	}
sl@0	2406	}
sl@0	2407	if (iInputEnd)
sl@0	2408	{
sl@0	2409	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, inputEndFound, %d"), pos))
sl@0	2410	pos--;
sl@0	2411
sl@0	2412	// FLV file has four bytes which needs to be removed in the end
sl@0	2413	pos -= 4;
sl@0	2414	}
sl@0	2415	else
sl@0	2416	{
sl@0	2417	// Go back to beginning of start code (3 bytes)
sl@0	2418	pos -= 3;
sl@0	2419	// Go back to beginning of FLV file frame header(16 bytes)
sl@0	2420	pos -= 16;
sl@0	2421	}
sl@0	2422	iReadDataChunk = iReadDataChunkTemp;
sl@0	2423	ReadDataToBuffer(aCodedInBuffer, pos);
sl@0	2424	}
sl@0	2425	// Raw flash bitstream file
sl@0	2426	else
sl@0	2427	{
sl@0	2428	TBool firstStartCode = EFalse;
sl@0	2429	while (!iInputEnd && !found)
sl@0	2430	{
sl@0	2431	TInt zeroCounter = 0;
sl@0	2432	while ((byte = ReadByteFromFile()) == 0x00 && !iInputEnd)
sl@0	2433	{
sl@0	2434	zeroCounter++;
sl@0	2435	pos++;
sl@0	2436	}
sl@0	2437	pos++;
sl@0	2438	if ((zeroCounter >= 2) && ((byte & 0xF8) == 0x80))
sl@0	2439	{
sl@0	2440	if (!firstStartCode)
sl@0	2441	{
sl@0	2442	firstStartCode = ETrue;
sl@0	2443	}
sl@0	2444	else
sl@0	2445	{
sl@0	2446	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, end of flash video picture found [%d]"), pos-3))
sl@0	2447
sl@0	2448	found = ETrue;
sl@0	2449	}
sl@0	2450	}
sl@0	2451	}
sl@0	2452	if (iInputEnd)
sl@0	2453	{
sl@0	2454	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, inputEndFound, %d"), pos))
sl@0	2455	pos--;
sl@0	2456	}
sl@0	2457	else
sl@0	2458	{
sl@0	2459	pos -= 3;
sl@0	2460	}
sl@0	2461	iReadDataChunk = iReadDataChunkTemp;
sl@0	2462	ReadDataToBuffer(aCodedInBuffer, pos);
sl@0	2463	}
sl@0	2464	}
sl@0	2465	else if ( iCodecType == EAVC )
sl@0	2466	{
sl@0	2467	if (iSetAUFormat)
sl@0	2468	{
sl@0	2469	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, AU format case")))
sl@0	2470	TBool auFound = EFalse;
sl@0	2471	TBool firstMB = EFalse;
sl@0	2472	TUint32 nalUnits = 0;
sl@0	2473	TUint32 totalData = 0;
sl@0	2474	iNalOffsetArray = new TUint32[KMaxNumberOfNals];
sl@0	2475	iNalLengthArray = new TUint32[KMaxNumberOfNals];
sl@0	2476	iMemAlloc += 2;
sl@0	2477	TInt previousNal = 0;
sl@0	2478	while (!auFound)
sl@0	2479	{
sl@0	2480	TBool firstStartCode = EFalse;
sl@0	2481	// Check if start code of Visual Object Sequence
sl@0	2482	pos = 0;
sl@0	2483	TInt nalStart = 0;
sl@0	2484	while (!iInputEnd && !found && !auFound)
sl@0	2485	{
sl@0	2486	TInt zeroCounter = 0;
sl@0	2487	while ((byte = ReadByteFromFile()) == 0x00 && !iInputEnd)
sl@0	2488	{
sl@0	2489	zeroCounter++;
sl@0	2490	pos++;
sl@0	2491	}
sl@0	2492	pos++;
sl@0	2493	if ((zeroCounter >= 2) && (byte == 0x01))
sl@0	2494	{
sl@0	2495	if (!firstStartCode)
sl@0	2496	{
sl@0	2497	firstStartCode = ETrue;
sl@0	2498	nalStart = pos - KScLength;
sl@0	2499	iNalOffsetArray[nalUnits] = pos+totalData;
sl@0	2500
sl@0	2501	byte = ReadByteFromFile();
sl@0	2502	pos++;
sl@0	2503
sl@0	2504	if (((byte & 0x1F) == 7) && ( previousNal == 5 \|\| previousNal == 1 ) )
sl@0	2505	{
sl@0	2506	auFound = ETrue;
sl@0	2507	pos -= 4;
sl@0	2508	GoBackInFile(4);
sl@0	2509	}
sl@0	2510	else if (((byte & 0x1F) == 5) \|\| ((byte & 0x1F) == 1))
sl@0	2511	{
sl@0	2512	byte = ReadByteFromFile();
sl@0	2513	pos++;
sl@0	2514	if (byte >= 128)
sl@0	2515	{
sl@0	2516	if (firstMB)
sl@0	2517	{
sl@0	2518	//NAL that belongs to the next AU
sl@0	2519	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Next AU Nal Found")))
sl@0	2520	auFound = ETrue;
sl@0	2521	pos -= 5;
sl@0	2522	GoBackInFile(5);
sl@0	2523	}
sl@0	2524	else
sl@0	2525	{
sl@0	2526	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, First MB")))
sl@0	2527	firstMB = ETrue;
sl@0	2528	}
sl@0	2529	}
sl@0	2530	}
sl@0	2531	previousNal = byte & 0x1F;
sl@0	2532
sl@0	2533	}
sl@0	2534	else
sl@0	2535	{
sl@0	2536	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, NAL start: [%d]"), nalStart ))
sl@0	2537	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, end of h264 NAL found at [%d]"), pos ))
sl@0	2538
sl@0	2539	found = ETrue;
sl@0	2540	pos -= KScLength;
sl@0	2541	GoBackInFile(KScLength); //go back before next start code
sl@0	2542	}
sl@0	2543	}
sl@0	2544	}
sl@0	2545
sl@0	2546	if (!found && iInputEnd)
sl@0	2547	{
sl@0	2548	auFound = ETrue;
sl@0	2549	if ( nalUnits == 0 )
sl@0	2550	{
sl@0	2551	totalData = pos;
sl@0	2552	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture: pos: %d"),pos))
sl@0	2553	iNalLengthArray[nalUnits] = pos;
sl@0	2554	nalUnits++;
sl@0	2555	}
sl@0	2556	}
sl@0	2557	found = EFalse;
sl@0	2558	if (!auFound)
sl@0	2559	{
sl@0	2560	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Searching next NAL")))
sl@0	2561	totalData += pos;
sl@0	2562	iNalLengthArray[nalUnits] = pos - 3 - nalStart;
sl@0	2563	nalUnits++;
sl@0	2564	}
sl@0	2565	else
sl@0	2566	{
sl@0	2567	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, AU Found")))
sl@0	2568	iReadDataChunk = iReadDataChunkTemp;
sl@0	2569	ReadDataToBuffer(aCodedInBuffer, totalData);
sl@0	2570	pos = totalData; //Set amount of data read from a file
sl@0	2571	//Optional filler data to align the header at a 32-bit boundary
sl@0	2572	while ((totalData % 4) != 0)
sl@0	2573	{
sl@0	2574	testData[totalData] = 0;
sl@0	2575	totalData++;
sl@0	2576	}
sl@0	2577	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Casting headerpointer")))
sl@0	2578	TUint8* headerData = reinterpret_cast<TUint8>(const_cast<TUint8>(aCodedInBuffer->iData.Ptr()));
sl@0	2579	TUint headerStart = totalData; //changing 8bit index to 32bit
sl@0	2580	for (TUint i = 0; i < nalUnits; i++)
sl@0	2581	{
sl@0	2582	((TUint32)&headerData[headerStart]) = static_cast<TUint32>(iNalOffsetArray[i]);
sl@0	2583	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture: offset [%d] \| [%d] "), iNalOffsetArray[i], headerData[headerStart]))
sl@0	2584	((TUint32)&headerData[headerStart+4]) = static_cast<TUint32>(iNalLengthArray[i]);
sl@0	2585	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture: size [%d] \| [%d][%d][%d][%d] "), iNalLengthArray[i], headerData[headerStart+4],headerData[headerStart+5],headerData[headerStart+6],headerData[headerStart+7]))
sl@0	2586	headerStart += 8;
sl@0	2587	}
sl@0	2588	((TUint32)&headerData[headerStart]) = static_cast<TUint32>(nalUnits);
sl@0	2589	headerStart += 4;
sl@0	2590	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, deleting arrays")))
sl@0	2591	delete iNalLengthArray;
sl@0	2592	iNalLengthArray = NULL;
sl@0	2593	iMemDelete++;
sl@0	2594	delete iNalOffsetArray;
sl@0	2595	iNalOffsetArray = NULL;
sl@0	2596	iMemDelete++;
sl@0	2597	#ifdef __MEM_CHECK_
sl@0	2598	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, mem del, iNalLengthArray") ))
sl@0	2599	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, mem del, iNalOffsetArray") ))
sl@0	2600	#endif
sl@0	2601
sl@0	2602	/*for (TUint i = 0; i < 100; i++)
sl@0	2603	{
sl@0	2604	PRINT((_L("test data End [%d]"), testData[pos-100+i]))
sl@0	2605	} */
sl@0	2606
sl@0	2607	//Set Size to length of the header + one picure, and reset position to be read next time
sl@0	2608	aCodedInBuffer->iData.SetLength(headerStart);
sl@0	2609	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture,length of frame: [%d] "),pos))
sl@0	2610	//TInt tempLength = pos - buffLength;
sl@0	2611	//err = iInFile.Seek(ESeekCurrent,tempLength);
sl@0	2612	return pos;
sl@0	2613	}
sl@0	2614	}
sl@0	2615	}
sl@0	2616	else
sl@0	2617	{
sl@0	2618	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Bytestream case")))
sl@0	2619	TBool auFound = EFalse;
sl@0	2620	TBool firstMB = EFalse;
sl@0	2621	TUint32 totalData = 0;
sl@0	2622	TInt previousNal = 0;
sl@0	2623	while (!auFound)
sl@0	2624	{
sl@0	2625	// Check if start code of Visual Object Sequence
sl@0	2626	TBool firstStartCode = EFalse;
sl@0	2627	pos = 0;
sl@0	2628	TInt nalStart = 0;
sl@0	2629	while (!iInputEnd && !found)
sl@0	2630	{
sl@0	2631	TInt zeroCounter = 0;
sl@0	2632	while ((byte = ReadByteFromFile()) == 0x00 && !iInputEnd)
sl@0	2633	{
sl@0	2634	zeroCounter++;
sl@0	2635	pos++;
sl@0	2636	}
sl@0	2637	pos++;
sl@0	2638	if ((zeroCounter >= 2) && (byte == 0x01))
sl@0	2639	{
sl@0	2640	if (!firstStartCode)
sl@0	2641	{
sl@0	2642	firstStartCode = ETrue;
sl@0	2643	nalStart = pos-KScLength;
sl@0	2644	byte = ReadByteFromFile();
sl@0	2645	pos++;
sl@0	2646
sl@0	2647	if (((byte & 0x1F) == 7) && ( previousNal == 5 \|\| previousNal == 1 ) )
sl@0	2648	{
sl@0	2649	auFound = ETrue;
sl@0	2650	pos -= 4;
sl@0	2651	GoBackInFile(4);
sl@0	2652	}
sl@0	2653	else if (((byte & 0x1F) == 5) \|\| ((byte & 0x1F) == 1))
sl@0	2654	{
sl@0	2655	byte = ReadByteFromFile();
sl@0	2656	pos++;
sl@0	2657	if (byte >= 128)
sl@0	2658	{
sl@0	2659	if (firstMB)
sl@0	2660	{
sl@0	2661	//NAL that belongs to the next AU
sl@0	2662	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Next AU Nal Found")))
sl@0	2663	auFound = ETrue;
sl@0	2664	pos -= 5;
sl@0	2665	GoBackInFile(5);
sl@0	2666	}
sl@0	2667	else
sl@0	2668	{
sl@0	2669	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, First MB")))
sl@0	2670	firstMB = ETrue;
sl@0	2671	}
sl@0	2672	}
sl@0	2673	}
sl@0	2674	previousNal = byte & 0x1F;
sl@0	2675
sl@0	2676	}
sl@0	2677	else
sl@0	2678	{
sl@0	2679	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, NAL start: [%d]"), nalStart ))
sl@0	2680	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, end of h264 NAL found at [%d]"), pos ))
sl@0	2681	found = ETrue;
sl@0	2682	pos -= KScLength;
sl@0	2683	GoBackInFile(KScLength); //go back before next start code
sl@0	2684	}
sl@0	2685	}
sl@0	2686	}
sl@0	2687
sl@0	2688	if (!found && iInputEnd)
sl@0	2689	{
sl@0	2690	totalData += pos;
sl@0	2691	auFound = ETrue;
sl@0	2692	}
sl@0	2693	found = EFalse;
sl@0	2694	if (!auFound)
sl@0	2695	{
sl@0	2696	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Searching next NAL")))
sl@0	2697	totalData += pos;
sl@0	2698	}
sl@0	2699	else
sl@0	2700	{
sl@0	2701	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, AU Found")))
sl@0	2702	iReadDataChunk = iReadDataChunkTemp;
sl@0	2703	ReadDataToBuffer(aCodedInBuffer, totalData);
sl@0	2704	pos = totalData; //Set amount of data read from a file
sl@0	2705	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture,length of frame: [%d] "),pos));
sl@0	2706	return pos;
sl@0	2707	}
sl@0	2708	}
sl@0	2709
sl@0	2710	}
sl@0	2711	}
sl@0	2712	else
sl@0	2713	{
sl@0	2714	err = KErrNotSupported;
sl@0	2715	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, codec type unknown")))
sl@0	2716	}
sl@0	2717
sl@0	2718	if (err == KErrNone) // wk45 for listing frame size
sl@0	2719	err = pos;
sl@0	2720
sl@0	2721	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Out")))
sl@0	2722	return err;
sl@0	2723	}
sl@0	2724
sl@0	2725	/* ----------------------------------------------------------------------------
sl@0	2726	* Name: CVDecTestEngine::ReadOneCodedPicture()
sl@0	2727	* Purpose: Read one coded picture into decoder input buffer, frame size is known
sl@0	2728	* Note:
sl@0	2729	* Parameters: TVideoInputBuffer* aCodedInBuffer TInt Size
sl@0	2730	* Return: TInt
sl@0	2731	* --------------------------------------------------------------------------*/
sl@0	2732
sl@0	2733	TInt CVDecTestEngine::ReadOneCodedPicture(TVideoInputBuffer* aCodedInBuffer, TInt aSize)
sl@0	2734	{
sl@0	2735	TInt err = KErrNone;
sl@0	2736
sl@0	2737	err = iInFile.Read(aCodedInBuffer->iData, aSize);
sl@0	2738	PRINT((_L("CVDecTestEngine::ReadOneCodedPicture, Frame Size"),aSize ))
sl@0	2739
sl@0	2740	if (err == KErrNone)
sl@0	2741	{
sl@0	2742	err = aSize;
sl@0	2743	}
sl@0	2744
sl@0	2745	if (aSize == 0)
sl@0	2746	{
sl@0	2747	iInputEnd = ETrue;
sl@0	2748	}
sl@0	2749
sl@0	2750	return err;
sl@0	2751	}
sl@0	2752
sl@0	2753
sl@0	2754
sl@0	2755	/* ----------------------------------------------------------------------------
sl@0	2756	* Name: CVDecTestEngine::ReadRawPicture()
sl@0	2757	* Purpose: Read one raw picture into postprocessor input buffer
sl@0	2758	* Note:
sl@0	2759	* Parameters: None
sl@0	2760	* Return: None
sl@0	2761	* --------------------------------------------------------------------------*/
sl@0	2762
sl@0	2763
sl@0	2764	TInt CVDecTestEngine::ReadRawPicture()
sl@0	2765	{
sl@0	2766	TInt err = KErrNone;
sl@0	2767
sl@0	2768	PRINT((_L("CVDecTestEngine::ReadRawPicture, Maximum data length in video picture: [%d]"),iRawInBuffer->iData.iRawData->MaxLength()))
sl@0	2769	iRawInBuffer->iData.iRawData->Set((TUint8*)iRawInBuffer->iData.iRawData->Ptr(), 0, iInBuffSize);
sl@0	2770
sl@0	2771
sl@0	2772	err = iInFile.Read(*(iRawInBuffer->iData.iRawData),iInBuffSize);
sl@0	2773	PRINT((_L("CVDecTestEngine::ReadRawPicture, data length:[%d]"),iRawInBuffer->iData.iRawData->Length()))
sl@0	2774
sl@0	2775	if ( !err )
sl@0	2776	{
sl@0	2777	if ( (iRawInBuffer->iData.iRawData->Length()) == 0)
sl@0	2778	{
sl@0	2779	iInputEnd = ETrue;
sl@0	2780	}
sl@0	2781	}
sl@0	2782
sl@0	2783	PRINT((_L("CVDecTestEngine::ReadRawPicture, Out error:[%d]"),err))
sl@0	2784	return err;
sl@0	2785
sl@0	2786	}
sl@0	2787
sl@0	2788	/* ----------------------------------------------------------------------------
sl@0	2789	* Name: CVDecTestEngine::GetReturnedPictureL
sl@0	2790	* Purpose: Retrieve output picuture
sl@0	2791	* Note: Memory buffer output is used
sl@0	2792	* Parameters: None
sl@0	2793	* Return: None
sl@0	2794	* --------------------------------------------------------------------------*/
sl@0	2795
sl@0	2796
sl@0	2797	void CVDecTestEngine::GetReturnedPictureL()
sl@0	2798	{
sl@0	2799	PRINT((_L("CVDecTestEngine::GetReturnedPictureL, In")))
sl@0	2800	iOutBuffer = iDevvp->NextPictureL();
sl@0	2801
sl@0	2802	if ( iOutBuffer )
sl@0	2803	{
sl@0	2804	PRINT((_L("CVDecTestEngine::GetReturnedPictureL, data Size in Byte:[%d]"),iOutBuffer->iData.iRawData->Size() ))
sl@0	2805	iReturnedBuffCount++;
sl@0	2806	SaveAndReturnPicture();
sl@0	2807	}
sl@0	2808	PRINT((_L("CVDecTestEngine::GetReturnedPictureL, Out")))
sl@0	2809	}
sl@0	2810
sl@0	2811
sl@0	2812	/* ----------------------------------------------------------------------------
sl@0	2813	* Name: CVDecTestEngine::SaveAndReturnPicture()
sl@0	2814	* Purpose: Store output data into a file
sl@0	2815	* Note: Memory buffer output is used
sl@0	2816	* Parameters: None
sl@0	2817	* Return: None
sl@0	2818	* --------------------------------------------------------------------------*/
sl@0	2819
sl@0	2820	void CVDecTestEngine::SaveAndReturnPicture()
sl@0	2821	{
sl@0	2822	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, In")))
sl@0	2823	TInt err = KErrNone;
sl@0	2824
sl@0	2825	if (iFrameMeasurement && iReturnedBuffCount == 1)
sl@0	2826	{
sl@0	2827	iClock->Reset(); // Reset Timer
sl@0	2828	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, clock reset")))
sl@0	2829	}
sl@0	2830	else
sl@0	2831	{
sl@0	2832	if ( iFrameMeasurement )
sl@0	2833	{
sl@0	2834	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, Frame measurement is on, %d. frame"), iReturnedBuffCount))
sl@0	2835	TTimeIntervalMicroSeconds time;
sl@0	2836	time = iClock->Time();
sl@0	2837	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, time measured: [%d%d]"), I64HIGH(time.Int64()), I64LOW(time.Int64())))
sl@0	2838	iFrameTime = (TReal)time.Int64()/1000000.0;
sl@0	2839	if(iInstantFpsEnabled)
sl@0	2840	{
sl@0	2841	iInstantFpsList.Append(time);
sl@0	2842	}
sl@0	2843
sl@0	2844	}
sl@0	2845	else
sl@0	2846	{
sl@0	2847	err = iOutFile.Write(*(iOutBuffer->iData.iRawData),iOutBuffer->iData.iRawData->Size() );
sl@0	2848	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, Output data stored: count[%d]"),iReturnedBuffCount))
sl@0	2849
sl@0	2850
sl@0	2851	}
sl@0	2852	}
sl@0	2853
sl@0	2854	if (iSetSlowClient)
sl@0	2855	{
sl@0	2856	if (iOutBufferTemp)
sl@0	2857	{
sl@0	2858	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, returning previous buffer (slow client)")))
sl@0	2859
sl@0	2860	iDevvp->ReturnPicture(iOutBufferTemp);
sl@0	2861	}
sl@0	2862	iOutBufferTemp = iOutBuffer;
sl@0	2863	}
sl@0	2864	else
sl@0	2865	{
sl@0	2866	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, returning buffer")))
sl@0	2867	iDevvp->ReturnPicture(iOutBuffer);
sl@0	2868	}
sl@0	2869
sl@0	2870
sl@0	2871	iOutBuffer = NULL;
sl@0	2872
sl@0	2873	if ( err != KErrNone )
sl@0	2874	{
sl@0	2875	//iInputEnd = ETrue; Fix for MRII-7HW9R3
sl@0	2876	iError = err;
sl@0	2877	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, Error in store data: [%d]"),iError))
sl@0	2878	}
sl@0	2879
sl@0	2880	PRINT((_L("CVDecTestEngine::SaveAndReturnPicture, Out")))
sl@0	2881	}
sl@0	2882
sl@0	2883
sl@0	2884
sl@0	2885	/* ----------------------------------------------------------------------------
sl@0	2886	* Name: CVDecTestEngine::Pause()
sl@0	2887	* Purpose: Pause decoding/postprocessing
sl@0	2888	* Note:
sl@0	2889	* Parameters: None
sl@0	2890	* Return: None
sl@0	2891	* --------------------------------------------------------------------------*/
sl@0	2892
sl@0	2893
sl@0	2894	TInt CVDecTestEngine::Pause()
sl@0	2895	{
sl@0	2896	TInt err = KErrNone;
sl@0	2897
sl@0	2898	if ( iState == ERunning )
sl@0	2899	{
sl@0	2900	if ( iSynchronized )
sl@0	2901	{
sl@0	2902	iClock->Suspend(); //Stop Clock source
sl@0	2903	}
sl@0	2904	iDevvp->Pause();
sl@0	2905	iState = EPaused;
sl@0	2906	PRINT((_L("CVDecTestEngine::Pause(), Paused")))
sl@0	2907	}
sl@0	2908	else
sl@0	2909	{
sl@0	2910	err = KErrGeneral;
sl@0	2911	}
sl@0	2912	return err;
sl@0	2913	}
sl@0	2914
sl@0	2915
sl@0	2916	/* ----------------------------------------------------------------------------
sl@0	2917	* Name: CVDecTestEngine::Resume()
sl@0	2918	* Purpose: Resume decoding/postprocessing
sl@0	2919	* Note:
sl@0	2920	* Parameters: None
sl@0	2921	* Return: None
sl@0	2922	* --------------------------------------------------------------------------*/
sl@0	2923
sl@0	2924	TInt CVDecTestEngine::Resume()
sl@0	2925	{
sl@0	2926
sl@0	2927	TInt err = KErrNone;
sl@0	2928
sl@0	2929	if ( iState == EPaused )
sl@0	2930	{
sl@0	2931	if ( iSynchronized )
sl@0	2932	{
sl@0	2933	iClock->Resume(); //Restart Clock source
sl@0	2934	}
sl@0	2935	iDevvp->Resume();
sl@0	2936	iState = ERunning;
sl@0	2937	PRINT((_L("CVDecTestEngine::Resume(), Resumed")))
sl@0	2938
sl@0	2939	/*if ( iDecHWDevId )
sl@0	2940	{
sl@0	2941	if ( iDevvp->NumFreeBuffers() )
sl@0	2942	{
sl@0	2943	iDecTestAO->RequestData(); //Restart data transfer
sl@0	2944	}
sl@0	2945	else
sl@0	2946	{
sl@0	2947	PRINT((_L("CVDecTestEngine::Resume, No input buffer available now")));
sl@0	2948	}
sl@0	2949	}*/
sl@0	2950	iDecTestAO->RequestData();
sl@0	2951	}
sl@0	2952	else
sl@0	2953	{
sl@0	2954	err = KErrGeneral;
sl@0	2955	}
sl@0	2956
sl@0	2957	return err;
sl@0	2958	}
sl@0	2959
sl@0	2960
sl@0	2961	/* ----------------------------------------------------------------------------
sl@0	2962	* Name: CVDecTestEngine::FreezePicture()
sl@0	2963	* Purpose: Freeze decoding/postprocessing
sl@0	2964	* Note:
sl@0	2965	* Parameters: TTimeIntervalMicroSeconds aTimeStamp
sl@0	2966	* Return: None
sl@0	2967	* --------------------------------------------------------------------------*/
sl@0	2968
sl@0	2969	void CVDecTestEngine::FreezePicture(TTimeIntervalMicroSeconds aTimeStamp)
sl@0	2970	{
sl@0	2971	iDevvp->FreezePicture(aTimeStamp);
sl@0	2972	PRINT((_L("CVDecTestEngine::Freeze(), Freezed: timestamp[%ld]"), aTimeStamp.Int64()))
sl@0	2973	}
sl@0	2974
sl@0	2975
sl@0	2976	/* ----------------------------------------------------------------------------
sl@0	2977	* Name: CVDecTestEngine::ReleaseFreeze()
sl@0	2978	* Purpose: Release Freeze
sl@0	2979	* Note:
sl@0	2980	* Parameters: TTimeIntervalMicroSeconds aTimeStamp
sl@0	2981	* Return: None
sl@0	2982	* --------------------------------------------------------------------------*/
sl@0	2983
sl@0	2984
sl@0	2985	void CVDecTestEngine::ReleaseFreeze(TTimeIntervalMicroSeconds aTimeStamp)
sl@0	2986	{
sl@0	2987	iDevvp->ReleaseFreeze(aTimeStamp);
sl@0	2988	PRINT((_L("CVDecTestEngine::ReleaseFreeze(), Freeze released")))
sl@0	2989	}
sl@0	2990
sl@0	2991
sl@0	2992	/* ----------------------------------------------------------------------------
sl@0	2993	* Name: CVDecTestEngine::StartDirectScreenAccessL
sl@0	2994	* Purpose: Start DirectScreenAccess
sl@0	2995	* Note:
sl@0	2996	* Parameters: None
sl@0	2997	* Return: None
sl@0	2998	* --------------------------------------------------------------------------*/
sl@0	2999
sl@0	3000	void CVDecTestEngine::StartDirectScreenAccessL(TRect aVideoRect, TRect aClipRegion)
sl@0	3001	{
sl@0	3002	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL(), In")))
sl@0	3003	if (!iScreenDevice)
sl@0	3004	{
sl@0	3005	User::LeaveIfError (RFbsSession::Connect());
sl@0	3006	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL, connected to Fbs server :")))
sl@0	3007	TInt err = KErrNone;
sl@0	3008	if( iUseSecondScreen )
sl@0	3009	{
sl@0	3010	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(1, EColor16MU));
sl@0	3011	}
sl@0	3012	else
sl@0	3013	{
sl@0	3014	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(0, EColor16MU));
sl@0	3015	}
sl@0	3016	if( err == KErrNotSupported )
sl@0	3017	{
sl@0	3018	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL, EColor16MU is not supported, ")))
sl@0	3019	if( iUseSecondScreen )
sl@0	3020	{
sl@0	3021	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(1, EColor16MA));
sl@0	3022	}
sl@0	3023	else
sl@0	3024	{
sl@0	3025	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(0, EColor16MA));
sl@0	3026	}
sl@0	3027	}
sl@0	3028
sl@0	3029	if( err != KErrNone )
sl@0	3030	{
sl@0	3031	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL, couldn't initialize screen device, err[%d]"),err))
sl@0	3032	}
sl@0	3033
sl@0	3034	else
sl@0	3035	{
sl@0	3036	iMemAlloc++;
sl@0	3037	#ifdef __MEM_CHECK_
sl@0	3038	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL, mem alloc, iScreenDevice") ))
sl@0	3039	#endif
sl@0	3040	}
sl@0	3041	}
sl@0	3042
sl@0	3043	TRegionFix<1> region(aClipRegion);
sl@0	3044
sl@0	3045	//Start DSA
sl@0	3046	iDevvp->StartDirectScreenAccessL(aVideoRect, *iScreenDevice, region);
sl@0	3047	PRINT((_L("CVDecTestEngine::Start, DSA started")))
sl@0	3048	iDsaStarted = ETrue;
sl@0	3049
sl@0	3050	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL(), Out")))
sl@0	3051	}
sl@0	3052
sl@0	3053	/* ----------------------------------------------------------------------------
sl@0	3054	* Name: CVDecTestEngine::StartDirectScreenAccessL
sl@0	3055	* Purpose: Start DirectScreenAccess
sl@0	3056	* Note:
sl@0	3057	* Parameters: None
sl@0	3058	* Return: None
sl@0	3059	* --------------------------------------------------------------------------*/
sl@0	3060
sl@0	3061	void CVDecTestEngine::StartDirectScreenAccessL()
sl@0	3062	{
sl@0	3063	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL(), In")))
sl@0	3064	if (iDsaStarted)
sl@0	3065	{
sl@0	3066	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL(), DSA already started- abort first")))
sl@0	3067	AbortDirectScreenAccess();
sl@0	3068	}
sl@0	3069
sl@0	3070	if (!iScreenDevice)
sl@0	3071	{
sl@0	3072
sl@0	3073
sl@0	3074	User::LeaveIfError (RFbsSession::Connect());
sl@0	3075	PRINT((_L("CVDecTestEngine::Start, connected to Fbs server :")))
sl@0	3076
sl@0	3077
sl@0	3078	TInt err = KErrNone;
sl@0	3079	if( iUseSecondScreen )
sl@0	3080	{
sl@0	3081	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(1, EColor16MU));
sl@0	3082	}
sl@0	3083	else
sl@0	3084	{
sl@0	3085	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(0, EColor16MU));
sl@0	3086	}
sl@0	3087	//TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(0, EColor16MU));
sl@0	3088	if( err == KErrNotSupported )
sl@0	3089	{
sl@0	3090	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL, EColor16MU is not supported, ")))
sl@0	3091	if( iUseSecondScreen )
sl@0	3092	{
sl@0	3093	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(1, EColor16MA));
sl@0	3094	}
sl@0	3095	else
sl@0	3096	{
sl@0	3097	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(0, EColor16MA));
sl@0	3098	}
sl@0	3099	//TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(0, EColor16MA));
sl@0	3100	}
sl@0	3101
sl@0	3102	if ( err != KErrNone )
sl@0	3103	{
sl@0	3104	PRINT((_L("CVDecTestEngine::Start, couldn't initialize screen device, err[%d]"),err))
sl@0	3105	}
sl@0	3106	}
sl@0	3107
sl@0	3108
sl@0	3109
sl@0	3110	PRINT((_L("CVDecTestEngine::Start, disprect x[%d],y[%d] "),iDispRect.iTl.iX, iDispRect.iTl.iY))
sl@0	3111	PRINT((_L("CVDecTestEngine::Start, disprect width[%d],height[%d] "),iDispRect.Width(),iDispRect.Height()))
sl@0	3112
sl@0	3113
sl@0	3114	TRegionFix<1> region(iDispRect);
sl@0	3115
sl@0	3116	//Start DSA
sl@0	3117	iDevvp->StartDirectScreenAccessL(iDispRect, *iScreenDevice, region);
sl@0	3118	PRINT((_L("CVDecTestEngine::Start, DSA started")))
sl@0	3119	iDsaStarted = ETrue;
sl@0	3120
sl@0	3121
sl@0	3122	PRINT((_L("CVDecTestEngine::StartDirectScreenAccessL(), Out")))
sl@0	3123	}
sl@0	3124
sl@0	3125	/* ----------------------------------------------------------------------------
sl@0	3126	* Name: CVDecTestEngine::AbortDirectScreenAccess
sl@0	3127	* Purpose: AbortDirectScreenAccess
sl@0	3128	* Note:
sl@0	3129	* Parameters: None
sl@0	3130	* Return: None
sl@0	3131	* --------------------------------------------------------------------------*/
sl@0	3132
sl@0	3133	void CVDecTestEngine::AbortDirectScreenAccess()
sl@0	3134	{
sl@0	3135	if ( iDirectScreenAccess && iDsaStarted )
sl@0	3136	{
sl@0	3137	iDevvp->AbortDirectScreenAccess();
sl@0	3138	iDsaStarted = EFalse;
sl@0	3139	PRINT((_L("CVDecTestEngine::AbortDirectScreenAccess, aborted ")))
sl@0	3140	}
sl@0	3141	}
sl@0	3142
sl@0	3143	/* ----------------------------------------------------------------------------
sl@0	3144	* Name: CVDecTestEngine::SetSecureOutputL
sl@0	3145	* Purpose: Set sucure output enable
sl@0	3146	* Note:
sl@0	3147	* Parameters: TBool aSecure
sl@0	3148	* Return: None
sl@0	3149	* --------------------------------------------------------------------------*/
sl@0	3150
sl@0	3151
sl@0	3152	void CVDecTestEngine::SetSecureOutputL(TBool aSecure)
sl@0	3153	{
sl@0	3154	PRINT((_L("CVDecTestEngine::SetSecureOutputL, In")))
sl@0	3155
sl@0	3156	#ifdef __SECUREOUTPUTCI__
sl@0	3157
sl@0	3158	MMmfVideoSecureOutput* secureOutput = NULL; // Custom interface Secure output
sl@0	3159
sl@0	3160	secureOutput = (MMmfVideoSecureOutput*)iDevvp->CustomInterface(iPostProcId, KMmfVideoSecureOutputUid);
sl@0	3161
sl@0	3162	if (!secureOutput)
sl@0	3163	{
sl@0	3164	PRINT((_L("CVDecTestEngine::SetSecureOutput, Failed to retrieve Secure CI")))
sl@0	3165	User::Leave(KErrGeneral);
sl@0	3166	}
sl@0	3167
sl@0	3168	secureOutput->MmvsoSetSecureOutputL(aSecure);
sl@0	3169
sl@0	3170	#endif
sl@0	3171
sl@0	3172	PRINT((_L("CVDecTestEngine::SetSecureOutputL, Out [%d]"), aSecure))
sl@0	3173	}
sl@0	3174
sl@0	3175	/* ----------------------------------------------------------------------------
sl@0	3176	* Name: CVDecTestEngine::SetPosition
sl@0	3177	* Purpose: Set postion
sl@0	3178	* Note:
sl@0	3179	* Parameters: TTimeIntervalMicroSeconds aTimeStamp
sl@0	3180	* Return: None
sl@0	3181	* --------------------------------------------------------------------------*/
sl@0	3182
sl@0	3183
sl@0	3184	void CVDecTestEngine::SetPosition(const TTimeIntervalMicroSeconds& aPlaybackPosition)
sl@0	3185	{
sl@0	3186	PRINT((_L("CVDecTestEngine::SetPosition, In")))
sl@0	3187
sl@0	3188	iDevvp->SetPosition(aPlaybackPosition);
sl@0	3189
sl@0	3190	PRINT((_L("CVDecTestEngine::SetPosition, Out")))
sl@0	3191	}
sl@0	3192
sl@0	3193	/* ----------------------------------------------------------------------------
sl@0	3194	* Name: CVDecTestEngine::ResetPosition
sl@0	3195	* Purpose: Reset postion to start
sl@0	3196	* Note:
sl@0	3197	* Parameters: TTimeIntervalMicroSeconds aTimeStamp
sl@0	3198	* Return: None
sl@0	3199	* --------------------------------------------------------------------------*/
sl@0	3200
sl@0	3201
sl@0	3202	void CVDecTestEngine::ResetPosition()
sl@0	3203	{
sl@0	3204	PRINT((_L("CVDecTestEngine::ResetPosition, In")))
sl@0	3205	TTimeIntervalMicroSeconds starttime(0);
sl@0	3206
sl@0	3207	iDevvp->SetPosition(starttime);
sl@0	3208	PRINT((_L("CVDecTestEngine::ResetPosition, Reset Position to start of bitstream")))
sl@0	3209
sl@0	3210	if ( iSynchronized )
sl@0	3211	{
sl@0	3212	iClock->Reset(starttime);
sl@0	3213	iTimeStamp = 0;
sl@0	3214	TTimeIntervalMicroSeconds currenttime = iClock->Time();
sl@0	3215	PRINT((_L("CVDecTestEngine::ResetPosition, current time[%ld]"),currenttime.Int64() ))
sl@0	3216	}
sl@0	3217	TInt pos = 0;
sl@0	3218	iInFile.Seek(ESeekStart,pos);
sl@0	3219	iSentBuffCount = 0;
sl@0	3220
sl@0	3221	PRINT((_L("CVDecTestEngine::ResetPosition, In")))
sl@0	3222	}
sl@0	3223
sl@0	3224
sl@0	3225
sl@0	3226
sl@0	3227	/* ----------------------------------------------------------------------------
sl@0	3228	* Name: CVDecTestEngine::PlaybackPosition
sl@0	3229	* Purpose: Ritrieve Playback Position
sl@0	3230	* Note:
sl@0	3231	* Parameters: None
sl@0	3232	* Return: None
sl@0	3233	* --------------------------------------------------------------------------*/
sl@0	3234
sl@0	3235
sl@0	3236	TTimeIntervalMicroSeconds CVDecTestEngine::PlaybackPosition()
sl@0	3237	{
sl@0	3238	PRINT((_L("CVDecTestEngine::PlaybackPosition, In")))
sl@0	3239
sl@0	3240	TTimeIntervalMicroSeconds position = iDevvp->PlaybackPosition();
sl@0	3241	PRINT((_L("CVDecTestEngine::PlaybackPosition, Playback Position[%ld]"),position.Int64()))
sl@0	3242
sl@0	3243	PRINT((_L("CVDecTestEngine::PlaybackPosition, Out")))
sl@0	3244	return position;
sl@0	3245	}
sl@0	3246
sl@0	3247
sl@0	3248	/* ----------------------------------------------------------------------------
sl@0	3249	* Name: CVDecTestEngine::DecodingPosition
sl@0	3250	* Purpose: Ritrieve Decoding Position
sl@0	3251	* Note:
sl@0	3252	* Parameters: None
sl@0	3253	* Return: None
sl@0	3254	* --------------------------------------------------------------------------*/
sl@0	3255
sl@0	3256
sl@0	3257	void CVDecTestEngine::DecodingPosition()
sl@0	3258	{
sl@0	3259	PRINT((_L("CVDecTestEngine::DecodingPosition, In")))
sl@0	3260
sl@0	3261	TTimeIntervalMicroSeconds position = iDevvp->DecodingPosition();
sl@0	3262	PRINT((_L("CVDecTestEngine::DecodingPosition, Decoding Position[%ld]"),position.Int64()))
sl@0	3263
sl@0	3264	PRINT((_L("CVDecTestEngine::DecodingPosition, Out")))
sl@0	3265	}
sl@0	3266
sl@0	3267	/* ----------------------------------------------------------------------------
sl@0	3268	* Name: CVDecTestEngine::GetFrameSizeCount
sl@0	3269	* Purpose: Get frame size count after frame sizes are listed
sl@0	3270	* Note: Called after initialization
sl@0	3271	* Parameters: None
sl@0	3272	* Return: TInt
sl@0	3273	* --------------------------------------------------------------------------*/
sl@0	3274	TInt CVDecTestEngine::GetFrameSizeCount()
sl@0	3275	{
sl@0	3276	return iFrameSizeList.Count();
sl@0	3277	}
sl@0	3278
sl@0	3279	/* ----------------------------------------------------------------------------
sl@0	3280	* Name: CVDecTestEngine::EnableSynchronization
sl@0	3281	* Purpose: Set Clock and enable synchronization
sl@0	3282	* Note: Called before initialization and after Decoder/post-processor selected
sl@0	3283	* Parameters: TInt aFrameRate
sl@0	3284	* Return: None
sl@0	3285	* --------------------------------------------------------------------------*/
sl@0	3286
sl@0	3287	void CVDecTestEngine::EnableSynchronization(TInt aFrameRate)
sl@0	3288	{
sl@0	3289	PRINT((_L("CVDecTestEngine::EnableSynchronization, In")))
sl@0	3290
sl@0	3291	iDevvp->SetClockSource(iClock);
sl@0	3292	PRINT((_L("CVDecTestEngine::Synchronization, Clock source set")))
sl@0	3293
sl@0	3294	iSynchronized = ETrue;
sl@0	3295	iFrameTimeInterval = (TInt64)(1000000/aFrameRate);
sl@0	3296	PRINT((_L("CVDecTestEngine::Synchronization, Frame rate:[%d]"),aFrameRate ))
sl@0	3297
sl@0	3298	PRINT((_L("CVDecTestEngine::EnableSynchronization, Out")))
sl@0	3299	}
sl@0	3300
sl@0	3301
sl@0	3302	/* ----------------------------------------------------------------------------
sl@0	3303	* Name: CVDecTestEngine::SetWindowRect
sl@0	3304	* Purpose: Set sucure output enable
sl@0	3305	* Note:
sl@0	3306	* Parameters: TInt aX, TInt aY, TSize aSize
sl@0	3307	* Return: None
sl@0	3308	* --------------------------------------------------------------------------*/
sl@0	3309
sl@0	3310	void CVDecTestEngine::SetWindowRect(TInt aX, TInt aY, TSize aSize )
sl@0	3311	{
sl@0	3312
sl@0	3313	iDispRect.SetRect(TPoint(aX,aY),aSize);
sl@0	3314
sl@0	3315	PRINT((_L("CVDecTestEngine::SetWindowRect, [%d], [%d]"),aX ,aY ))
sl@0	3316	PRINT((_L("CVDecTestEngine::SetWindowRect, width[%d], height[%d]"),aSize.iWidth, aSize.iHeight))
sl@0	3317	}
sl@0	3318
sl@0	3319
sl@0	3320	/* ----------------------------------------------------------------------------
sl@0	3321	* Name: CVDecTestEngine::ListFrameSizeL
sl@0	3322	* Purpose: List size of each frmae of coded bitstream for synchrinized
sl@0	3323	* playback
sl@0	3324	* Note:
sl@0	3325	* Parameters: None
sl@0	3326	* Return: None
sl@0	3327	* --------------------------------------------------------------------------*/
sl@0	3328
sl@0	3329	void CVDecTestEngine::ListFrameSizeL(RArray<TInt> aFramesizes)
sl@0	3330	{
sl@0	3331
sl@0	3332	if ( iCodecType == EVC1 ){
sl@0	3333
sl@0	3334	PRINT((_L("CVDecTestEngine::ListFrameSizeL, not supported for VC1") ))
sl@0	3335	User::Leave(KErrGeneral);
sl@0	3336	}
sl@0	3337
sl@0	3338	TInt framesize = 0;
sl@0	3339	TVideoInputBuffer* videoBuffer = new(ELeave) TVideoInputBuffer;
sl@0	3340	iMemAlloc++;
sl@0	3341	HBufC8* tempBuff = HBufC8::NewL(iInBuffSize);
sl@0	3342	iMemAlloc++;
sl@0	3343	#ifdef __MEM_CHECK_
sl@0	3344	PRINT((_L("CVDecTestEngine::ListFrameSizeL, mem alloc, videoBuffer & iInBuffSize") ))
sl@0	3345	#endif
sl@0	3346	videoBuffer->iData.Set(tempBuff->Des());
sl@0	3347	//iListFrameSize = ETrue;
sl@0	3348
sl@0	3349	if(aFramesizes.Count() > 0)
sl@0	3350	{
sl@0	3351	for (TUint i = 0; i < aFramesizes.Count(); i++)
sl@0	3352	{
sl@0	3353	iFrameSizeList.AppendL(aFramesizes[i]);
sl@0	3354	PRINT((_L("CVDecTestEngine::ListFrameSize, user input [%d]"),aFramesizes[i]))
sl@0	3355	}
sl@0	3356
sl@0	3357	}
sl@0	3358	else
sl@0	3359	{
sl@0	3360	while (!iInputEnd)
sl@0	3361	{
sl@0	3362	videoBuffer->iData.SetLength(0);
sl@0	3363	framesize = ReadOneCodedPicture(videoBuffer);
sl@0	3364	PRINT((_L("CVDecTestEngine::ListFrameSize, frame size[%d]"),framesize))
sl@0	3365	// here append frame size in list
sl@0	3366
sl@0	3367	if (framesize >= 0 )
sl@0	3368	{
sl@0	3369	iFrameSizeList.AppendL(framesize);
sl@0	3370	iSentBuffCount++;
sl@0	3371	}
sl@0	3372	else
sl@0	3373	{
sl@0	3374	break;
sl@0	3375	}
sl@0	3376
sl@0	3377	}
sl@0	3378	}
sl@0	3379	PRINT((_L("CVDecTestEngine::ListFrameSize, frame count[%d]"),iFrameSizeList.Count()))
sl@0	3380
sl@0	3381	// cleanup
sl@0	3382	//Reset file postion to start
sl@0	3383	TInt pos =0;
sl@0	3384	iSentBuffCount = 0;
sl@0	3385	iReadDataChunk = iDataChunk;
sl@0	3386	iWriteDataChunk = iDataChunk;
sl@0	3387	iDataReadFromFile = 0;
sl@0	3388	iInFile.Seek(ESeekStart,pos);
sl@0	3389
sl@0	3390	iInputEnd = EFalse;
sl@0	3391
sl@0	3392	delete tempBuff;
sl@0	3393	delete videoBuffer;
sl@0	3394	iMemDelete += 2;
sl@0	3395	#ifdef __MEM_CHECK_
sl@0	3396	PRINT((_L("CVDecTestEngine::ListFrameSize, mem del, tempBuff & videoBuffer") ))
sl@0	3397	#endif
sl@0	3398	if ( framesize < 0)
sl@0	3399	{
sl@0	3400	PRINT((_L("CVDecTestEngine::ListFrameSize, error[%d]"),framesize ))
sl@0	3401	User::Leave(framesize);
sl@0	3402	}
sl@0	3403
sl@0	3404	}
sl@0	3405
sl@0	3406
sl@0	3407	/* ----------------------------------------------------------------------------
sl@0	3408	* Name: CVDecTestEngine::SetLandscapeMode()
sl@0	3409	* Purpose: Set landscape mode flag
sl@0	3410	* Note:
sl@0	3411	* Parameters: None
sl@0	3412	* Return: None
sl@0	3413	* --------------------------------------------------------------------------*/
sl@0	3414
sl@0	3415	/*
sl@0	3416	void CVDecTestEngine::SetLandscapeMode()
sl@0	3417	{
sl@0	3418
sl@0	3419	iLandscapeMode = ETrue;
sl@0	3420	PRINT((_L("CVDecTestEngine::SetLandscapeMode, Landscape mode is set") ))
sl@0	3421
sl@0	3422	}
sl@0	3423	*/
sl@0	3424
sl@0	3425	/* ----------------------------------------------------------------------------
sl@0	3426	* Name: CVDecTestEngine::SelectDecoderL()
sl@0	3427	* Purpose:
sl@0	3428	* Note:
sl@0	3429	* Parameters: None
sl@0	3430	* Return: None
sl@0	3431	* --------------------------------------------------------------------------*/
sl@0	3432	void CVDecTestEngine::SelectDecoderL(const TUid& aUid)
sl@0	3433	{
sl@0	3434	PRINT((_L("CVDecTestEngine::SelectDecoderL, In") ))
sl@0	3435
sl@0	3436	iDecoderUid = aUid;
sl@0	3437	iDecHWDevId = iDevvp->SelectDecoderL(aUid);
sl@0	3438
sl@0	3439	#ifdef __RESOURCENOTIFICATION__
sl@0	3440	MMmfVideoResourceHandler* handler = (MMmfVideoResourceHandler*)iDevvp->CustomInterface(iDecHWDevId, KUidMmfVideoResourceManagement );
sl@0	3441	handler->MmvrhSetObserver(((MMmfVideoResourceObserver*)(this)));
sl@0	3442	#endif
sl@0	3443
sl@0	3444	PRINT((_L("CVDecTestEngine::SelectDecoderL, Out") ))
sl@0	3445	}
sl@0	3446
sl@0	3447	/* ----------------------------------------------------------------------------
sl@0	3448	* Name: CVDecTestEngine::SelectPostProcessorL()
sl@0	3449	* Purpose:
sl@0	3450	* Note:
sl@0	3451	* Parameters: None
sl@0	3452	* Return: None
sl@0	3453	* --------------------------------------------------------------------------*/
sl@0	3454	void CVDecTestEngine::SelectPostProcessorL(const TUid& aUid)
sl@0	3455	{
sl@0	3456	PRINT((_L("CVDecTestEngine::SelectPostProcessorL, In") ))
sl@0	3457
sl@0	3458	iPostProcessorUid = aUid;
sl@0	3459	iPostProcId = iDevvp->SelectPostProcessorL(aUid);
sl@0	3460
sl@0	3461	PRINT((_L("CVDecTestEngine::SelectPostProcessorL, Out") ))
sl@0	3462	}
sl@0	3463
sl@0	3464	/* ----------------------------------------------------------------------------
sl@0	3465	* Name: CVDecTestEngine::SetBufferOptionsL()
sl@0	3466	* Purpose:
sl@0	3467	* Note:
sl@0	3468	* Parameters: None
sl@0	3469	* Return: None
sl@0	3470	* --------------------------------------------------------------------------*/
sl@0	3471	void CVDecTestEngine::SetBufferOptionsL(const CMMFDevVideoPlay::TBufferOptions& aOptions)
sl@0	3472	{
sl@0	3473	PRINT((_L("CVDecTestEngine::SetBufferOptionsL, In") ))
sl@0	3474
sl@0	3475	iInBuffSize = aOptions.iMaxInputBufferSize;
sl@0	3476	iDevvp->SetBufferOptionsL(aOptions);
sl@0	3477
sl@0	3478	PRINT((_L("CVDecTestEngine::SetBufferOptionsL, Out") ))
sl@0	3479	}
sl@0	3480
sl@0	3481	/* ----------------------------------------------------------------------------
sl@0	3482	* Name: CVDecTestEngine::SetVideoDestScreenL()
sl@0	3483	* Purpose:
sl@0	3484	* Note:
sl@0	3485	* Parameters: None
sl@0	3486	* Return: None
sl@0	3487	* --------------------------------------------------------------------------*/
sl@0	3488	void CVDecTestEngine::SetVideoDestScreenL(TBool aDest)
sl@0	3489	{
sl@0	3490	PRINT((_L("CVDecTestEngine::SetVideoDestScreenL, In") ))
sl@0	3491
sl@0	3492	iDevvp->SetVideoDestScreenL(aDest);
sl@0	3493
sl@0	3494	PRINT((_L("CVDecTestEngine::SetVideoDestScreenL, Out") ))
sl@0	3495	}
sl@0	3496
sl@0	3497	/* ----------------------------------------------------------------------------
sl@0	3498	* Name: CVDecTestEngine::SynchronizeDecoding()
sl@0	3499	* Purpose:
sl@0	3500	* Note:
sl@0	3501	* Parameters: None
sl@0	3502	* Return: None
sl@0	3503	* --------------------------------------------------------------------------*/
sl@0	3504	void CVDecTestEngine::SynchronizeDecoding(TBool aSynch)
sl@0	3505	{
sl@0	3506	PRINT((_L("CVDecTestEngine::SynchronizeDecoding, In") ))
sl@0	3507
sl@0	3508	iDevvp->SynchronizeDecoding(aSynch);
sl@0	3509
sl@0	3510	PRINT((_L("CVDecTestEngine::SynchronizeDecoding, Out") ))
sl@0	3511	}
sl@0	3512
sl@0	3513	/* ----------------------------------------------------------------------------
sl@0	3514	* Name: CVDecTestEngine::GetBufferOptions()
sl@0	3515	* Purpose:
sl@0	3516	* Note:
sl@0	3517	* Parameters: None
sl@0	3518	* Return: None
sl@0	3519	* --------------------------------------------------------------------------*/
sl@0	3520	void CVDecTestEngine::GetBufferOptions()
sl@0	3521	{
sl@0	3522	PRINT((_L("CVDecTestEngine::GetBufferOptions, In") ))
sl@0	3523
sl@0	3524	CMMFDevVideoPlay::TBufferOptions options;
sl@0	3525	iDevvp->GetBufferOptions(options);
sl@0	3526
sl@0	3527	PRINT((_L("CVDecTestEngine::GetBufferOptions: iPreDecodeBufferSize: [%d]\n iMaxPostDecodeBufferSize: [%d]\n"),
sl@0	3528	options.iPreDecodeBufferSize, options.iMaxPostDecodeBufferSize))
sl@0	3529	PRINT((_L("CVDecTestEngine::GetBufferOptions: iMaxInputBufferSize [%d]\n iMinNumInputBuffers [%d]\n "),
sl@0	3530	options.iMaxInputBufferSize, options.iMinNumInputBuffers))
sl@0	3531	PRINT((_L("CVDecTestEngine::GetBufferOptions: iPreDecoderBufferPeriod [%d] [%d]"), I64LOW(options.iPreDecoderBufferPeriod.Int64()), I64HIGH(options.iPreDecoderBufferPeriod.Int64())))
sl@0	3532	PRINT((_L("CVDecTestEngine::GetBufferOptions: iPostDecoderBufferPeriod [%d] [%d]"), I64LOW(options.iPostDecoderBufferPeriod.Int64()), I64HIGH(options.iPostDecoderBufferPeriod.Int64())))
sl@0	3533
sl@0	3534	PRINT((_L("CVDecTestEngine::GetBufferOptions, Out") ))
sl@0	3535	}
sl@0	3536
sl@0	3537	/* ----------------------------------------------------------------------------
sl@0	3538	* Name: CVDecTestEngine::SetInputFormatL()
sl@0	3539	* Purpose:
sl@0	3540	* Note:
sl@0	3541	* Parameters: None
sl@0	3542	* Return: None
sl@0	3543	* --------------------------------------------------------------------------*/
sl@0	3544	void CVDecTestEngine::SetInputFormatL(TInt aHwDev, const TUncompressedVideoFormat& aFormat)
sl@0	3545	{
sl@0	3546	PRINT((_L("CVDecTestEngine::SetInputFormatL, In") ))
sl@0	3547
sl@0	3548	if (aHwDev == EPostProcessor)
sl@0	3549	{
sl@0	3550	iDevvp->SetInputFormatL(iPostProcId, aFormat);
sl@0	3551	}
sl@0	3552	else
sl@0	3553	{
sl@0	3554	iDevvp->SetInputFormatL(iDecHWDevId, aFormat);
sl@0	3555	}
sl@0	3556
sl@0	3557	PRINT((_L("CVDecTestEngine::SetInputFormatL, Out") ))
sl@0	3558	}
sl@0	3559
sl@0	3560	/* ----------------------------------------------------------------------------
sl@0	3561	* Name: CVDecTestEngine::SetOutputFormatL()
sl@0	3562	* Purpose:
sl@0	3563	* Note:
sl@0	3564	* Parameters: None
sl@0	3565	* Return: None
sl@0	3566	* --------------------------------------------------------------------------*/
sl@0	3567	void CVDecTestEngine::SetOutputFormatL(TInt aHwDev, const TUncompressedVideoFormat& aFormat)
sl@0	3568	{
sl@0	3569	PRINT((_L("CVDecTestEngine::SetOutputFormatL, In") ))
sl@0	3570
sl@0	3571	if (aHwDev == EPostProcessor)
sl@0	3572	{
sl@0	3573	iDevvp->SetOutputFormatL(iPostProcId, aFormat);
sl@0	3574	}
sl@0	3575	else
sl@0	3576	{
sl@0	3577	iDevvp->SetOutputFormatL(iDecHWDevId, aFormat);
sl@0	3578	}
sl@0	3579
sl@0	3580	PRINT((_L("CVDecTestEngine::SetOutputFormatL, Out") ))
sl@0	3581	}
sl@0	3582
sl@0	3583	/* ----------------------------------------------------------------------------
sl@0	3584	* Name: CVDecTestEngine::SetInputFormatL()
sl@0	3585	* Purpose:
sl@0	3586	* Note:
sl@0	3587	* Parameters: None
sl@0	3588	* Return: None
sl@0	3589	* --------------------------------------------------------------------------*/
sl@0	3590	void CVDecTestEngine::SetInputFormatL(TInt aHwDev, const CCompressedVideoFormat& aFormat,
sl@0	3591	TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation,
sl@0	3592	TBool aDataInOrder)
sl@0	3593	{
sl@0	3594	PRINT((_L("CVDecTestEngine::SetInputFormatL, In") ))
sl@0	3595
sl@0	3596	if (aHwDev == EPostProcessor)
sl@0	3597	{
sl@0	3598	iDevvp->SetInputFormatL(iPostProcId, aFormat, aDataUnitType, aEncapsulation, aDataInOrder);
sl@0	3599	}
sl@0	3600	else
sl@0	3601	{
sl@0	3602	iDevvp->SetInputFormatL(iDecHWDevId, aFormat, aDataUnitType, aEncapsulation, aDataInOrder);
sl@0	3603	}
sl@0	3604
sl@0	3605	PRINT((_L("CVDecTestEngine::SetInputFormatL, Out") ))
sl@0	3606	}
sl@0	3607
sl@0	3608	/* ----------------------------------------------------------------------------
sl@0	3609	* Name: CVDecTestEngine::FindCommonFormats()
sl@0	3610	* Purpose:
sl@0	3611	* Note:
sl@0	3612	* Parameters: None
sl@0	3613	* Return: None
sl@0	3614	* --------------------------------------------------------------------------*/
sl@0	3615	void CVDecTestEngine::FindCommonFormatsL()
sl@0	3616	{
sl@0	3617	PRINT((_L("CVDecTestEngine::FindCommonFormatsL, In") ))
sl@0	3618
sl@0	3619	// Set Output Format for Decoder/Input Format for Postprocessor
sl@0	3620	RArray<TUncompressedVideoFormat> decformats;
sl@0	3621	TUncompressedVideoFormat commonFormat;
sl@0	3622
sl@0	3623
sl@0	3624	iDevvp->GetOutputFormatListL(iDecHWDevId, decformats);
sl@0	3625
sl@0	3626	CPostProcessorInfo* info;
sl@0	3627
sl@0	3628	info = iDevvp->PostProcessorInfoLC(iPostProcessorUid);
sl@0	3629
sl@0	3630	RArray<TUncompressedVideoFormat> ppformats;
sl@0	3631	ppformats = info->SupportedFormats();
sl@0	3632
sl@0	3633	//Find common format for dec output and postproc input
sl@0	3634	TBool found = iDevvp->FindCommonFormat(decformats.Array(), ppformats.Array(), commonFormat);
sl@0	3635
sl@0	3636	if (found)
sl@0	3637	{
sl@0	3638	iDevvp->SetOutputFormatL(iDecHWDevId, commonFormat);
sl@0	3639	PRINT((_L("CVDecTestEngine::FindCommonFormatsL, Decoder output Format set")))
sl@0	3640	iDevvp->SetInputFormatL(iPostProcId, commonFormat);
sl@0	3641	PRINT((_L("CVDecTestEngine::FindCommonFormatsL, Postprocessor input format set.")))
sl@0	3642	PrintUncompressedFormat(commonFormat);
sl@0	3643	}
sl@0	3644	else
sl@0	3645	{
sl@0	3646	PRINT((_L("CVDecTestEngine::FindCommonFormatsL, Common Format not found")))
sl@0	3647	User::Leave( KErrNotFound);
sl@0	3648	}
sl@0	3649	CleanupStack::PopAndDestroy(info);
sl@0	3650	PRINT((_L("CVDecTestEngine::FindCommonFormatsL, closing array") ))
sl@0	3651	decformats.Close();
sl@0	3652	PRINT((_L("CVDecTestEngine::FindCommonFormatsL, Out") ))
sl@0	3653	}
sl@0	3654
sl@0	3655	/* ----------------------------------------------------------------------------
sl@0	3656	* Name: CVDecTestEngine::FindDecodersL()
sl@0	3657	* Purpose:
sl@0	3658	* Note:
sl@0	3659	* Parameters: None
sl@0	3660	* Return: None
sl@0	3661	* --------------------------------------------------------------------------*/
sl@0	3662	TInt CVDecTestEngine::FindDecodersL(const TDesC8& aMimeType, TUint32 aPostProcType, TBool aExactMatch, TUid& aUid )
sl@0	3663	{
sl@0	3664	PRINT((_L("CVDecTestEngine::FindDecodersL, In") ))
sl@0	3665
sl@0	3666	TInt supports = KErrNotSupported;
sl@0	3667
sl@0	3668	//UID is not set
sl@0	3669	if (aUid.iUid == 0 && !aExactMatch)
sl@0	3670	{
sl@0	3671	supports = KErrNone;
sl@0	3672	}
sl@0	3673
sl@0	3674	RArray<TUid> decoders;
sl@0	3675	CleanupClosePushL(decoders);
sl@0	3676	iDevvp->FindDecodersL(aMimeType, aPostProcType, decoders, aExactMatch);
sl@0	3677	for (TUint i = 0; i < decoders.Count(); i++)
sl@0	3678	{
sl@0	3679	if (decoders[i].iUid == aUid.iUid)
sl@0	3680	{
sl@0	3681	supports = KErrNone;
sl@0	3682	}
sl@0	3683
sl@0	3684	PRINT((_L("CVDecTestEngine::FindDecodersL, Uid [%x]"), decoders[i].iUid ))
sl@0	3685	}
sl@0	3686	CleanupStack::PopAndDestroy(&decoders);
sl@0	3687
sl@0	3688	PRINT((_L("CVDecTestEngine::FindDecodersL, Out") ))
sl@0	3689
sl@0	3690	return supports;
sl@0	3691	}
sl@0	3692
sl@0	3693	/* ----------------------------------------------------------------------------
sl@0	3694	* Name: CVDecTestEngine::FindPostProcessorsL()
sl@0	3695	* Purpose:
sl@0	3696	* Note:
sl@0	3697	* Parameters: None
sl@0	3698	* Return: None
sl@0	3699	* --------------------------------------------------------------------------*/
sl@0	3700	TInt CVDecTestEngine::FindPostProcessorsL(TUid& aUid, TUint32 aPostProcType)
sl@0	3701	{
sl@0	3702	PRINT((_L("CVDecTestEngine::FindPostProcessorsL, In") ))
sl@0	3703
sl@0	3704	TInt supports = KErrNotSupported;
sl@0	3705
sl@0	3706	//UID is not set
sl@0	3707	if (aUid.iUid == 0)
sl@0	3708	{
sl@0	3709	supports = KErrNone;
sl@0	3710	}
sl@0	3711
sl@0	3712	RArray<TUid> postProcessors;
sl@0	3713	CleanupClosePushL(postProcessors);
sl@0	3714	iDevvp->FindPostProcessorsL(aPostProcType, postProcessors);
sl@0	3715	for (TUint i = 0; i < postProcessors.Count(); i++)
sl@0	3716	{
sl@0	3717	PRINT((_L("CVDecTestEngine::FindPostProcessorsL, Uid [%x]"), postProcessors[i].iUid ))
sl@0	3718
sl@0	3719	if (postProcessors[i].iUid == aUid.iUid)
sl@0	3720	{
sl@0	3721	supports = KErrNone;
sl@0	3722	}
sl@0	3723
sl@0	3724	}
sl@0	3725	CleanupStack::PopAndDestroy(&postProcessors);
sl@0	3726
sl@0	3727	PRINT((_L("CVDecTestEngine::FindPostProcessorsL, Out") ))
sl@0	3728	return supports;
sl@0	3729	}
sl@0	3730
sl@0	3731	/* ----------------------------------------------------------------------------
sl@0	3732	* Name: CVDecTestEngine::GetDecoderListL()
sl@0	3733	* Purpose:
sl@0	3734	* Note:
sl@0	3735	* Parameters: None
sl@0	3736	* Return: None
sl@0	3737	* --------------------------------------------------------------------------*/
sl@0	3738	void CVDecTestEngine::GetDecoderListL()
sl@0	3739	{
sl@0	3740	PRINT((_L("CVDecTestEngine::GetDecoderListL, In") ))
sl@0	3741
sl@0	3742	RArray<TUid> decoders;
sl@0	3743	CleanupClosePushL(decoders);
sl@0	3744	iDevvp->GetDecoderListL(decoders);
sl@0	3745	for (TUint i = 0; i < decoders.Count(); i++)
sl@0	3746	{
sl@0	3747	PRINT((_L("CVDecTestEngine::GetDecoderListL, Uid [%x]"), decoders[i].iUid ))
sl@0	3748	}
sl@0	3749	CleanupStack::PopAndDestroy(&decoders);
sl@0	3750
sl@0	3751	PRINT((_L("CVDecTestEngine::GetDecoderListL, Out") ))
sl@0	3752	}
sl@0	3753
sl@0	3754	/* ----------------------------------------------------------------------------
sl@0	3755	* Name: CVDecTestEngine::ConfigureDecoderL()
sl@0	3756	* Purpose:
sl@0	3757	* Note:
sl@0	3758	* Parameters: None
sl@0	3759	* Return: None
sl@0	3760	* --------------------------------------------------------------------------*/
sl@0	3761	void CVDecTestEngine::ConfigureDecoderL(TVideoPictureHeader& aVideoPictureHeader)
sl@0	3762	{
sl@0	3763	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, In") ))
sl@0	3764
sl@0	3765	if( iSetPassword )
sl@0	3766	{
sl@0	3767	TBuf16<128> tempBuf;
sl@0	3768	tempBuf.Copy( iPasswordForFLV);
sl@0	3769	PRINT( ( _L( "CVDecTestEngine::ConfigureDecoderL(): password tempBuf: %S." ), &tempBuf ) )
sl@0	3770
sl@0	3771	TPtrC8 metaData((TUint8*)iPasswordForFLV.Ptr(), iPasswordForFLV.Size());
sl@0	3772
sl@0	3773	aVideoPictureHeader.iOptional = &metaData;
sl@0	3774
sl@0	3775	}
sl@0	3776
sl@0	3777	iDevvp->ConfigureDecoderL(aVideoPictureHeader);
sl@0	3778
sl@0	3779	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, Out") ))
sl@0	3780	}
sl@0	3781
sl@0	3782
sl@0	3783	/* ----------------------------------------------------------------------------
sl@0	3784	* Name: CVDecTestEngine::ConfigureDecoderL()
sl@0	3785	* Purpose:
sl@0	3786	* Note:
sl@0	3787	* Parameters: None
sl@0	3788	* Return: None
sl@0	3789	* --------------------------------------------------------------------------*/
sl@0	3790	void CVDecTestEngine::ConfigureDecoderL()
sl@0	3791	{
sl@0	3792	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, In") ))
sl@0	3793
sl@0	3794	if (iCodecType == EVC1)
sl@0	3795	{
sl@0	3796	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, iCodectype VC1") ))
sl@0	3797	TInt configPosition = 0;
sl@0	3798	TUint configDataSize = 36; // MetaData is 36 Bytes in SP-L0 VC1 .
sl@0	3799	TUint8* ptr = new (ELeave) TUint8[configDataSize+8];
sl@0	3800	iMemAlloc++;
sl@0	3801	#ifdef __MEM_CHECK_
sl@0	3802	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, mem alloc, ptr") ))
sl@0	3803	#endif
sl@0	3804	TUint32* ptr32 = reinterpret_cast<TUint32*>(ptr);
sl@0	3805	ptr32[0] = 1;
sl@0	3806	ptr32[1] = 44;
sl@0	3807	TPtr8 configData((ptr+8), configDataSize);
sl@0	3808	for (TUint i=0; i < 8; i++)
sl@0	3809	{
sl@0	3810	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, beginning [%d]"), ptr[i] ))
sl@0	3811	}
sl@0	3812
sl@0	3813	User::LeaveIfError(iInFile.Seek(ESeekStart, configPosition));
sl@0	3814	User::LeaveIfError(iInFile.Read(configData, configDataSize));
sl@0	3815	TVideoPictureHeader* configHeader = new TVideoPictureHeader;
sl@0	3816	iMemAlloc++;
sl@0	3817	CleanupStack::PushL(configHeader);
sl@0	3818	#ifdef __MEM_CHECK_
sl@0	3819	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, mem alloc, configHeader") ))
sl@0	3820	#endif
sl@0	3821
sl@0	3822	TPtrC8 metaData(ptr,configDataSize+8);
sl@0	3823
sl@0	3824
sl@0	3825	configHeader->iOptional = &metaData;
sl@0	3826	configHeader->iLevel = -1;
sl@0	3827	configHeader->iProfile = -1;
sl@0	3828
sl@0	3829	iDevvp->ConfigureDecoderL(*configHeader);
sl@0	3830
sl@0	3831
sl@0	3832	CleanupStack::Pop();
sl@0	3833	delete ptr;
sl@0	3834	iMemDelete++;
sl@0	3835	delete configHeader;
sl@0	3836	iMemDelete++;
sl@0	3837	#ifdef __MEM_CHECK_
sl@0	3838	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, mem del, ptr & configHeader") ))
sl@0	3839	#endif
sl@0	3840	return;
sl@0	3841	}
sl@0	3842
sl@0	3843	TInt err = KErrNone;
sl@0	3844	TVideoPictureHeader* headerInfo = NULL;
sl@0	3845	HBufC8* tempBuff = NULL;
sl@0	3846
sl@0	3847	//Read Picture header : Size is not known
sl@0	3848	TVideoInputBuffer* codedBuffer = new(ELeave) TVideoInputBuffer;
sl@0	3849	CleanupStack::PushL( codedBuffer );
sl@0	3850	iInBuffSize = KMaxCodedSize;
sl@0	3851	err = KErrOverflow;
sl@0	3852
sl@0	3853	while ( (err == KErrOverflow) && (iInBuffSize <= KMaxCodedSize) )
sl@0	3854	{
sl@0	3855	tempBuff = HBufC8::NewL(iInBuffSize);
sl@0	3856	CleanupStack::PushL( tempBuff );
sl@0	3857	codedBuffer->iData.Set(tempBuff->Des());
sl@0	3858
sl@0	3859	if ( iFrameSizeList.Count() > 0 )
sl@0	3860	{
sl@0	3861	err = ReadOneCodedPicture(codedBuffer, iFrameSizeList[0] );
sl@0	3862	}
sl@0	3863	else
sl@0	3864	{
sl@0	3865	err = ReadOneCodedPicture(codedBuffer);
sl@0	3866	}
sl@0	3867	//err = ReadOneCodedPicture(codedBuffer);
sl@0	3868
sl@0	3869	TInt pos =0;
sl@0	3870	if ( iInFile.Seek(ESeekStart,pos) )
sl@0	3871	{
sl@0	3872	err = KErrGeneral;
sl@0	3873	}
sl@0	3874
sl@0	3875	if ( iInputEnd )
sl@0	3876	{
sl@0	3877	err = KErrNotFound;
sl@0	3878	}
sl@0	3879
sl@0	3880	if ( err < 0 )
sl@0	3881	{
sl@0	3882	CleanupStack::PopAndDestroy(tempBuff);
sl@0	3883	iInBuffSize = 4*iInBuffSize;
sl@0	3884	}
sl@0	3885	}
sl@0	3886
sl@0	3887
sl@0	3888	// Reitrieve header information from bitstream
sl@0	3889	if ( err < 0 )
sl@0	3890	{
sl@0	3891	CleanupStack::PopAndDestroy(codedBuffer);
sl@0	3892	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, Reading input data fail")))
sl@0	3893	}
sl@0	3894	else
sl@0	3895	{
sl@0	3896	err = KErrNone;
sl@0	3897
sl@0	3898	headerInfo = iDevvp->GetHeaderInformationL(EDuCodedPicture,EDuElementaryStream,codedBuffer);
sl@0	3899
sl@0	3900	CleanupStack::PopAndDestroy(tempBuff);
sl@0	3901	CleanupStack::PopAndDestroy(codedBuffer);
sl@0	3902
sl@0	3903	//Check Header info
sl@0	3904	if ( headerInfo )
sl@0	3905	{
sl@0	3906
sl@0	3907	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, Configuring the decoder")))
sl@0	3908
sl@0	3909
sl@0	3910	if( iSetPassword )
sl@0	3911	{
sl@0	3912	TBuf16<128> tempBuf;
sl@0	3913	tempBuf.Copy( iPasswordForFLV);
sl@0	3914	PRINT( ( _L( "CVDecTestEngine::ConfigureDecoderL(): password tempBuf: %S." ), &tempBuf ) )
sl@0	3915
sl@0	3916	TPtrC8 metaData((TUint8*)iPasswordForFLV.Ptr(), iPasswordForFLV.Size());
sl@0	3917
sl@0	3918	headerInfo->iOptional = &metaData;
sl@0	3919
sl@0	3920	}
sl@0	3921	iDevvp->ConfigureDecoderL(*headerInfo);
sl@0	3922
sl@0	3923	//return headerInfo
sl@0	3924	iDevvp->ReturnHeader(headerInfo);
sl@0	3925
sl@0	3926	}
sl@0	3927	else
sl@0	3928	{
sl@0	3929	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, Get header info fail")))
sl@0	3930	err = KErrGeneral;
sl@0	3931	}
sl@0	3932
sl@0	3933	}
sl@0	3934
sl@0	3935	// Set size of decoder input buffer
sl@0	3936	if ( iCodecType == EH263 )
sl@0	3937	{
sl@0	3938	if ( (iPictureSize.iWidth <= 176 ) && (iPictureSize.iHeight <= 144) )
sl@0	3939	iInBuffSize = KH263MaxCodedSizeQCIF;
sl@0	3940	else
sl@0	3941	iInBuffSize = KH263MaxCodedSizeCIF;
sl@0	3942
sl@0	3943	}
sl@0	3944	else //Mpeg4 and AVC and FLV
sl@0	3945	{
sl@0	3946	if ( (iPictureSize.iWidth <= 176 ) && (iPictureSize.iHeight <= 144) )
sl@0	3947	iInBuffSize = KMP4MaxCodedSizeQCIF;
sl@0	3948	else if ( (iPictureSize.iWidth <= 352 ) && (iPictureSize.iHeight <= 288) )
sl@0	3949	iInBuffSize = KMP4MaxCodedSizeCIF;
sl@0	3950	else if ( (iPictureSize.iWidth <= 640 ) && (iPictureSize.iHeight <= 480) )
sl@0	3951	iInBuffSize = KMP4MaxCodedSizeVGA;
sl@0	3952	else if ( (iPictureSize.iWidth <= 720 ) && (iPictureSize.iHeight <= 576) )
sl@0	3953	iInBuffSize = KMP4MaxCodedSizePAL;
sl@0	3954	else
sl@0	3955	iInBuffSize = KMaxCodedSize;
sl@0	3956	}
sl@0	3957
sl@0	3958	AssertTIntEqualL(KErrNone, err);
sl@0	3959
sl@0	3960	TInt pos =0;
sl@0	3961	iSentBuffCount = 0;
sl@0	3962	iReadDataChunk = iDataChunk;
sl@0	3963	iWriteDataChunk = iDataChunk;
sl@0	3964	iDataReadFromFile = 0;
sl@0	3965	iInFile.Seek(ESeekStart,pos);
sl@0	3966
sl@0	3967	PRINT((_L("CVDecTestEngine::ConfigureDecoderL, Out") ))
sl@0	3968	}
sl@0	3969
sl@0	3970	/* ----------------------------------------------------------------------------
sl@0	3971	* Name: CVDecTestEngine::GetOutputFormatListL()
sl@0	3972	* Purpose:
sl@0	3973	* Note:
sl@0	3974	* Parameters: None
sl@0	3975	* Return: None
sl@0	3976	* --------------------------------------------------------------------------*/
sl@0	3977	void CVDecTestEngine::GetOutputFormatListL(TInt aHWDevice)
sl@0	3978	{
sl@0	3979	PRINT((_L("CVDecTestEngine::GetOutputFormatListL, In") ))
sl@0	3980
sl@0	3981	RArray<TUncompressedVideoFormat> formats;
sl@0	3982	CleanupClosePushL(formats);
sl@0	3983	if (aHWDevice == EPostProcessor)
sl@0	3984	{
sl@0	3985	iDevvp->GetOutputFormatListL(iPostProcId, formats);
sl@0	3986	}
sl@0	3987	else
sl@0	3988	{
sl@0	3989	iDevvp->GetOutputFormatListL(iDecHWDevId, formats);
sl@0	3990	}
sl@0	3991
sl@0	3992	for (TUint i = 0; i < formats.Count(); i++)
sl@0	3993	{
sl@0	3994	PRINT((_L("CVDecTestEngine::GetOutputFormatListL, Format No.%d"), i))
sl@0	3995	PrintUncompressedFormat(formats[i]);
sl@0	3996	}
sl@0	3997	CleanupStack::PopAndDestroy(&formats);
sl@0	3998
sl@0	3999	PRINT((_L("CVDecTestEngine::GetOutputFormatListL, Out") ))
sl@0	4000	}
sl@0	4001
sl@0	4002	/* ----------------------------------------------------------------------------
sl@0	4003	* Name: CVDecTestEngine::SupportsOutputFormatL()
sl@0	4004	* Purpose:
sl@0	4005	* Note:
sl@0	4006	* Parameters: None
sl@0	4007	* Return: None
sl@0	4008	* --------------------------------------------------------------------------*/
sl@0	4009	TInt CVDecTestEngine::SupportsOutputFormatL(TInt aHwdev, const TUncompressedVideoFormat& aFormat)
sl@0	4010	{
sl@0	4011	PRINT((_L("CVDecTestEngine::SupportsOutputFormatL, In") ))
sl@0	4012
sl@0	4013	TInt result = KErrNotSupported;
sl@0	4014
sl@0	4015	RArray<TUncompressedVideoFormat> formats;
sl@0	4016	CleanupClosePushL(formats);
sl@0	4017	if (aHwdev == EPostProcessor)
sl@0	4018	{
sl@0	4019	iDevvp->GetOutputFormatListL(iPostProcId, formats);
sl@0	4020	}
sl@0	4021	else
sl@0	4022	{
sl@0	4023	iDevvp->GetOutputFormatListL(iDecHWDevId, formats);
sl@0	4024	}
sl@0	4025
sl@0	4026	for (TUint i = 0; i < formats.Count(); i++)
sl@0	4027	{
sl@0	4028	PRINT((_L("CVDecTestEngine::SupportsOutputFormatL, Format No.%d"), i))
sl@0	4029	if (formats[i] == aFormat)
sl@0	4030	{
sl@0	4031	result = KErrNone;
sl@0	4032	}
sl@0	4033	PrintUncompressedFormat(formats[i]);
sl@0	4034	}
sl@0	4035	CleanupStack::PopAndDestroy(&formats);
sl@0	4036
sl@0	4037	PRINT((_L("CVDecTestEngine::SupportsOutputFormatL, Out") ))
sl@0	4038
sl@0	4039	return result;
sl@0	4040	}
sl@0	4041
sl@0	4042	/* ----------------------------------------------------------------------------
sl@0	4043	* Name: CVDecTestEngine::GetPostProcessorListL()
sl@0	4044	* Purpose:
sl@0	4045	* Note:
sl@0	4046	* Parameters: None
sl@0	4047	* Return: None
sl@0	4048	* --------------------------------------------------------------------------*/
sl@0	4049	void CVDecTestEngine::GetPostProcessorListL()
sl@0	4050	{
sl@0	4051	PRINT((_L("CVDecTestEngine::GetPostProcessorListL, Out") ))
sl@0	4052
sl@0	4053	RArray<TUid> postProcessors;
sl@0	4054	CleanupClosePushL(postProcessors);
sl@0	4055	iDevvp->GetPostProcessorListL(postProcessors);
sl@0	4056	for (TUint i = 0; i < postProcessors.Count(); i++)
sl@0	4057	{
sl@0	4058	PRINT((_L("CVDecTestEngine::GetPostProcessorListL, Uid [%x]"), postProcessors[i].iUid ))
sl@0	4059	}
sl@0	4060	CleanupStack::PopAndDestroy(&postProcessors);
sl@0	4061
sl@0	4062	PRINT((_L("CVDecTestEngine::GetPostProcessorListL, Out") ))
sl@0	4063	}
sl@0	4064
sl@0	4065	/* ----------------------------------------------------------------------------
sl@0	4066	* Name: CVDecTestEngine::VideoDecoderInfoL()
sl@0	4067	* Purpose:
sl@0	4068	* Note:
sl@0	4069	* Parameters: None
sl@0	4070	* Return: None
sl@0	4071	* --------------------------------------------------------------------------*/
sl@0	4072	void CVDecTestEngine::VideoDecoderInfoL(TUid aVideoDecoder)
sl@0	4073	{
sl@0	4074	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, In") ))
sl@0	4075
sl@0	4076	CVideoDecoderInfo* info;
sl@0	4077	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, 2test") ))
sl@0	4078	info = iDevvp->VideoDecoderInfoLC(aVideoDecoder);
sl@0	4079
sl@0	4080	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, test") ))
sl@0	4081
sl@0	4082	TVersion version = info->Version();
sl@0	4083	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, Manufacturer: %S"), &info->Manufacturer()))
sl@0	4084	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, Identifier: %S"), &info->Identifier()))
sl@0	4085	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, Version information:")))
sl@0	4086	PRINT((_L("Major Version:[%d], Minor Version:[%d], Build number:[%d] "), version.iMajor,version.iMinor,version.iBuild))
sl@0	4087	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, HW Accelerated:[%d]"),info->Accelerated()))
sl@0	4088	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, Support Direct Screen:[%d]"),info->SupportsDirectDisplay()))
sl@0	4089	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, MaxPictureSize, %dx%d"),info->MaxPictureSize().iWidth, info->MaxPictureSize().iHeight))
sl@0	4090	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, MaxBitrate: [%d]"),info->MaxBitrate()))
sl@0	4091	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, SupportsPictureLoss: [%d]"),info->SupportsPictureLoss()))
sl@0	4092	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, SupportsSliceLoss: [%d]"),info->SupportsSliceLoss()))
sl@0	4093	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, CodingStandardSpecificInfo: %S"), &info->CodingStandardSpecificInfo()))
sl@0	4094	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, ImplementationSpecificInfo: %S"), &info->ImplementationSpecificInfo()))
sl@0	4095
sl@0	4096	CleanupStack::PopAndDestroy(info);
sl@0	4097
sl@0	4098	PRINT((_L("CVDecTestEngine::VideoDecoderInfoL, Out") ))
sl@0	4099	}
sl@0	4100
sl@0	4101	/* ----------------------------------------------------------------------------
sl@0	4102	* Name: CVDecTestEngine::PostProcessorInfoL()
sl@0	4103	* Purpose:
sl@0	4104	* Note:
sl@0	4105	* Parameters: None
sl@0	4106	* Return: None
sl@0	4107	* --------------------------------------------------------------------------*/
sl@0	4108	void CVDecTestEngine::PostProcessorInfoL(TUid aPostProcessor)
sl@0	4109	{
sl@0	4110	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, In") ))
sl@0	4111
sl@0	4112	CPostProcessorInfo* info;
sl@0	4113	info = iDevvp->PostProcessorInfoLC(aPostProcessor);
sl@0	4114
sl@0	4115	TVersion version = info->Version();
sl@0	4116	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Manufacturer: %S"), &info->Manufacturer()))
sl@0	4117	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Identifier: %S"), &info->Identifier()))
sl@0	4118	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Version information:")))
sl@0	4119	PRINT((_L("Major Version:[%d], Minor Version:[%d], Build number:[%d] "), version.iMajor,version.iMinor,version.iBuild))
sl@0	4120
sl@0	4121	// combination
sl@0	4122	RArray<TUint32> combination = info->SupportedCombinations();
sl@0	4123
sl@0	4124	for (TInt i=0; i < combination.Count(); i++)
sl@0	4125	{
sl@0	4126	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, combiantion:[%x]"), combination.operator[](i)))
sl@0	4127	}
sl@0	4128
sl@0	4129	//Color Conversion YUV to RGV
sl@0	4130	TYuvToRgbCapabilities colorconv;
sl@0	4131	colorconv = info->YuvToRgbCapabilities();
sl@0	4132	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, YUV Sampling Pattern bit:[0x%x]"),colorconv.iSamplingPatterns))
sl@0	4133	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, YUV Coefficient bit:[0x%x]"),colorconv.iCoefficients))
sl@0	4134	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, RGB Formats bit:[0x%x]"),colorconv.iRgbFormats))
sl@0	4135	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Lightness Control:[%d]"),colorconv.iLightnessControl))
sl@0	4136	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Saturation Control:[%d]"),colorconv.iSaturationControl))
sl@0	4137	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Contrast Control:[%d]"),colorconv.iContrastControl))
sl@0	4138	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Gamma Correction:[%d]"),colorconv.iGammaCorrection))
sl@0	4139
sl@0	4140	if(colorconv.iDitherTypes & EDitherNone)
sl@0	4141	{
sl@0	4142	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, No dither support")))
sl@0	4143	}
sl@0	4144	if(colorconv.iDitherTypes & EDitherOrdered)
sl@0	4145	{
sl@0	4146	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Ordered Dither")))
sl@0	4147	}
sl@0	4148	if(colorconv.iDitherTypes & EDitherErrorDiffusion)
sl@0	4149	{
sl@0	4150	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Error diffusion dither")))
sl@0	4151	}
sl@0	4152	if(colorconv.iDitherTypes & EDitherOther)
sl@0	4153	{
sl@0	4154	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Other hardware device specific dithering type")))
sl@0	4155	}
sl@0	4156
sl@0	4157
sl@0	4158	//HW Accelated
sl@0	4159	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, HW Accelerated:[%d]"),info->Accelerated()))
sl@0	4160
sl@0	4161	//Support Direct Screen
sl@0	4162	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Direct Screen:[%d]"),info->SupportsDirectDisplay()))
sl@0	4163
sl@0	4164	//Rotation
sl@0	4165	TUint rotation;
sl@0	4166	rotation = info->SupportedRotations();
sl@0	4167
sl@0	4168	if(rotation & 0x00000001)
sl@0	4169	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Rotation: 90Clockwise ")))
sl@0	4170	if(rotation & 0x00000002)
sl@0	4171	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Rotation: 90Anticlockwise ")))
sl@0	4172	if(rotation & 0x00000004)
sl@0	4173	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Rotation: 180 ")))
sl@0	4174	if(!(rotation & 0x00000007))
sl@0	4175	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, No Rotation supported ")))
sl@0	4176
sl@0	4177	//Arbitrary Scaling
sl@0	4178	TInt support = info->SupportsArbitraryScaling();
sl@0	4179	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Arbitrary Scaling:[%d]"),support))
sl@0	4180
sl@0	4181	//Scalling Factor
sl@0	4182	if ( support )
sl@0	4183	{
sl@0	4184	RArray<TScaleFactor> scale = info->SupportedScaleFactors();
sl@0	4185
sl@0	4186	for (TInt i=0; i<scale.Count(); i++)
sl@0	4187	{
sl@0	4188	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Scalling Factor:[%d]/[%d]"),scale.operator[](i).iScaleNum, scale.operator[](i).iScaleDenom))
sl@0	4189	}
sl@0	4190	}
sl@0	4191
sl@0	4192	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Support Anti Aliased filter:[%d]"),info->AntiAliasedScaling()))
sl@0	4193
sl@0	4194	CleanupStack::PopAndDestroy(info);
sl@0	4195
sl@0	4196	PRINT((_L("CVDecTestEngine::PostProcessorInfoL, Out") ))
sl@0	4197	}
sl@0	4198
sl@0	4199	/* ----------------------------------------------------------------------------
sl@0	4200	* Name: CVDecTestEngine::SupportsFormatL()
sl@0	4201	* Purpose: Retrieves information about an installed video decoder
sl@0	4202	* Parameters: None
sl@0	4203	* Return: None
sl@0	4204	* --------------------------------------------------------------------------*/
sl@0	4205
sl@0	4206	TInt CVDecTestEngine::SupportsFormatL(const TUid& aUid, const CCompressedVideoFormat& aFormat)
sl@0	4207	{
sl@0	4208	PRINT((_L("CVDecTestEngine::SupportsFormatL(),In")))
sl@0	4209
sl@0	4210	TInt supports = KErrNotSupported;
sl@0	4211
sl@0	4212	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4213	if(!info)
sl@0	4214	{
sl@0	4215	PRINT((_L("CVDecTestEngine::SupportsFormatL(),Error")))
sl@0	4216	return KErrGeneral;
sl@0	4217	}
sl@0	4218
sl@0	4219	if (info->SupportsFormat(aFormat))
sl@0	4220	{
sl@0	4221	PRINT((_L("CVDecTestEngine::SupportsFormatL, Supported format found")))
sl@0	4222	supports=KErrNone;
sl@0	4223	}
sl@0	4224
sl@0	4225	CleanupStack::PopAndDestroy();
sl@0	4226
sl@0	4227	PRINT((_L("CVDecTestEngine::SupportsFormatL(),Out")))
sl@0	4228	return supports;
sl@0	4229	}
sl@0	4230
sl@0	4231
sl@0	4232	/* ----------------------------------------------------------------------------
sl@0	4233	* Name: CVDecTestEngine::SupportsFormatInfoL()
sl@0	4234	* Purpose: Retrieves information about an installed video decoder
sl@0	4235	* Parameters: None
sl@0	4236	* Return: None
sl@0	4237	* --------------------------------------------------------------------------*/
sl@0	4238
sl@0	4239	TInt CVDecTestEngine::SupportsFormatInfoL(const TUid& aUid, const CCompressedVideoFormat& aFormat)
sl@0	4240	{
sl@0	4241	PRINT((_L("CVDecTestEngine::SupportsFormatInfoL(),In")))
sl@0	4242
sl@0	4243	TInt supports = KErrNotSupported;
sl@0	4244	RPointerArray<CCompressedVideoFormat> formats;
sl@0	4245
sl@0	4246	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4247	if(!info)
sl@0	4248	{
sl@0	4249	PRINT((_L("CVDecTestEngine::SupportsFormatInfoL(),Error")))
sl@0	4250	formats.Close();
sl@0	4251	return KErrGeneral;
sl@0	4252	}
sl@0	4253
sl@0	4254	formats = info->SupportedFormats();
sl@0	4255
sl@0	4256	PRINT((_L("CVDecTestEngine::SupportsFormatInfoL(), supported formats")))
sl@0	4257
sl@0	4258	for (TUint i = 0; i < formats.Count(); i++)
sl@0	4259	{
sl@0	4260	TBuf16<128> format;
sl@0	4261	format.Copy(formats[i]->MimeType());
sl@0	4262	PRINT((_L("CVDecTestEngine::SupportsFormatInfoL, Format [%S]"), &format))
sl@0	4263	//PRINT((_L("CVDecTestEngine::SupportsFormatInfoL, %d. Format [%S]"), &(formats[i]))
sl@0	4264	if (*(formats[i]) == aFormat)
sl@0	4265	{
sl@0	4266	supports = KErrNone;
sl@0	4267	PRINT((_L("CVDecTestEngine::SupportsFormatInfoL, Supported format found")))
sl@0	4268	}
sl@0	4269	}
sl@0	4270
sl@0	4271	CleanupStack::PopAndDestroy();
sl@0	4272
sl@0	4273	PRINT((_L("CVDecTestEngine::SupportsFormatInfoL(),Out")))
sl@0	4274	return supports;
sl@0	4275	}
sl@0	4276
sl@0	4277	/* ----------------------------------------------------------------------------
sl@0	4278	* Name: CVDecTestEngine::SupportsAccelerationL()
sl@0	4279	* Purpose: Retrieves information about an installed video decoder
sl@0	4280	* Parameters: None
sl@0	4281	* Return: None
sl@0	4282	* --------------------------------------------------------------------------*/
sl@0	4283
sl@0	4284	TInt CVDecTestEngine::SupportsAccelerationL(TInt aHwDev, const TUid& aUid)
sl@0	4285	{
sl@0	4286	PRINT((_L("CVDecTestEngine::SupportsAccelerationL(),In")))
sl@0	4287
sl@0	4288	TInt supports = KErrNotSupported;
sl@0	4289	TBool supported = EFalse;
sl@0	4290
sl@0	4291	if (aHwDev == EPostProcessor)
sl@0	4292	{
sl@0	4293	CPostProcessorInfo* info = iDevvp->PostProcessorInfoLC(aUid);
sl@0	4294	if(!info)
sl@0	4295	{
sl@0	4296	PRINT((_L("CVDecTestEngine::SupportsAccelerationL(),Error")))
sl@0	4297	return KErrGeneral;
sl@0	4298	}
sl@0	4299	supported = info->Accelerated();
sl@0	4300	}
sl@0	4301	else
sl@0	4302	{
sl@0	4303	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4304	if(!info)
sl@0	4305	{
sl@0	4306	PRINT((_L("CVDecTestEngine::SupportsAccelerationL(),Error")))
sl@0	4307	return KErrGeneral;
sl@0	4308	}
sl@0	4309
sl@0	4310	supported = info->Accelerated();
sl@0	4311	}
sl@0	4312
sl@0	4313	if (supported)
sl@0	4314	{
sl@0	4315	supports = KErrNone;
sl@0	4316	}
sl@0	4317
sl@0	4318	CleanupStack::PopAndDestroy();
sl@0	4319
sl@0	4320	PRINT((_L("CVDecTestEngine::SupportsAccelerationL(),Out")))
sl@0	4321	return supports;
sl@0	4322	}
sl@0	4323
sl@0	4324	/* ----------------------------------------------------------------------------
sl@0	4325	* Name: CVDecTestEngine::SupportsDirectDisplayL()
sl@0	4326	* Purpose: Retrieves information about an installed video decoder
sl@0	4327	* Parameters: None
sl@0	4328	* Return: None
sl@0	4329	* --------------------------------------------------------------------------*/
sl@0	4330
sl@0	4331	TInt CVDecTestEngine::SupportsDirectDisplayL(TInt aHwDev, const TUid& aUid)
sl@0	4332	{
sl@0	4333	PRINT((_L("CVDecTestEngine::SupportsDirectDisplayL(),In")))
sl@0	4334
sl@0	4335	TInt supports = KErrNotSupported;
sl@0	4336	TBool supported = EFalse;
sl@0	4337
sl@0	4338	if (aHwDev == EPostProcessor)
sl@0	4339	{
sl@0	4340	CPostProcessorInfo* info = iDevvp->PostProcessorInfoLC(aUid);
sl@0	4341	if(!info)
sl@0	4342	{
sl@0	4343	PRINT((_L("CVDecTestEngine::SupportsDirectDisplayL(),Error")))
sl@0	4344	return KErrGeneral;
sl@0	4345	}
sl@0	4346
sl@0	4347	supported = info->SupportsDirectDisplay();
sl@0	4348	}
sl@0	4349	else
sl@0	4350	{
sl@0	4351	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4352	if(!info)
sl@0	4353	{
sl@0	4354	PRINT((_L("CVDecTestEngine::SupportsDirectDisplayL(),Error")))
sl@0	4355	return KErrGeneral;
sl@0	4356	}
sl@0	4357
sl@0	4358	supported = info->SupportsDirectDisplay();
sl@0	4359	}
sl@0	4360
sl@0	4361	if (supported)
sl@0	4362	{
sl@0	4363	supports = KErrNone;
sl@0	4364	}
sl@0	4365
sl@0	4366	CleanupStack::PopAndDestroy();
sl@0	4367
sl@0	4368	PRINT((_L("CVDecTestEngine::SupportsDirectDisplayL(),Out")))
sl@0	4369	return supports;
sl@0	4370	}
sl@0	4371
sl@0	4372
sl@0	4373	/* ----------------------------------------------------------------------------
sl@0	4374	* Name: CVDecTestEngine::SupportsMaxPictureSizeL()
sl@0	4375	* Purpose: Retrieves information about an installed video decoder
sl@0	4376	* Parameters: None
sl@0	4377	* Return: None
sl@0	4378	* --------------------------------------------------------------------------*/
sl@0	4379
sl@0	4380	TInt CVDecTestEngine::SupportsMaxPictureSizeL(const TUid& aUid, TSize aSize)
sl@0	4381	{
sl@0	4382	PRINT((_L("CVDecTestEngine::SupportsMaxPictureSizeL(),In")))
sl@0	4383
sl@0	4384	TInt supports = KErrNotSupported;
sl@0	4385
sl@0	4386	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4387	if(!info)
sl@0	4388	{
sl@0	4389	PRINT((_L("CVDecTestEngine::SupportsMaxPictureSizeL(),Error")))
sl@0	4390	return KErrGeneral;
sl@0	4391	}
sl@0	4392
sl@0	4393	TSize size = info->MaxPictureSize();
sl@0	4394
sl@0	4395	if (size.iWidth >= aSize.iWidth && size.iHeight >= aSize.iHeight)
sl@0	4396	{
sl@0	4397	supports = KErrNone;
sl@0	4398	}
sl@0	4399
sl@0	4400	CleanupStack::PopAndDestroy();
sl@0	4401
sl@0	4402	PRINT((_L("CVDecTestEngine::SupportsMaxPictureSizeL(),Out")))
sl@0	4403	return supports;
sl@0	4404	}
sl@0	4405
sl@0	4406	/* ----------------------------------------------------------------------------
sl@0	4407	* Name: CVDecTestEngine::SupportsMaxPictureRateL()
sl@0	4408	* Purpose: Retrieves information about an installed video decoder
sl@0	4409	* Parameters: None
sl@0	4410	* Return: None
sl@0	4411	* --------------------------------------------------------------------------*/
sl@0	4412
sl@0	4413	TInt CVDecTestEngine::SupportsMaxPictureRateL(const TUid& aUid, TPictureRateAndSize& aRateAndSize)
sl@0	4414	{
sl@0	4415	PRINT((_L("CVDecTestEngine::SupportsMaxPictureRateL(),In")))
sl@0	4416
sl@0	4417	TInt supports = KErrNotSupported;
sl@0	4418	TPictureRateAndSize picRateAndSize;
sl@0	4419
sl@0	4420	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4421	if(!info)
sl@0	4422	{
sl@0	4423	PRINT((_L("CVEncTestEngine::SupportsMaxPictureRateL(),Error")))
sl@0	4424	return KErrGeneral;
sl@0	4425	}
sl@0	4426
sl@0	4427	RArray<TPictureRateAndSize> picRateAndSizeArray = info->MaxPictureRates();
sl@0	4428
sl@0	4429	for (TUint i=0; i < picRateAndSizeArray.Count(); i++)
sl@0	4430	{
sl@0	4431	picRateAndSize = picRateAndSizeArray[i];
sl@0	4432	if (aRateAndSize.iPictureRate <= picRateAndSize.iPictureRate && aRateAndSize.iPictureSize.iWidth <= picRateAndSize.iPictureSize.iWidth &&
sl@0	4433	aRateAndSize.iPictureSize.iHeight <= picRateAndSize.iPictureSize.iHeight)
sl@0	4434	{
sl@0	4435	supports = KErrNone;
sl@0	4436	}
sl@0	4437	}
sl@0	4438
sl@0	4439	CleanupStack::PopAndDestroy();
sl@0	4440
sl@0	4441	PRINT((_L("CVDecTestEngine::SupportsMaxPictureRateL(),Out")))
sl@0	4442	return supports;
sl@0	4443	}
sl@0	4444
sl@0	4445
sl@0	4446	/* ----------------------------------------------------------------------------
sl@0	4447	* Name: CVDecTestEngine::SupportsSliceLossL()
sl@0	4448	* Purpose: Retrieves information about an installed video decoder
sl@0	4449	* Parameters: None
sl@0	4450	* Return: None
sl@0	4451	* --------------------------------------------------------------------------*/
sl@0	4452
sl@0	4453	TInt CVDecTestEngine::SupportsSliceLossL(const TUid& aUid)
sl@0	4454	{
sl@0	4455	PRINT((_L("CVDecTestEngine::SupportsSliceLossL(),In")))
sl@0	4456
sl@0	4457	TInt supports = KErrNotSupported;
sl@0	4458	TBool supported = EFalse;
sl@0	4459
sl@0	4460	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4461	if(!info)
sl@0	4462	{
sl@0	4463	PRINT((_L("CVDecTestEngine::SupportsSliceLossL(),Error")))
sl@0	4464	return KErrGeneral;
sl@0	4465	}
sl@0	4466
sl@0	4467	supported = info->SupportsSliceLoss();
sl@0	4468
sl@0	4469	if (supported)
sl@0	4470	{
sl@0	4471	supports = KErrNone;
sl@0	4472	}
sl@0	4473
sl@0	4474	CleanupStack::PopAndDestroy();
sl@0	4475
sl@0	4476	PRINT((_L("CVDecTestEngine::SupportsSliceLossL(),Out")))
sl@0	4477	return supports;
sl@0	4478	}
sl@0	4479
sl@0	4480	/* ----------------------------------------------------------------------------
sl@0	4481	* Name: CVDecTestEngine::SupportsPictureLossL()
sl@0	4482	* Purpose: Retrieves information about an installed video decoder
sl@0	4483	* Parameters: None
sl@0	4484	* Return: None
sl@0	4485	* --------------------------------------------------------------------------*/
sl@0	4486
sl@0	4487	TInt CVDecTestEngine::SupportsPictureLossL(const TUid& aUid)
sl@0	4488	{
sl@0	4489	PRINT((_L("CVDecTestEngine::SupportsPictureLossL(),In")))
sl@0	4490
sl@0	4491	TInt supports = KErrNotSupported;
sl@0	4492	TBool supported = EFalse;
sl@0	4493
sl@0	4494	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4495	if(!info)
sl@0	4496	{
sl@0	4497	PRINT((_L("CVDecTestEngine::SupportsPictureLossL(),Error")))
sl@0	4498	return KErrGeneral;
sl@0	4499	}
sl@0	4500
sl@0	4501	supported = info->SupportsPictureLoss();
sl@0	4502
sl@0	4503	if (supported)
sl@0	4504	{
sl@0	4505	supports = KErrNone;
sl@0	4506	}
sl@0	4507
sl@0	4508	CleanupStack::PopAndDestroy();
sl@0	4509
sl@0	4510	PRINT((_L("CVDecTestEngine::SupportsPictureLossL(),Out")))
sl@0	4511	return supports;
sl@0	4512	}
sl@0	4513
sl@0	4514
sl@0	4515	/* ----------------------------------------------------------------------------
sl@0	4516	* Name: CVDecTestEngine::SupportsMaxBitrateL()
sl@0	4517	* Purpose: Retrieves information about an installed video encoder
sl@0	4518	* Parameters: None
sl@0	4519	* Return: None
sl@0	4520	* --------------------------------------------------------------------------*/
sl@0	4521
sl@0	4522	TInt CVDecTestEngine::SupportsMaxBitrateL(const TUid& aUid, TInt aBitrate)
sl@0	4523	{
sl@0	4524	PRINT((_L("CVDecTestEngine::SupportsMaxBitrateL(),In")))
sl@0	4525
sl@0	4526	TInt supports = KErrNotSupported;
sl@0	4527	TInt bitrate = 0;
sl@0	4528
sl@0	4529	CVideoDecoderInfo* info = iDevvp->VideoDecoderInfoLC(aUid);
sl@0	4530	if(!info)
sl@0	4531	{
sl@0	4532	PRINT((_L("CVDecTestEngine::SupportsMaxBitrateL(),Error")))
sl@0	4533	return KErrGeneral;
sl@0	4534	}
sl@0	4535
sl@0	4536	bitrate = info->MaxBitrate();
sl@0	4537
sl@0	4538	if (aBitrate <= bitrate)
sl@0	4539	{
sl@0	4540	supports = KErrNone;
sl@0	4541	}
sl@0	4542
sl@0	4543	CleanupStack::PopAndDestroy();
sl@0	4544
sl@0	4545	PRINT((_L("CVDecTestEngine::SupportsMaxBitrateL(),Out")))
sl@0	4546	return supports;
sl@0	4547	}
sl@0	4548
sl@0	4549
sl@0	4550	/* ----------------------------------------------------------------------------
sl@0	4551	* Name: CVDecTestEngine::SetYuvToRgbOptionsL()
sl@0	4552	* Purpose:
sl@0	4553	* Note:
sl@0	4554	* Parameters: None
sl@0	4555	* Return: None
sl@0	4556	* --------------------------------------------------------------------------*/
sl@0	4557	void CVDecTestEngine::SetYuvToRgbOptionsL(TInt aHWDevice, const TYuvToRgbOptions& aOptions, const TYuvFormat& aYuvFormat, TRgbFormat aRgbFormat)
sl@0	4558	{
sl@0	4559	PRINT((_L("CVDecTestEngine::SetYuvToRgbOptionsL, In") ))
sl@0	4560
sl@0	4561	if (aHWDevice == EPostProcessor)
sl@0	4562	{
sl@0	4563	iDevvp->SetYuvToRgbOptionsL(iPostProcId, aOptions, aYuvFormat, aRgbFormat);
sl@0	4564	}
sl@0	4565	else
sl@0	4566	{
sl@0	4567	iDevvp->SetYuvToRgbOptionsL(iDecHWDevId, aOptions, aYuvFormat, aRgbFormat);
sl@0	4568	}
sl@0	4569
sl@0	4570	PRINT((_L("CVDecTestEngine::SetYuvToRgbOptionsL, Out") ))
sl@0	4571	}
sl@0	4572
sl@0	4573	/* ----------------------------------------------------------------------------
sl@0	4574	* Name: CVDecTestEngine::SetSlowClient()
sl@0	4575	* Purpose:
sl@0	4576	* Note:
sl@0	4577	* Parameters: None
sl@0	4578	* Return: None
sl@0	4579	* --------------------------------------------------------------------------*/
sl@0	4580	void CVDecTestEngine::SetSlowClient(TBool aOption)
sl@0	4581	{
sl@0	4582	PRINT((_L("CVDecTestEngine::SetSlowClient, In") ))
sl@0	4583
sl@0	4584	iSetSlowClient = aOption;
sl@0	4585
sl@0	4586	PRINT((_L("CVDecTestEngine::SetSlowClient, Out") ))
sl@0	4587	}
sl@0	4588
sl@0	4589	/* ----------------------------------------------------------------------------
sl@0	4590	* Name: CVDecTestEngine::SetFastClient()
sl@0	4591	* Purpose:
sl@0	4592	* Note:
sl@0	4593	* Parameters: None
sl@0	4594	* Return: None
sl@0	4595	* --------------------------------------------------------------------------*/
sl@0	4596	void CVDecTestEngine::SetFastClient(TBool aOption)
sl@0	4597	{
sl@0	4598	PRINT((_L("CVDecTestEngine::SetFastClient, In") ))
sl@0	4599
sl@0	4600	iSetFastClient = aOption;
sl@0	4601
sl@0	4602	PRINT((_L("CVDecTestEngine::SetFastClient, Out") ))
sl@0	4603	}
sl@0	4604
sl@0	4605	/* ----------------------------------------------------------------------------
sl@0	4606	* Name: CVDecTestEngine::SetAUFormat()
sl@0	4607	* Purpose:
sl@0	4608	* Note:
sl@0	4609	* Parameters: None
sl@0	4610	* Return: None
sl@0	4611	* --------------------------------------------------------------------------*/
sl@0	4612	TInt CVDecTestEngine::SetAUFormat()
sl@0	4613	{
sl@0	4614	PRINT((_L("CVDecTestEngine::SetAUFormat, In") ))
sl@0	4615
sl@0	4616	if (iCodecType== EAVC)
sl@0	4617	{
sl@0	4618	iSetAUFormat = ETrue;
sl@0	4619
sl@0	4620	}
sl@0	4621	else
sl@0	4622	{
sl@0	4623	return KErrNotSupported;
sl@0	4624	}
sl@0	4625
sl@0	4626	PRINT((_L("CVDecTestEngine::SetAUFormat, Out") ))
sl@0	4627
sl@0	4628	return KErrNone;
sl@0	4629	}
sl@0	4630
sl@0	4631	/* ----------------------------------------------------------------------------
sl@0	4632	* Name: CVDecTestEngine::MoveFileL()
sl@0	4633	* Purpose:
sl@0	4634	* Note:
sl@0	4635	* Parameters: None
sl@0	4636	* Return: None
sl@0	4637	* --------------------------------------------------------------------------*/
sl@0	4638	TInt CVDecTestEngine::MoveFileL(const TDesC &anOld, const TDesC &aNew)
sl@0	4639	{
sl@0	4640	PRINT((_L("CVDecTestEngine::MoveFileL, In") ))
sl@0	4641
sl@0	4642	CFileMan* fileman = CFileMan::NewL(iFs);
sl@0	4643	iMemAlloc++;
sl@0	4644	#ifdef __MEM_CHECK_
sl@0	4645	PRINT((_L("CVDecTestEngine::MoveFileL, mem alloc, fileman") ))
sl@0	4646	#endif
sl@0	4647	PRINT((_L("CVDecTestEngine::MoveFileL, fileman [%x]"), fileman))
sl@0	4648
sl@0	4649	CloseFile();
sl@0	4650
sl@0	4651	PRINT((_L("CVDecTestEngine::MoveFileL, File [%s] moving to [%s]"), &anOld, &aNew ))
sl@0	4652	fileman->Move(anOld, aNew);
sl@0	4653
sl@0	4654	PRINT((_L("CVDecTestEngine::MoveFileL, File [%s] moved to [%s]"), &anOld, &aNew ))
sl@0	4655
sl@0	4656	delete fileman;
sl@0	4657	iMemDelete++;
sl@0	4658	#ifdef __MEM_CHECK_
sl@0	4659	PRINT((_L("CVDecTestEngine::MoveFileL, mem del, fileman") ))
sl@0	4660	#endif
sl@0	4661	PRINT((_L("CVDecTestEngine::MoveFileL, Out") ))
sl@0	4662
sl@0	4663	return KErrNone;
sl@0	4664	}
sl@0	4665
sl@0	4666	/* ----------------------------------------------------------------------------
sl@0	4667	* Name: CVDecTestEngine::CopyFileL()
sl@0	4668	* Purpose:
sl@0	4669	* Note:
sl@0	4670	* Parameters: None
sl@0	4671	* Return: None
sl@0	4672	* --------------------------------------------------------------------------*/
sl@0	4673	TInt CVDecTestEngine::CopyFileL(const TDesC &anOld, const TDesC &aNew)
sl@0	4674	{
sl@0	4675	PRINT((_L("CVDecTestEngine::CopyFileL, In") ))
sl@0	4676
sl@0	4677	CFileMan* fileman = CFileMan::NewL(iFs);
sl@0	4678	iMemAlloc++;
sl@0	4679	#ifdef __MEM_CHECK_
sl@0	4680	PRINT((_L("CVDecTestEngine::MoveFileL, mem alloc, fileman") ))
sl@0	4681	#endif
sl@0	4682	PRINT((_L("CVDecTestEngine::CopyFileL, fileman [%x]"), fileman))
sl@0	4683
sl@0	4684	//CloseFile();
sl@0	4685
sl@0	4686	PRINT((_L("CVDecTestEngine::CopyFileL, File [%s] copying to [%s]"), &anOld, &aNew ))
sl@0	4687	fileman->Copy(anOld, aNew);
sl@0	4688
sl@0	4689	PRINT((_L("CVDecTestEngine::CopyFileL, File [%s] copied to [%s]"), &anOld, &aNew ))
sl@0	4690
sl@0	4691	delete fileman;
sl@0	4692	iMemDelete++;
sl@0	4693	#ifdef __MEM_CHECK_
sl@0	4694	PRINT((_L("CVDecTestEngine::CopyFileL, mem del, fileman") ))
sl@0	4695	#endif
sl@0	4696	PRINT((_L("CVDecTestEngine::CopyFileL, Out") ))
sl@0	4697
sl@0	4698	return KErrNone;
sl@0	4699	}
sl@0	4700
sl@0	4701	/* ----------------------------------------------------------------------------
sl@0	4702	* Name: CVDecTestEngine::HandleNewBufferL()
sl@0	4703	* Purpose: Get Next input data
sl@0	4704	* Note:
sl@0	4705	* Parameters: None
sl@0	4706	* Return: None
sl@0	4707	* --------------------------------------------------------------------------*/
sl@0	4708
sl@0	4709
sl@0	4710	void CVDecTestEngine::HandleNewBufferL()
sl@0	4711	{
sl@0	4712
sl@0	4713	if ( iState == ERunning && !iInputEnd )
sl@0	4714	{
sl@0	4715	if ( iDecHWDevId \|\| iCIBuffMgmtOn ) //Retrieve buffer from Hwdevice
sl@0	4716	{
sl@0	4717	GetInputBufferL();
sl@0	4718	}
sl@0	4719	else
sl@0	4720	{
sl@0	4721	FillAndSendBufferL(); // Postproc input
sl@0	4722	}
sl@0	4723
sl@0	4724	}
sl@0	4725	else
sl@0	4726	{
sl@0	4727	PRINT((_L("CVDecTestEngine::HandleNewBufferL, inputEnd found") ))
sl@0	4728	if (iLastFrame)
sl@0	4729	{
sl@0	4730	PRINT((_L("CVDecTestEngine::HandleNewBufferL, Getting last input buffer") ))
sl@0	4731	GetInputBufferL();
sl@0	4732	}
sl@0	4733	}
sl@0	4734
sl@0	4735	}
sl@0	4736
sl@0	4737	/* ----------------------------------------------------------------------------
sl@0	4738	* Name: CVDecTestEngine::LoadNextFrameL()
sl@0	4739	* Purpose:
sl@0	4740	* Note:
sl@0	4741	* Parameters: None
sl@0	4742	* Return: None
sl@0	4743	* --------------------------------------------------------------------------*/
sl@0	4744
sl@0	4745	TInt CVDecTestEngine::LoadNextFrameL(TVideoInputBuffer* aCodedInBuffer)
sl@0	4746	{
sl@0	4747	// Normal VC1 video reading
sl@0	4748	// Read file after the file header
sl@0	4749	PRINT((_L("CVDecTestEngine::LoadNextFrameL, In")));
sl@0	4750	unsigned int frameDataSize = 4; //4 Bytes to obain the framesize
sl@0	4751	unsigned int frameSize=0;
sl@0	4752	unsigned int Timestamp;
sl@0	4753	TInt err = 0;
sl@0	4754	TUint8* ptr = new (ELeave) TUint8[frameDataSize]; // dynamic alloc 1
sl@0	4755	iMemAlloc++;
sl@0	4756	#ifdef __MEM_CHECK_
sl@0	4757	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem alloc, ptr") ))
sl@0	4758	#endif
sl@0	4759	TPtr8 frameData(ptr, frameDataSize);
sl@0	4760	if ( (err = iInFile.Read(frameData, frameDataSize)) != KErrNone)
sl@0	4761	{
sl@0	4762	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Error reading file") ))
sl@0	4763	delete ptr;
sl@0	4764	ptr = NULL;
sl@0	4765	iMemDelete++;
sl@0	4766	#ifdef __MEM_CHECK_
sl@0	4767	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem del, ptr") ))
sl@0	4768	#endif
sl@0	4769
sl@0	4770	return err;
sl@0	4771	}
sl@0	4772
sl@0	4773	if (frameData.Length() < 4)
sl@0	4774	{
sl@0	4775	PRINT((_L("CVDecTestEngine::LoadNextFrameL, File end found") ))
sl@0	4776	aCodedInBuffer->iData.SetLength( 0 );
sl@0	4777	iInputEnd = ETrue;
sl@0	4778	delete ptr;
sl@0	4779	ptr = NULL;
sl@0	4780	iMemDelete++;
sl@0	4781	#ifdef __MEM_CHECK_
sl@0	4782	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem del, ptr") ))
sl@0	4783	#endif
sl@0	4784	return KErrNone;
sl@0	4785	}
sl@0	4786
sl@0	4787	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Reading Item") ))
sl@0	4788	ReadItemLE(ptr, 4, (TUint8 *)&frameSize);
sl@0	4789	PRINT((_L("CVDecTestEngine::LoadNextFrameL, before AND frameSize: %x"), frameSize ))
sl@0	4790
sl@0	4791	if (frameData.Length() < 4)
sl@0	4792	{
sl@0	4793	PRINT((_L("CVDecTestEngine::LoadNextFrameL, File end found") ))
sl@0	4794	iInputEnd = ETrue;
sl@0	4795	delete ptr;
sl@0	4796	ptr = NULL;
sl@0	4797	iMemDelete++;
sl@0	4798	#ifdef __MEM_CHECK_
sl@0	4799	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem del, ptr") ))
sl@0	4800	#endif
sl@0	4801	return KErrNone;
sl@0	4802	}
sl@0	4803
sl@0	4804	//RCV_V2_FRAMESIZE_FLAGS
sl@0	4805	frameSize = frameSize & ~(0xff000000);
sl@0	4806
sl@0	4807	PRINT((_L("CVDecTestEngine::LoadNextFrameL, frameSize: %d"), frameSize ))
sl@0	4808
sl@0	4809	//Now obtain the Timestamp of the frame
sl@0	4810	if ( (err = iInFile.Read(frameData, frameDataSize)) != KErrNone)
sl@0	4811	{
sl@0	4812	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Error reading file %d"), err ))
sl@0	4813	return err;
sl@0	4814	}
sl@0	4815
sl@0	4816	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Reading Item2") ))
sl@0	4817	ReadItemLE(ptr, 4, (TUint8 *)&Timestamp);
sl@0	4818	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Timestamp: %d"), Timestamp ))
sl@0	4819
sl@0	4820	delete ptr;
sl@0	4821	ptr = NULL;
sl@0	4822	iMemDelete++;
sl@0	4823	#ifdef __MEM_CHECK_
sl@0	4824	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem del, ptr") ))
sl@0	4825	#endif
sl@0	4826
sl@0	4827	if (frameSize != 0)
sl@0	4828	{
sl@0	4829
sl@0	4830	tempFrame += frameSize + 8;
sl@0	4831	PRINT((_L("CVDecTestEngine::LoadNextFrameL, tota data %d"), tempFrame ))
sl@0	4832	PRINT((_L("CVDecTestEngine::LoadNextFrameL, frame"), iFrame))
sl@0	4833
sl@0	4834	TInt currentPos = 0;
sl@0	4835	iInFile.Seek(ESeekCurrent, currentPos );
sl@0	4836	PRINT((_L("CVDecTestEngine::LoadNextFrameL, currentPos %d"), currentPos ))
sl@0	4837	currentPos = 0;
sl@0	4838
sl@0	4839	//Send metadata in the first frame
sl@0	4840	if (iFrame==0)
sl@0	4841	{
sl@0	4842	TInt pos = 0;
sl@0	4843	//err = iInFile.Seek(ESeekCurrent,pos);
sl@0	4844	err = iInFile.Seek(ESeekStart,pos);
sl@0	4845	// pos -= 44; //header (36) and framesize+timestamp (8)
sl@0	4846	// err = iInFile.Seek(ESeekCurrent,pos);
sl@0	4847	PRINT((_L("CVDecTestEngine::LoadNextFrameL, first frame")))
sl@0	4848	if ( (err = iInFile.Read(aCodedInBuffer->iData, frameSize+44)) != KErrNone)
sl@0	4849	{
sl@0	4850	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Error reading file %d"), err ))
sl@0	4851	return err;
sl@0	4852	}
sl@0	4853
sl@0	4854	TUint8* ptr2 = new(ELeave)TUint8[4]; // dynamic alloc 2
sl@0	4855	iMemAlloc++;
sl@0	4856	#ifdef __MEM_CHECK_
sl@0	4857	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem alloc, ptr2") ))
sl@0	4858	#endif
sl@0	4859	Mem::FillZ(ptr2,4);
sl@0	4860	TPtr8 firstPtr(ptr2,4,4);
sl@0	4861	// aCodedInBuffer->iData.Insert(35,firstPtr);
sl@0	4862	PRINT((_L("CVDecTestEngine::LoadNextFrameL, frame1"), iFrame))
sl@0	4863	TUint8* ptr = new ( ELeave ) TUint8[8]; // dynamic alloc 3
sl@0	4864	iMemAlloc++;
sl@0	4865	#ifdef __MEM_CHECK_
sl@0	4866	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem alloc, ptr") ))
sl@0	4867	#endif
sl@0	4868
sl@0	4869	Mem::FillZ( ptr, 8 );
sl@0	4870	ptr[0] = 1;
sl@0	4871	ptr[4] = 44;
sl@0	4872	TPtr8 anotherPtr(ptr, 8, 8);
sl@0	4873	aCodedInBuffer->iData.Insert(0, anotherPtr );
sl@0	4874	delete ptr2;
sl@0	4875	ptr2 = NULL;
sl@0	4876	delete ptr;
sl@0	4877	ptr = NULL;
sl@0	4878	iMemDelete += 2;
sl@0	4879	#ifdef __MEM_CHECK_
sl@0	4880	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem del, ptr2 & ptr") ))
sl@0	4881	#endif
sl@0	4882	}
sl@0	4883	else
sl@0	4884	{
sl@0	4885	PRINT((_L("CVDecTestEngine::LoadNextFrameL, iFrame num != 0: %d"), iFrame ))
sl@0	4886	TInt pos = -8;
sl@0	4887
sl@0	4888	err = iInFile.Seek(ESeekCurrent, pos);
sl@0	4889	PRINT((_L("CVDecTestEngine::LoadNextFrameL, read file: %d"), err ))
sl@0	4890	if ( (err = iInFile.Read(aCodedInBuffer->iData, frameSize+8)) != KErrNone)
sl@0	4891	{
sl@0	4892	PRINT((_L("CVDecTestEngine::LoadNextFrameL, Error reading file %d"), err ))
sl@0	4893	return err;
sl@0	4894	}
sl@0	4895
sl@0	4896	TUint8* ptr2 = new(ELeave)TUint8[4]; // dynamic alloc 4
sl@0	4897	iMemAlloc++;
sl@0	4898	#ifdef __MEM_CHECK_
sl@0	4899	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem alloc, ptr2") ))
sl@0	4900	#endif
sl@0	4901	Mem::FillZ(ptr2,4);
sl@0	4902	TPtr8 firstPtr(ptr2,4,4);
sl@0	4903	// aCodedInBuffer->iData.Insert(0, firstPtr);
sl@0	4904	delete ptr2;
sl@0	4905	iMemDelete++;
sl@0	4906	#ifdef __MEM_CHECK_
sl@0	4907	PRINT((_L("CVDecTestEngine::LoadNextFrameL, mem del, ptr2") ))
sl@0	4908	#endif
sl@0	4909	}
sl@0	4910
sl@0	4911	TInt substreamID = 0;
sl@0	4912	if(aCodedInBuffer->iUser != NULL){
sl@0	4913	((TInt)aCodedInBuffer->iUser) = substreamID;
sl@0	4914	}
sl@0	4915	iInFile.Seek(ESeekCurrent, currentPos );
sl@0	4916	PRINT((_L("CVDecTestEngine::LoadNextFrameL, currentPos %d"), currentPos ))
sl@0	4917	currentPos = 0;
sl@0	4918
sl@0	4919	aCodedInBuffer->iSequenceNumber = iFrame;
sl@0	4920	aCodedInBuffer->iOptions = TVideoInputBuffer::EPresentationTimestamp;
sl@0	4921
sl@0	4922	aCodedInBuffer->iPresentationTimestamp = Timestamp;
sl@0	4923	iTimeToPlay = aCodedInBuffer->iPresentationTimestamp ;
sl@0	4924
sl@0	4925
sl@0	4926	aCodedInBuffer->iDecodingTimestamp = Timestamp;
sl@0	4927	iPresentationTimestamp = aCodedInBuffer->iPresentationTimestamp ;
sl@0	4928
sl@0	4929
sl@0	4930
sl@0	4931	}
sl@0	4932	iFrame++;
sl@0	4933	PRINT(_L("CVDecTestEngine::LoadNextFrameL.. Out"));
sl@0	4934	return frameSize;
sl@0	4935	}
sl@0	4936
sl@0	4937
sl@0	4938	/* ----------------------------------------------------------------------------
sl@0	4939	* Name: CVDecTestEngine::ReadItemLE()
sl@0	4940	* Purpose:
sl@0	4941	* Note:
sl@0	4942	* Parameters: None
sl@0	4943	* Return: None
sl@0	4944	* --------------------------------------------------------------------------*/
sl@0	4945	//Currently Supporting only upto 4Bytes
sl@0	4946	TBool CVDecTestEngine::ReadItemLE(unsigned char *readBuffer, int Size,
sl@0	4947	unsigned char* pItem)
sl@0	4948	{
sl@0	4949	PRINT((_L("CVDecTestEngine::ReadItemLE, In")));
sl@0	4950	unsigned int High=0, Low=0;
sl@0	4951	unsigned char m_char;
sl@0	4952	int shift = 0;
sl@0	4953	int numbytes = Size;
sl@0	4954	int i=0;
sl@0	4955
sl@0	4956	/* Read a little-endian file value into a variable, regardless of host endianness */
sl@0	4957	while (numbytes-- >0)
sl@0	4958	{
sl@0	4959	m_char = readBuffer[i++];
sl@0	4960
sl@0	4961	if (shift >= 32)
sl@0	4962	{
sl@0	4963	High \|= m_char << (shift-32);
sl@0	4964	}
sl@0	4965	else
sl@0	4966	{
sl@0	4967	Low \|= m_char << shift;
sl@0	4968	}
sl@0	4969	shift += 8;
sl@0	4970	}
sl@0	4971
sl@0	4972	switch (Size)
sl@0	4973	{
sl@0	4974	case 1:
sl@0	4975	*pItem = (unsigned char)Low;
sl@0	4976	break;
sl@0	4977
sl@0	4978	case 2:
sl@0	4979	(unsigned short )pItem = (unsigned short)Low;
sl@0	4980	break;
sl@0	4981
sl@0	4982	case 4:
sl@0	4983	(unsigned int )pItem = (unsigned int)Low;
sl@0	4984	break;
sl@0	4985
sl@0	4986	default:
sl@0	4987	//WARN("Unknown size (%d) item read requested",Size);
sl@0	4988	//return false;
sl@0	4989	return EFalse;
sl@0	4990	}
sl@0	4991
sl@0	4992	PRINT((_L("CVDecTestEngine::ReadItemLE, Out")));
sl@0	4993	return TRUE;
sl@0	4994	}
sl@0	4995
sl@0	4996	/* ----------------------------------------------------------------------------
sl@0	4997	* Name: CVDecTestEngine::GoBackInFile()
sl@0	4998	* Purpose:
sl@0	4999	* Note:
sl@0	5000	* Parameters: None
sl@0	5001	* Return: None
sl@0	5002	* --------------------------------------------------------------------------*/
sl@0	5003	void CVDecTestEngine::GoBackInFile(TUint aBytes)
sl@0	5004	{
sl@0	5005	PRINT((_L("CVDecTestEngine::GoBackInFile, In")));
sl@0	5006
sl@0	5007	//If read pointer is in the end of the buffer change it in the beginning
sl@0	5008	if (iReadDataChunk - iDataChunk >= aBytes)
sl@0	5009	{
sl@0	5010	iReadDataChunk -= aBytes;
sl@0	5011	}
sl@0	5012	else
sl@0	5013	{
sl@0	5014	TInt endBytes = aBytes - (iReadDataChunk - iDataChunk);
sl@0	5015	iReadDataChunk = iDataChunk+iDataChunkSize-endBytes;
sl@0	5016	}
sl@0	5017
sl@0	5018	PRINT((_L("CVDecTestEngine::GoBackInFile, Out, ")));
sl@0	5019	}
sl@0	5020
sl@0	5021
sl@0	5022
sl@0	5023	/* ----------------------------------------------------------------------------
sl@0	5024	* Name: CVDecTestEngine::ReadByteFromFile()
sl@0	5025	* Purpose:
sl@0	5026	* Note:
sl@0	5027	* Parameters: None
sl@0	5028	* Return: None
sl@0	5029	* --------------------------------------------------------------------------*/
sl@0	5030	TUint8 CVDecTestEngine::ReadByteFromFile()
sl@0	5031	{
sl@0	5032	//PRINT((_L("CVDecTestEngine::ReadByteFromFile, In")));
sl@0	5033	if (iDataReadFromFile == 0)
sl@0	5034	{
sl@0	5035	TInt err = CheckAndFillDataChunk();
sl@0	5036	if (err )
sl@0	5037	{
sl@0	5038	PRINT((_L("CVDecTestEngine::ReadByteFromFile, ERROR [%d]"), err));
sl@0	5039	return 0;
sl@0	5040	}
sl@0	5041	}
sl@0	5042
sl@0	5043	if (iReadDataChunk >= iDataChunk+iDataChunkSize)
sl@0	5044	{
sl@0	5045	iReadDataChunk = iDataChunk;
sl@0	5046	}
sl@0	5047
sl@0	5048	if (iEndOfData && iReadDataChunk == iWriteDataChunk && iDataReadFromFile != 0)
sl@0	5049	{
sl@0	5050	PRINT((_L("CVDecTestEngine::ReadByteFromFile, Input End found")));
sl@0	5051	iInputEnd = ETrue;
sl@0	5052	TUint8 value = 0;
sl@0	5053	return value;
sl@0	5054	}
sl@0	5055
sl@0	5056
sl@0	5057	TUint8 byte = iReadDataChunk[0];
sl@0	5058	iReadDataChunk++;
sl@0	5059	return byte;
sl@0	5060
sl@0	5061	}
sl@0	5062
sl@0	5063
sl@0	5064	/* ----------------------------------------------------------------------------
sl@0	5065	* Name: CVDecTestEngine::ReadDataToBuffer()
sl@0	5066	* Purpose:
sl@0	5067	* Note:
sl@0	5068	* Parameters: None
sl@0	5069	* Return: None
sl@0	5070	* --------------------------------------------------------------------------*/
sl@0	5071	void CVDecTestEngine::ReadDataToBuffer(TVideoInputBuffer* aCodedInBuffer, TInt aSize, TBool aDiscard)
sl@0	5072	{
sl@0	5073	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, In")));
sl@0	5074	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, iWriteDataChunk [%x]"), iWriteDataChunk));
sl@0	5075	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, iReadDataChunk [%x]"), iReadDataChunk));
sl@0	5076	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, iDataChunk [%x]"), iDataChunk));
sl@0	5077	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, size [%d]"), aSize));
sl@0	5078
sl@0	5079
sl@0	5080
sl@0	5081	TInt err = CheckAndFillDataChunk();
sl@0	5082	if (err )
sl@0	5083	{
sl@0	5084	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, ERROR [%d]"), err));
sl@0	5085	return;
sl@0	5086	}
sl@0	5087
sl@0	5088	aCodedInBuffer->iData.Zero();
sl@0	5089
sl@0	5090	if (iEndOfData)
sl@0	5091	{
sl@0	5092	if (iReadDataChunk == iWriteDataChunk && iDataReadFromFile != 0)
sl@0	5093	{
sl@0	5094	PRINT((_L("CVDecTestEngine::ReadByteFromFile, Input End found")));
sl@0	5095	iInputEnd = ETrue;
sl@0	5096	return;
sl@0	5097	}
sl@0	5098
sl@0	5099	if (iReadDataChunk+aSize > iWriteDataChunk && iReadDataChunk < iWriteDataChunk)
sl@0	5100	{
sl@0	5101	PRINT((_L("CVDecTestEngine::ReadByteFromFile, Input End found")));
sl@0	5102	if (!aDiscard)
sl@0	5103	{
sl@0	5104	aCodedInBuffer->iData.Append(iReadDataChunk, (iWriteDataChunk-iReadDataChunk));
sl@0	5105	}
sl@0	5106	iReadDataChunk += aSize;
sl@0	5107	iInputEnd = ETrue;
sl@0	5108	return;
sl@0	5109	}
sl@0	5110	else if (iReadDataChunk+aSize > iDataChunk+iDataChunkSize && iReadDataChunk > iWriteDataChunk &&
sl@0	5111	iDataChunk+aSize-(iDataChunkSize+iDataChunk-iReadDataChunk) > iWriteDataChunk)
sl@0	5112	{
sl@0	5113	PRINT((_L("CVDecTestEngine::ReadByteFromFile, Input End found")));
sl@0	5114	if (!aDiscard)
sl@0	5115	{
sl@0	5116	aCodedInBuffer->iData.Append(iReadDataChunk, (iDataChunkSize+(iDataChunk-iReadDataChunk)));
sl@0	5117	}
sl@0	5118	iReadDataChunk = iDataChunk;
sl@0	5119	if (!aDiscard)
sl@0	5120	{
sl@0	5121	aCodedInBuffer->iData.Append(iReadDataChunk, (iWriteDataChunk-iReadDataChunk));
sl@0	5122	}
sl@0	5123	iReadDataChunk += iWriteDataChunk-iReadDataChunk;
sl@0	5124	iInputEnd = ETrue;
sl@0	5125	return;
sl@0	5126	}
sl@0	5127	}
sl@0	5128
sl@0	5129	if (iReadDataChunk+aSize <= iDataChunk+iDataChunkSize)
sl@0	5130	{
sl@0	5131	if (!aDiscard)
sl@0	5132	{
sl@0	5133	aCodedInBuffer->iData.Append(iReadDataChunk, aSize);
sl@0	5134	}
sl@0	5135	iReadDataChunk +=aSize;
sl@0	5136	}
sl@0	5137	else if (iReadDataChunk+aSize > iDataChunk+iDataChunkSize)
sl@0	5138	{
sl@0	5139	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, iReadDataChunk+aSize > iDataChunk+iDataChunkSize")));
sl@0	5140	if (!aDiscard)
sl@0	5141	{
sl@0	5142	aCodedInBuffer->iData.Append(iReadDataChunk, (iDataChunkSize+iDataChunk-iReadDataChunk));
sl@0	5143	}
sl@0	5144	TInt end = aSize - ( iDataChunkSize+iDataChunk - iReadDataChunk );
sl@0	5145	iReadDataChunk = iDataChunk;
sl@0	5146	PRINT( ( _L( "CVDecTestEngine::ReadDataToBuffer, iReadDataChunk = iDataChunk") ) );
sl@0	5147	if (!aDiscard)
sl@0	5148	{
sl@0	5149	aCodedInBuffer->iData.Append(iReadDataChunk, end);
sl@0	5150	}
sl@0	5151	iReadDataChunk += end;
sl@0	5152	}
sl@0	5153
sl@0	5154	err = CheckAndFillDataChunk();
sl@0	5155	if (err )
sl@0	5156	{
sl@0	5157	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, ERROR [%d]"), err));
sl@0	5158
sl@0	5159	return;
sl@0	5160	};
sl@0	5161	PRINT((_L("CVDecTestEngine::ReadDataToBuffer, Out")));
sl@0	5162	}
sl@0	5163
sl@0	5164	/* ----------------------------------------------------------------------------
sl@0	5165	* Name: CVDecTestEngine::CheckAndFillDataChunk()
sl@0	5166	* Purpose:
sl@0	5167	* Note:
sl@0	5168	* Parameters: None
sl@0	5169	* Return: None
sl@0	5170	* --------------------------------------------------------------------------*/
sl@0	5171	TInt CVDecTestEngine::CheckAndFillDataChunk()
sl@0	5172	{
sl@0	5173	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, In")));
sl@0	5174
sl@0	5175	TInt err = KErrNone;
sl@0	5176
sl@0	5177	//If all the data is read return KerrNone
sl@0	5178	if (iEndOfData)
sl@0	5179	{
sl@0	5180	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, End of data")));
sl@0	5181	return KErrNone;
sl@0	5182	}
sl@0	5183
sl@0	5184	TInt32 read = (TInt32)(iReadDataChunk);
sl@0	5185	TInt32 write = (TInt32)(iWriteDataChunk);
sl@0	5186	TInt32 chunk = (TInt32)(iDataChunkSize);
sl@0	5187	TInt32 thres = (TInt32)(iDataThreshold);
sl@0	5188	//First time fill the whole buffer
sl@0	5189
sl@0	5190	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, read %d, write %d, chunk %d, thres %d"), read, write, chunk, thres));
sl@0	5191
sl@0	5192	if (iDataReadFromFile == 0)
sl@0	5193	{
sl@0	5194	TPtr8 temp(iWriteDataChunk, iDataChunkSize, iDataChunkSize);
sl@0	5195	if ( (err = iInFile.Read(temp, iDataChunkSize)) != KErrNone)
sl@0	5196	{
sl@0	5197	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, Infile read [%d]"), err));
sl@0	5198	return err;
sl@0	5199	}
sl@0	5200	if (temp.Length() < iDataChunkSize)
sl@0	5201	{
sl@0	5202	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, end of file found [%d]"), temp.Length()));
sl@0	5203	if(temp.Length()== 0){
sl@0	5204	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, Error! Trying to read zero-sized input file")));
sl@0	5205	iInputEnd = ETrue;
sl@0	5206	}
sl@0	5207	iEndOfData = ETrue;
sl@0	5208	iWriteDataChunk += temp.Length();
sl@0	5209	iDataReadFromFile += temp.Length();
sl@0	5210	return KErrNone;
sl@0	5211	}
sl@0	5212	iDataReadFromFile += iDataChunkSize;
sl@0	5213	for (TUint i = 0; i < 20; i++)
sl@0	5214	{
sl@0	5215	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, [%x]"), iReadDataChunk[i]));
sl@0	5216	}
sl@0	5217	}
sl@0	5218	else if (((read-write) > (chunk-thres)) && (iSentBuffCount != 0))
sl@0	5219	{
sl@0	5220	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iReadDataChunk-iWriteDataChunk > iDataChunkSize-iDataThreshold")));
sl@0	5221	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iWriteDataChunk [%x]"), iWriteDataChunk));
sl@0	5222	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iReadDataChunk [%x]"), iReadDataChunk));
sl@0	5223	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iDataChunk [%x]"), iDataChunk));
sl@0	5224	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iReadDataChunk-iWriteDataChunk [%d]"), iReadDataChunk-iWriteDataChunk));
sl@0	5225	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iDataChunkSize-iDataThreshold [%d]"), iDataChunkSize-iDataThreshold));
sl@0	5226
sl@0	5227	TPtr8 temp(iWriteDataChunk, iReadDataChunk-iWriteDataChunk, iReadDataChunk-iWriteDataChunk);
sl@0	5228	if ( (err = iInFile.Read(temp, (iReadDataChunk-iWriteDataChunk))) != KErrNone)
sl@0	5229	{
sl@0	5230	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, Infile read [%d]"), err));
sl@0	5231	return err;
sl@0	5232	}
sl@0	5233	if (temp.Length() < iReadDataChunk-iWriteDataChunk)
sl@0	5234	{
sl@0	5235	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, End of file found [%d]"), temp.Length()));
sl@0	5236	iEndOfData = ETrue;
sl@0	5237	iWriteDataChunk += temp.Length();
sl@0	5238	return KErrNone;
sl@0	5239	}
sl@0	5240	iWriteDataChunk += iReadDataChunk-iWriteDataChunk;
sl@0	5241	iDataReadFromFile += iReadDataChunk-iWriteDataChunk;
sl@0	5242	}
sl@0	5243	else if (((write-read) < thres) && (iSentBuffCount != 0) && ((write-read) > 0))
sl@0	5244	{
sl@0	5245	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, iReadDataChunk-iWriteDataChunk > -iDataThreshold")));
sl@0	5246	//fill end of the buffer
sl@0	5247	TPtr8 end(iWriteDataChunk, iDataChunk+iDataChunkSize-iWriteDataChunk, iDataChunk+iDataChunkSize-iWriteDataChunk);
sl@0	5248	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, TPtr created")));
sl@0	5249	if ( (err = iInFile.Read(end, (iDataChunkSize+iDataChunk-iWriteDataChunk))) != KErrNone)
sl@0	5250	{
sl@0	5251	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, Infile read [%d]"), err));
sl@0	5252	return err;
sl@0	5253	}
sl@0	5254	if (end.Length() < (iDataChunkSize+iDataChunk-iWriteDataChunk))
sl@0	5255	{
sl@0	5256	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, End of file found [%d]"), end.Length()));
sl@0	5257	iEndOfData = ETrue;
sl@0	5258	iWriteDataChunk += end.Length();
sl@0	5259	return KErrNone;
sl@0	5260	}
sl@0	5261
sl@0	5262	//fill beginning of the buffer
sl@0	5263	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, end of data chunk filled [%d]"), end.Length()));
sl@0	5264	TPtr8 begin(iDataChunk, iReadDataChunk-iDataChunk, iReadDataChunk-iDataChunk);
sl@0	5265	if ( (err = iInFile.Read(begin, iReadDataChunk-iDataChunk)) != KErrNone)
sl@0	5266	{
sl@0	5267	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, Infile read [%d]"), err));
sl@0	5268	return err;
sl@0	5269	}
sl@0	5270	if (begin.Length() < (iReadDataChunk-iDataChunk))
sl@0	5271	{
sl@0	5272	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, End of file found [%d]"), begin.Length()));
sl@0	5273	iEndOfData = ETrue;
sl@0	5274	iWriteDataChunk = iDataChunk+begin.Length();
sl@0	5275	return KErrNone;
sl@0	5276	}
sl@0	5277	iWriteDataChunk = iDataChunk+begin.Length();
sl@0	5278	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, beginning of data chunk filled [%d]"), begin.Length()));
sl@0	5279	iDataReadFromFile += iDataChunkSize-(iWriteDataChunk-iReadDataChunk);
sl@0	5280	}
sl@0	5281	else if (iWriteDataChunk == iDataChunk+iDataChunkSize)
sl@0	5282	{
sl@0	5283	iWriteDataChunk = iDataChunk;
sl@0	5284	}
sl@0	5285
sl@0	5286	PRINT((_L("CVDecTestEngine::CheckAndFillDataChunk, Out")));
sl@0	5287	return err;
sl@0	5288	}
sl@0	5289
sl@0	5290	/* ----------------------------------------------------------------------------
sl@0	5291	* Name: CVDecTestEngine::PrintUncompressedFormat()
sl@0	5292	* Purpose: Get Next input data
sl@0	5293	* Note:
sl@0	5294	* Parameters: None
sl@0	5295	* Return: None
sl@0	5296	* --------------------------------------------------------------------------*/
sl@0	5297
sl@0	5298
sl@0	5299	void CVDecTestEngine::PrintUncompressedFormat(const TUncompressedVideoFormat& aFormat)
sl@0	5300	{
sl@0	5301	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, In")))
sl@0	5302
sl@0	5303	switch (aFormat.iDataFormat)
sl@0	5304	{
sl@0	5305	case ERgbRawData:
sl@0	5306	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataFormat = ERgbRawData")))
sl@0	5307	case ERgbFbsBitmap:
sl@0	5308	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataFormat = ERgbFbsBitmap")))
sl@0	5309	switch(aFormat.iRgbFormat)
sl@0	5310	{
sl@0	5311	case ERgb16bit444:
sl@0	5312	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = ERgb16bit444")))
sl@0	5313	break;
sl@0	5314	case ERgb16bit565:
sl@0	5315	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = ERgb16bit565")))
sl@0	5316	break;
sl@0	5317	case ERgb32bit888:
sl@0	5318	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = ERgb32bit888")))
sl@0	5319	break;
sl@0	5320	case EFbsBitmapColor4K:
sl@0	5321	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = EFbsBitmapColor4K")))
sl@0	5322	break;
sl@0	5323	case EFbsBitmapColor64K:
sl@0	5324	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = EFbsBitmapColor64K")))
sl@0	5325	break;
sl@0	5326	case EFbsBitmapColor16M:
sl@0	5327	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = EFbsBitmapColor16M")))
sl@0	5328	break;
sl@0	5329	case EFbsBitmapColor16MU:
sl@0	5330	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iRgbFormat = EFbsBitmapColor16MU")))
sl@0	5331	break;
sl@0	5332	default:
sl@0	5333	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, Error reading iRgbFormat [%x]"), aFormat.iRgbFormat))
sl@0	5334	}
sl@0	5335	break;
sl@0	5336	case EYuvRawData:
sl@0	5337	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataFormat = EYuvRawData")))
sl@0	5338	switch(aFormat.iYuvFormat.iCoefficients)
sl@0	5339	{
sl@0	5340	case EYuvRange0:
sl@0	5341	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvRange0")))
sl@0	5342	break;
sl@0	5343	case EYuvRange1:
sl@0	5344	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvRange1")))
sl@0	5345	break;
sl@0	5346	case EYuvBt709:
sl@0	5347	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvBt709")))
sl@0	5348	break;
sl@0	5349	case EYuvBt709Range0:
sl@0	5350	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvBt709Range0")))
sl@0	5351	break;
sl@0	5352	case EYuvBt709Range1:
sl@0	5353	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvBt709Range1")))
sl@0	5354	break;
sl@0	5355	case EYuvBt601:
sl@0	5356	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvBt601")))
sl@0	5357	break;
sl@0	5358	case EYuvBt601Range0:
sl@0	5359	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvBt601Range0")))
sl@0	5360	break;
sl@0	5361	case EYuvBt601Range1:
sl@0	5362	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = EYuvBt601Range1")))
sl@0	5363	break;
sl@0	5364	case ECustomYuvMatrix:
sl@0	5365	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iCoefficients = ECustomYuvMatrix")))
sl@0	5366	break;
sl@0	5367	default:
sl@0	5368	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, Error reading iCoefficients [%x]"), aFormat.iYuvFormat.iCoefficients))
sl@0	5369	}
sl@0	5370	switch(aFormat.iYuvFormat.iPattern)
sl@0	5371	{
sl@0	5372	case EYuv420Chroma1:
sl@0	5373	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iPattern = EYuv420Chroma1")))
sl@0	5374	break;
sl@0	5375	case EYuv420Chroma2:
sl@0	5376	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iPattern = EYuv420Chroma2")))
sl@0	5377	break;
sl@0	5378	case EYuv420Chroma3:
sl@0	5379	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iPattern = EYuv420Chroma3")))
sl@0	5380	break;
sl@0	5381	case EYuv422Chroma1:
sl@0	5382	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iPattern = EYuv422Chroma1")))
sl@0	5383	break;
sl@0	5384	case EYuv422Chroma2:
sl@0	5385	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iPattern = EYuv422Chroma2")))
sl@0	5386	break;
sl@0	5387	default:
sl@0	5388	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, Error reading iPattern [%x]"), aFormat.iYuvFormat.iPattern))
sl@0	5389	}
sl@0	5390	switch(aFormat.iYuvFormat.iDataLayout)
sl@0	5391	{
sl@0	5392	case EYuvDataPlanar:
sl@0	5393	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataLayout = EYuvDataPlanar")))
sl@0	5394	break;
sl@0	5395	case EYuvDataInterleavedLE:
sl@0	5396	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataLayout = EYuvDataInterleavedLE")))
sl@0	5397	break;
sl@0	5398	case EYuvDataInterleavedBE:
sl@0	5399	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataLayout = EYuvDataInterleavedBE")))
sl@0	5400	break;
sl@0	5401	case EYuvDataSemiPlanar:
sl@0	5402	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iDataLayout = EYuvDataSemiPlanar")))
sl@0	5403	break;
sl@0	5404	default:
sl@0	5405	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, Error reading iDataLayout [%x]"), aFormat.iYuvFormat.iDataLayout))
sl@0	5406	}
sl@0	5407	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iAspectRatioNum [%d]"), aFormat.iYuvFormat.iAspectRatioNum))
sl@0	5408	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, iAspectRatioDenom [%d]"), aFormat.iYuvFormat.iAspectRatioDenom))
sl@0	5409	break;
sl@0	5410	default :
sl@0	5411	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, Error reading iDataFormat [%x]"), aFormat.iDataFormat))
sl@0	5412	}
sl@0	5413
sl@0	5414	PRINT((_L("CVDecTestEngine::PrintUncompressedFormat, Out")))
sl@0	5415	}
sl@0	5416
sl@0	5417	/* ----------------------------------------------------------------------------
sl@0	5418	* Name: CVDecTestEngine::ConvertToRealL()
sl@0	5419	* Purpose: Converts the given descriptor to TReal
sl@0	5420	* Parameters: const TDesC& aPtr
sl@0	5421	* Return: TReal
sl@0	5422	* --------------------------------------------------------------------------*/
sl@0	5423
sl@0	5424	TReal CVDecTestEngine::ConvertToRealL(const TDesC& aPtr)
sl@0	5425	{
sl@0	5426	PRINT((_L("CVDecTestEngine::ConvertToReal(),In")))
sl@0	5427
sl@0	5428	TInt point = aPtr.Find(_L("."));
sl@0	5429
sl@0	5430	TBufC<7> integer;
sl@0	5431	TBufC<7> decimal;
sl@0	5432	if (point != KErrNotFound)
sl@0	5433	{
sl@0	5434
sl@0	5435	integer = aPtr.Mid(0, point);
sl@0	5436	decimal = aPtr.Mid(point+1);
sl@0	5437	}
sl@0	5438	else
sl@0	5439	{
sl@0	5440	User::Leave(KErrArgument);
sl@0	5441	}
sl@0	5442	TInt decimalInt = 0;
sl@0	5443	TInt integerInt = 0;
sl@0	5444	TLex lexInt(integer);
sl@0	5445	TLex lexDec(decimal);
sl@0	5446
sl@0	5447	if (lexInt.Val(integerInt) != KErrNone \|\| lexDec.Val(decimalInt) != KErrNone)
sl@0	5448	{
sl@0	5449	PRINT((_L("CVDecTestEngine::ConvertToReal(), error in descriptor")))
sl@0	5450	User::Leave(KErrArgument);
sl@0	5451	}
sl@0	5452
sl@0	5453
sl@0	5454	TReal real = 1.0;
sl@0	5455	TReal length = static_cast<TReal>(aPtr.Length()-point-1);
sl@0	5456	TReal denom = pow(10.0, length);
sl@0	5457
sl@0	5458
sl@0	5459	real = (static_cast<TReal>(integerInt)) + (static_cast<TReal>(decimalInt)/denom);
sl@0	5460
sl@0	5461	PRINT((_L("CVDecTestEngine::ConvertToReal(),integer [%d]"), integerInt))
sl@0	5462	PRINT((_L("CVDecTestEngine::ConvertToReal(),decimal [%d]"), decimalInt))
sl@0	5463	PRINT((_L("CVDecTestEngine::ConvertToReal(),denom [%f]"), denom))
sl@0	5464	PRINT((_L("CVDecTestEngine::ConvertToReal(),real [%f]"), real))
sl@0	5465
sl@0	5466	PRINT((_L("CVDecTestEngine::ConvertToReal(),Out")))
sl@0	5467	return real;
sl@0	5468	}
sl@0	5469
sl@0	5470
sl@0	5471	/* ----------------------------------------------------------------------------
sl@0	5472	* Name: CVDecTestEngine::MdvpoNewBuffers()
sl@0	5473	* Purpose: Availability of Next buffer is notified
sl@0	5474	* Note:
sl@0	5475	* Parameters: None
sl@0	5476	* Return: None
sl@0	5477	* --------------------------------------------------------------------------*/
sl@0	5478
sl@0	5479
sl@0	5480	void CVDecTestEngine::MdvpoNewBuffers()
sl@0	5481	{
sl@0	5482	PRINT((_L("CVDecTestEngine::MdvpoNewBuffers(), Newbuffer is available")))
sl@0	5483
sl@0	5484	//if ( iFrameMeasurement )
sl@0	5485	// return;
sl@0	5486
sl@0	5487	if ( iState == ERunning)
sl@0	5488	{
sl@0	5489	iDecTestAO->RequestData();
sl@0	5490	}
sl@0	5491
sl@0	5492
sl@0	5493	}
sl@0	5494
sl@0	5495	/* ----------------------------------------------------------------------------
sl@0	5496	* Name: CVDecTestEngine::MdvpoReturnPicture()
sl@0	5497	* Purpose: Postprocessor Input buffer is returned
sl@0	5498	* Note: Used when input to Postprocessing
sl@0	5499	* Parameters: TVideoPicture* aPicture
sl@0	5500	* Return: None
sl@0	5501	* --------------------------------------------------------------------------*/
sl@0	5502
sl@0	5503
sl@0	5504	void CVDecTestEngine::MdvpoReturnPicture(TVideoPicture* aPicture)
sl@0	5505	{
sl@0	5506	if ( iRawInBuffer == aPicture )
sl@0	5507	{
sl@0	5508	PRINT((_L("CVDecTestEngine::MdvpoReturnPicture, a Picture returned ")))
sl@0	5509	iDecTestAO->RequestData();
sl@0	5510
sl@0	5511	}
sl@0	5512	else
sl@0	5513	{
sl@0	5514	PRINT((_L("CVDecTestEngine::MdvpoReturnPicture, Returned picture unknown")))
sl@0	5515	iError = KErrGeneral;
sl@0	5516	}
sl@0	5517	}
sl@0	5518
sl@0	5519
sl@0	5520
sl@0	5521	/* ----------------------------------------------------------------------------
sl@0	5522	* Name: CVDecTestEngine::MdvpoSupplementalInformation()
sl@0	5523	* Purpose: Supplementary information is notified
sl@0	5524	* Note:
sl@0	5525	* Parameters: const TDesC8& aData, const TTimeIntervalMicroSeconds& aTimestamp, const TPictureId& aPictureId
sl@0	5526	* Return: None
sl@0	5527	* --------------------------------------------------------------------------*/
sl@0	5528
sl@0	5529
sl@0	5530	void CVDecTestEngine::MdvpoSupplementalInformation(const TDesC8& /aData/, const TTimeIntervalMicroSeconds& /aTimestamp/, const TPictureId& /aPictureId/)
sl@0	5531	{
sl@0	5532	PRINT((_L("CVDecTestEngine::MdvpoSupplementalInformation ")))
sl@0	5533	}
sl@0	5534
sl@0	5535
sl@0	5536	/* ----------------------------------------------------------------------------
sl@0	5537	* Name: CVDecTestEngine::MdvpoPictureLoss()
sl@0	5538	* Purpose: Loss of a picture is notified
sl@0	5539	* Note:
sl@0	5540	* Parameters: None
sl@0	5541	* Return: None
sl@0	5542	* --------------------------------------------------------------------------*/
sl@0	5543
sl@0	5544	void CVDecTestEngine::MdvpoPictureLoss()
sl@0	5545	{
sl@0	5546	iPictureLoss++;
sl@0	5547	PRINT((_L("CVDecTestEngine::MdvpoPictureLoss, A picture lost. ")))
sl@0	5548
sl@0	5549	}
sl@0	5550
sl@0	5551
sl@0	5552	/* ----------------------------------------------------------------------------
sl@0	5553	* Name: CVDecTestEngine::MdvpoPictureLoss()
sl@0	5554	* Purpose: Loss of pictures is notified
sl@0	5555	* Note:
sl@0	5556	* Parameters: const TArray<TPictureId>& aPictures
sl@0	5557	* Return: None
sl@0	5558	* --------------------------------------------------------------------------*/
sl@0	5559
sl@0	5560	void CVDecTestEngine::MdvpoPictureLoss(const TArray<TPictureId>& aPictures)
sl@0	5561	{
sl@0	5562	TInt count = aPictures.Count();
sl@0	5563	iPictureLoss += count;
sl@0	5564	PRINT((_L("CVDecTestEngine::MdvpoPictureLoss, [%d] pictures lost. "),count))
sl@0	5565
sl@0	5566	for ( TInt i =0; i<count;i++ )
sl@0	5567	{
sl@0	5568	TPictureId id = aPictures[i];
sl@0	5569	PRINT((_L("CVDecTestEngine::MdvpoPictureLoss, Picure:[%d]"),i))
sl@0	5570
sl@0	5571	/* if(id.iIdType == TPictureId::EPictureNumber)
sl@0	5572	PRINT((_L("CVDecTestEngine::MdvpoPictureLoss, Picture Type:Picture Number, ID:[%d]"),id.iId))
sl@0	5573	else if (id.iIdType == TPictureId::ETemporalReference)
sl@0	5574	PRINT((_L("CVDecTestEngine::MdvpoPictureLoss, Picture Type:Temporal Reference, ID:[%d]"),id.iId))
sl@0	5575	else
sl@0	5576	PRINT((_L("CVDecTestEngine::MdvpoPictureLoss, Picture Type:Unidentified piture")))
sl@0	5577	*/
sl@0	5578	}
sl@0	5579	}
sl@0	5580
sl@0	5581	/* ----------------------------------------------------------------------------
sl@0	5582	* Name: CVDecTestEngine::MdvpoSliceLoss
sl@0	5583	* Purpose: Loss of slice is notified
sl@0	5584	* Note:
sl@0	5585	* Parameters: TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture
sl@0	5586	* Return: None
sl@0	5587	* --------------------------------------------------------------------------*/
sl@0	5588
sl@0	5589	void CVDecTestEngine::MdvpoSliceLoss(TUint /aFirstMacroblock/, TUint /aNumMacroblocks/, const TPictureId& /aPicture/)
sl@0	5590	{
sl@0	5591
sl@0	5592	PRINT((_L("CVDecTestEngine::MdvpoSliceLoss, In")))
sl@0	5593
sl@0	5594	// PRINT((_L("CVDecTestEngine::MdvpoSliceLoss, [%d] consecutive Mactoblocks from [%d] in raster-scan order are lost"),aPicture.aNumMacroblocks ,aPicture.aFirstMacroblock))
sl@0	5595	/* if( aPicture.iIdType == TPictureId::EPictureNumber)
sl@0	5596	PRINT((_L("CVDecTestEngine::MdvpoSliceLoss, Picture Type:Picture Number, ID:[%d]"),aPicture.iId))
sl@0	5597	else if (aPicture.iIdType == TPictureId::ETemporalReference)
sl@0	5598	PRINT((_L("CVDecTestEngine::MdvpoSliceLoss, Picture Type:Temporal Reference, ID:[%d]"),aPicture.iId))
sl@0	5599	else
sl@0	5600	PRINT((_L("CVDecTestEngine::MdvpoSliceLoss, Picture Type:Unidentified piture")))
sl@0	5601	*/
sl@0	5602
sl@0	5603	}
sl@0	5604
sl@0	5605
sl@0	5606	/* ----------------------------------------------------------------------------
sl@0	5607	* Name: CVDecTestEngine::MdvpoReferencePictureSelection
sl@0	5608	* Purpose:
sl@0	5609	* Note:
sl@0	5610	* Parameters: const TDesC8& aSelectionData
sl@0	5611	* Return: None
sl@0	5612	* --------------------------------------------------------------------------*/
sl@0	5613
sl@0	5614
sl@0	5615	void CVDecTestEngine::MdvpoReferencePictureSelection(const TDesC8& /aSelectionData/)
sl@0	5616	{
sl@0	5617	PRINT((_L("CVDecTestEngine::MdvpoReferencePictureSelection ")))
sl@0	5618
sl@0	5619	}
sl@0	5620
sl@0	5621	/* ----------------------------------------------------------------------------
sl@0	5622	* Name: CVDecTestEngine::MdvpoTimedSnapshotComplete()
sl@0	5623	* Purpose:
sl@0	5624	* Note:
sl@0	5625	* Parameters: TInt aError, TPictureData* aPictureData, const TTimeIntervalMicroSeconds& aPresentationTimestamp, const TPictureId& aPictureId
sl@0	5626	* Return: None
sl@0	5627	* --------------------------------------------------------------------------*/
sl@0	5628
sl@0	5629	void CVDecTestEngine::MdvpoTimedSnapshotComplete(TInt aError, TPictureData* aPictureData, const TTimeIntervalMicroSeconds& /aPresentationTimestamp/, const TPictureId& aPictureId)
sl@0	5630	{
sl@0	5631	PRINT((_L("CVDecTestEngine::MdvpoTimedSnapshotComplete(),In, error [%d]"), aError))
sl@0	5632
sl@0	5633	if ( aError == KErrNone )
sl@0	5634	{
sl@0	5635	RFile snapshot;
sl@0	5636
sl@0	5637	TFileName filename;
sl@0	5638	TBuf8<128> newFile;
sl@0	5639	newFile.Delete(newFile.Length()-5, 4);
sl@0	5640	newFile.Append(_L("_id_"));
sl@0	5641	newFile.AppendNum(aPictureId.iId);
sl@0	5642	newFile.Append(_L(".yuv"));
sl@0	5643	filename.Copy(newFile);
sl@0	5644
sl@0	5645	TInt err = snapshot.Replace(iFs, filename, EFileShareExclusive\|EFileWrite);
sl@0	5646
sl@0	5647	if ( err != KErrNone )
sl@0	5648	{
sl@0	5649	PRINT((_L("CVDecTestEngine::GetSnapshotL, snapshot file open failed")))
sl@0	5650	snapshot.Close();
sl@0	5651	User::Leave(err);
sl@0	5652	}
sl@0	5653	else
sl@0	5654	{
sl@0	5655	err = snapshot.Write(*(aPictureData->iRawData),aPictureData->iRawData->Size());
sl@0	5656	if ( err!= KErrNone )
sl@0	5657	{
sl@0	5658	PRINT((_L("CVDecTestEngine::GetSnapshotL, snapshot file write failed")))
sl@0	5659	snapshot.Close();
sl@0	5660	User::Leave(err);
sl@0	5661	}
sl@0	5662	}
sl@0	5663	PRINT((_L("CVDecTestEngine::GetSnapshotL, Picture size"),aPictureData->iRawData->Size()));
sl@0	5664	snapshot.Close();
sl@0	5665	}
sl@0	5666	PRINT((_L("CVDecTestEngine::MdvpoTimedSnapshotComplete(),Out")))
sl@0	5667	}
sl@0	5668
sl@0	5669
sl@0	5670	/* ----------------------------------------------------------------------------
sl@0	5671	* Name: CVDecTestEngine::MdvpoNewPictures()
sl@0	5672	* Purpose:
sl@0	5673	* Note:
sl@0	5674	* Parameters: None
sl@0	5675	* Return: None
sl@0	5676	* --------------------------------------------------------------------------*/
sl@0	5677
sl@0	5678	void CVDecTestEngine::MdvpoNewPictures()
sl@0	5679	{
sl@0	5680
sl@0	5681	PRINT((_L("CVDecTestEngine::MdvpoNewPictures(),In, New output picture is available")))
sl@0	5682
sl@0	5683	GetReturnedPictureL();
sl@0	5684	}
sl@0	5685
sl@0	5686
sl@0	5687
sl@0	5688	/* ----------------------------------------------------------------------------
sl@0	5689	* Name: CVDecTestEngine::MdvpoFatalError()
sl@0	5690	* Purpose: Fatal error is notified
sl@0	5691	* Note: Decoder/Postprocessor to be deleted
sl@0	5692	* Parameters: TInt aError
sl@0	5693	* Return: None
sl@0	5694	* --------------------------------------------------------------------------*/
sl@0	5695
sl@0	5696	void CVDecTestEngine::MdvpoFatalError(TInt aError)
sl@0	5697	{
sl@0	5698	iError = aError;
sl@0	5699	PRINT((_L("CVDecTestEngine::MdvpoFatalError, FATAL ERROR [%d]"),aError))
sl@0	5700	iState = EStopped;
sl@0	5701	MdvpoStreamEnd();
sl@0	5702
sl@0	5703	iTestClass->MvdeSetError(aError);
sl@0	5704	}
sl@0	5705
sl@0	5706
sl@0	5707	/* ----------------------------------------------------------------------------
sl@0	5708	* Name: CVDecTestEngine::MdvpoInitComplete()
sl@0	5709	* Purpose: Completion of initialization is notified
sl@0	5710	* Note:
sl@0	5711	* Parameters: TInt aError
sl@0	5712	* Return: None
sl@0	5713	* --------------------------------------------------------------------------*/
sl@0	5714
sl@0	5715	void CVDecTestEngine::MdvpoInitComplete(TInt aError)
sl@0	5716	{
sl@0	5717	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, In")))
sl@0	5718	if ( iRunning )
sl@0	5719	{
sl@0	5720	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, Stopping SchedulerWait")))
sl@0	5721	iScheduler->AsyncStop();
sl@0	5722	delete iScheduler;
sl@0	5723	iScheduler = NULL;
sl@0	5724	iMemDelete++;
sl@0	5725	#ifdef __MEM_CHECK_
sl@0	5726	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, mem del, iScheduler") ))
sl@0	5727	#endif
sl@0	5728	}
sl@0	5729
sl@0	5730	if ( aError != KErrNone )
sl@0	5731	{
sl@0	5732	iError = aError;
sl@0	5733	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, Error code [%d]"),aError))
sl@0	5734	return;
sl@0	5735	}
sl@0	5736
sl@0	5737	if (iDeleteDecoderFromInitComp)
sl@0	5738	{
sl@0	5739	//TearDown();
sl@0	5740	delete iDevvp;
sl@0	5741	iDevvp = NULL;
sl@0	5742	iMemDelete++;
sl@0	5743	#ifdef __MEM_CHECK_
sl@0	5744	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, mem del, iDevvp") ))
sl@0	5745	#endif
sl@0	5746	iState = EStateNone;
sl@0	5747	PRINT((_L("CVDecTestEngine::MdvpoInitComplete,DevVideo deleted")))
sl@0	5748	}
sl@0	5749
sl@0	5750	iState = EInitialized;
sl@0	5751	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, Initialized")))
sl@0	5752
sl@0	5753	//Initilize parameters for Decoding/Playback
sl@0	5754	iCodedInBuffer = NULL;
sl@0	5755	iOutBuffer =NULL;
sl@0	5756	iSentBuffCount = 0;
sl@0	5757	iReturnedBuffCount = 0;
sl@0	5758	iPictureLoss =0;
sl@0	5759	iInputEnd = EFalse;
sl@0	5760	iStreamEnd = EFalse;
sl@0	5761	iTimeStamp = 0;
sl@0	5762	iNoBuffAvailable = 0;
sl@0	5763
sl@0	5764	iTestClass->MvdeStreamEndReached(); // Notify observer data transfer is complete
sl@0	5765	PRINT((_L("CVDecTestEngine::MdvpoInitComplete, Out")))
sl@0	5766	}
sl@0	5767
sl@0	5768
sl@0	5769	/* ----------------------------------------------------------------------------
sl@0	5770	* Name: CVDecTestEngine::MdvpoStreamEnd()
sl@0	5771	* Purpose: End of stream is notified
sl@0	5772	* Note:
sl@0	5773	* Parameters: None
sl@0	5774	* Return: None
sl@0	5775	* --------------------------------------------------------------------------*/
sl@0	5776
sl@0	5777	void CVDecTestEngine::MdvpoStreamEnd()
sl@0	5778	{
sl@0	5779	iStreamEnd = ETrue;
sl@0	5780	if (iOutBufferTemp)
sl@0	5781	{
sl@0	5782	iDevvp->ReturnPicture(iOutBufferTemp);
sl@0	5783	}
sl@0	5784	PRINT((_L("CVDecTestEngine::MdvpoStreamEnd(), Stream end")))
sl@0	5785
sl@0	5786	if (iFrameMeasurement && iFrameTime != 0)
sl@0	5787	{
sl@0	5788	TReal framerate = (TReal)(iReturnedBuffCount-1) / iFrameTime;
sl@0	5789	PRINT((_L("CVDecTestEngine::MdvpoStreamEnd(), Frame rate: [%f] fps"), framerate))
sl@0	5790	}
sl@0	5791	if(iInstantFpsEnabled)
sl@0	5792	{
sl@0	5793	TInt err = KErrNone;
sl@0	5794	for(TUint i=0; i < iInstantFpsList.Count(); i++ )
sl@0	5795	{
sl@0	5796	_LIT(KEnd, "\n");
sl@0	5797	TBuf8 <0x100> tempBuff;
sl@0	5798	TTimeIntervalMicroSeconds time = iInstantFpsList[ i ];
sl@0	5799	tempBuff.AppendNum((TInt64)time.Int64());
sl@0	5800	tempBuff.Append(KEnd);
sl@0	5801	err = iFpsFile.Write(tempBuff,tempBuff.Size() );
sl@0	5802	if( err != KErrNone )
sl@0	5803	{
sl@0	5804	PRINT((_L("CVDecTestEngine::MdvpoStreamEnd(), iFpsFile write error: [%d]"), err))
sl@0	5805	}
sl@0	5806	}
sl@0	5807	}
sl@0	5808	iTestClass->MvdeStreamEndReached(); // Notify observer data transfer is complete
sl@0	5809	}
sl@0	5810
sl@0	5811	/* ----------------------------------------------------------------------------
sl@0	5812	* Name: CVDecTestEngine::MmvbmoNewBuffers()
sl@0	5813	* Purpose: Observer callback in Custom interface Buffer management
sl@0	5814	* Client is notified a new buffer(s) is available
sl@0	5815	* Note: This is used when custom interface buffer management is used
sl@0	5816	* Parameters: None
sl@0	5817	* Return: None
sl@0	5818	* --------------------------------------------------------------------------*/
sl@0	5819
sl@0	5820	#ifdef __CI_HEADERS__
sl@0	5821
sl@0	5822	void CVDecTestEngine::MmvbmoNewBuffers()
sl@0	5823	{
sl@0	5824
sl@0	5825	PRINT((_L("CVDecTestEngine::MmvbmoNewBuffers(), New input buffer is available")))
sl@0	5826	if ( (iState == ERunning) && iCIBuffMgmtOn )
sl@0	5827	{
sl@0	5828	iDecTestAO->RequestData();
sl@0	5829	}
sl@0	5830
sl@0	5831	}
sl@0	5832	#endif
sl@0	5833	/* ----------------------------------------------------------------------------
sl@0	5834	* Name: CVDecTestEngine::MmvbmoReleaseBuffers()
sl@0	5835	* Purpose: Observer callback in Custom interface Buffer management
sl@0	5836	* Client is notified to release all buffers it has, using MmvbmReleaseBuffer
sl@0	5837	* Note: This is used when custom interface buffer management is used
sl@0	5838	* Parameters: None
sl@0	5839	* Return: None
sl@0	5840	* --------------------------------------------------------------------------*/
sl@0	5841	#ifdef __CI_HEADERS__
sl@0	5842	void CVDecTestEngine::MmvbmoReleaseBuffers()
sl@0	5843	{
sl@0	5844	if (iRawInBuffer)
sl@0	5845	{
sl@0	5846	iCIBuffMgmt->MmvbmReleaseBuffer(iRawInBuffer);
sl@0	5847	iRawInBuffer = NULL;
sl@0	5848	}
sl@0	5849	PRINT((_L("CVDecTestEngine::MmvbmoReleaseBuffers(), buffer released")))
sl@0	5850	}
sl@0	5851
sl@0	5852	#endif
sl@0	5853
sl@0	5854	/* ----------------------------------------------------------------------------
sl@0	5855	* Name: CVDecTestEngine::
sl@0	5856	* Purpose:
sl@0	5857	* Parameters: None
sl@0	5858	* Return: None
sl@0	5859	* --------------------------------------------------------------------------*/
sl@0	5860	#ifdef __RESOURCENOTIFICATION__
sl@0	5861	void CVDecTestEngine::MmvroResourcesLost(TUid aMediaDevice)
sl@0	5862	{
sl@0	5863	PRINT((_L("CVDecTestEngine::MmvroResourcesLost(), Uid [%x]"), aMediaDevice.iUid))
sl@0	5864
sl@0	5865	if (iDecoderUid.iUid != aMediaDevice.iUid)
sl@0	5866	{
sl@0	5867	PRINT((_L("CVDecTestEngine::MmvroResourcesLost, UID is different")))
sl@0	5868	return;
sl@0	5869	}
sl@0	5870
sl@0	5871	Pause();
sl@0	5872
sl@0	5873	iDecTestAO->Cancel();
sl@0	5874	if ( iDirectScreenAccess && iDsaStarted )
sl@0	5875	{
sl@0	5876	iDevvp->AbortDirectScreenAccess();
sl@0	5877	iDsaStarted = EFalse;
sl@0	5878	PRINT((_L("CVDecTestEngine::MmvroResourcesLost, DSA is aborted ")))
sl@0	5879	}
sl@0	5880
sl@0	5881
sl@0	5882	PRINT((_L("CVDecTestEngine::MmvroResourcesLost, Out ")))
sl@0	5883	}
sl@0	5884	#endif
sl@0	5885
sl@0	5886	/* ----------------------------------------------------------------------------
sl@0	5887	* Name: CVDecTestEngine::
sl@0	5888	* Purpose:
sl@0	5889	* Parameters: None
sl@0	5890	* Return: None
sl@0	5891	* --------------------------------------------------------------------------*/
sl@0	5892	#ifdef __RESOURCENOTIFICATION__
sl@0	5893	void CVDecTestEngine::MmvroResourcesRestored(TUid aMediaDevice)
sl@0	5894	{
sl@0	5895	PRINT((_L("CVDecTestEngine::MmvroResourcesRestored(), Uid [%x]"), aMediaDevice.iUid))
sl@0	5896
sl@0	5897	if (iDecoderUid.iUid != aMediaDevice.iUid)
sl@0	5898	{
sl@0	5899	PRINT((_L("CVDecTestEngine::MmvroResourcesRestored, UID is different")))
sl@0	5900	return;
sl@0	5901	}
sl@0	5902
sl@0	5903	if ( iDirectScreenAccess && !iDsaStarted )
sl@0	5904	{
sl@0	5905	TRAPD(err, StartDirectScreenAccessL());
sl@0	5906	if (err != KErrNone)
sl@0	5907	{
sl@0	5908	PRINT((_L("CVDecTestEngine::MmvroResourcesRestored, couldn't start DSA, err[%d]"),err))
sl@0	5909	User::Leave(err);
sl@0	5910	}
sl@0	5911	else
sl@0	5912	{
sl@0	5913	PRINT((_L("CVDecTestEngine::MmvroResourcesRestored, DSA started")))
sl@0	5914	}
sl@0	5915	}
sl@0	5916
sl@0	5917
sl@0	5918	// Start DevVideoPlay
sl@0	5919	Resume();
sl@0	5920
sl@0	5921	PRINT((_L("CVDecTestEngine::MmvroResourcesRestored(), Out")))
sl@0	5922	}
sl@0	5923
sl@0	5924	#endif
sl@0	5925
sl@0	5926	/* ----------------------------------------------------------------------------
sl@0	5927	* Name: CVDecTestAO::CVDecTestAO()
sl@0	5928	* Purpose: Constructor
sl@0	5929	* Parameters: CVDecTestEngine* aTestEngine
sl@0	5930	* Return: None
sl@0	5931	* --------------------------------------------------------------------------*/
sl@0	5932
sl@0	5933	CVDecTestAO::CVDecTestAO(CVDecTestEngine* aTestEngine) :
sl@0	5934	CActive(EPriorityStandard)
sl@0	5935	{
sl@0	5936	iTestEngine = aTestEngine;
sl@0	5937	CActiveScheduler::Add(this);
sl@0	5938
sl@0	5939	}
sl@0	5940
sl@0	5941
sl@0	5942	/* ----------------------------------------------------------------------------
sl@0	5943	* Name: CVDecTestAO::~CVDecTestAO()
sl@0	5944	* Purpose: Deconstructor
sl@0	5945	* Parameters: None
sl@0	5946	* Return: None
sl@0	5947	* --------------------------------------------------------------------------*/
sl@0	5948
sl@0	5949	CVDecTestAO::~CVDecTestAO()
sl@0	5950	{
sl@0	5951
sl@0	5952	Cancel();
sl@0	5953
sl@0	5954	}
sl@0	5955
sl@0	5956
sl@0	5957	/* ----------------------------------------------------------------------------
sl@0	5958	* Name: CVDecTestAO::RequestData()
sl@0	5959	* Purpose: Asyncronous request of next input data
sl@0	5960	* Parameters: None
sl@0	5961	* Return: None
sl@0	5962	* --------------------------------------------------------------------------*/
sl@0	5963
sl@0	5964	void CVDecTestAO::RequestData()
sl@0	5965	{
sl@0	5966
sl@0	5967	if ( !IsActive() )
sl@0	5968	{
sl@0	5969	TRequestStatus* status = &iStatus;
sl@0	5970	User::RequestComplete(status, KErrNone);
sl@0	5971
sl@0	5972	SetActive();
sl@0	5973	}
sl@0	5974	else
sl@0	5975	{
sl@0	5976	PRINT((_L("CVDecTestAO::RequestData(), Async request already active")))
sl@0	5977	}
sl@0	5978	}
sl@0	5979
sl@0	5980	/* ----------------------------------------------------------------------------
sl@0	5981	* Name: CVDecTestAO::RunL()
sl@0	5982	* Purpose: Active object RunL
sl@0	5983	* Parameters: None
sl@0	5984	* Return: None
sl@0	5985	* --------------------------------------------------------------------------*/
sl@0	5986
sl@0	5987	void CVDecTestAO::RunL()
sl@0	5988	{
sl@0	5989	if (iTestEngine->iState == EPaused \|\| iTestEngine->iState == EStopped)
sl@0	5990	{
sl@0	5991	return;
sl@0	5992	}
sl@0	5993	iTestEngine->HandleNewBufferL();
sl@0	5994	}
sl@0	5995
sl@0	5996	/* ----------------------------------------------------------------------------
sl@0	5997	* Name: CVDecTestAO::DoCancel()
sl@0	5998	* Purpose:
sl@0	5999	* Parameters: None
sl@0	6000	* Return: None
sl@0	6001	* --------------------------------------------------------------------------*/
sl@0	6002
sl@0	6003
sl@0	6004	void CVDecTestAO::DoCancel()
sl@0	6005	{
sl@0	6006
sl@0	6007	}
sl@0	6008
sl@0	6009	/* ----------------------------------------------------------------------------
sl@0	6010	* Name: CVDecTestEngine::CorruptInput()
sl@0	6011	* Purpose: Make the input file corrupted to test codec's robustness
sl@0	6012	* Note:
sl@0	6013	* Parameters: None
sl@0	6014	* Return: None
sl@0	6015	* --------------------------------------------------------------------------*/
sl@0	6016
sl@0	6017	void CVDecTestEngine::CorruptInput(TInt aFilter, TInt aInterval,
sl@0	6018	TInt aFrameNum, TInt aPct)
sl@0	6019	{
sl@0	6020	PRINT((_L("CVDecTestEngine::CorruptInput(),In")))
sl@0	6021
sl@0	6022	iCorruptMarker = ETrue;
sl@0	6023	iCorruptCounter = 0;
sl@0	6024
sl@0	6025	iFilter = aFilter;
sl@0	6026	iInterval = aInterval;
sl@0	6027	iFrameNum = aFrameNum;
sl@0	6028	iPercentage = aPct;
sl@0	6029
sl@0	6030	PRINT((_L("CVDecTestEngine::CorruptInput(),Out")))
sl@0	6031	}
sl@0	6032
sl@0	6033	/* ----------------------------------------------------------------------------
sl@0	6034	* Name: CVDecTestEngine::CorruptEngine()
sl@0	6035	* Purpose: Make the content in the buffer corrupted
sl@0	6036	* Note:
sl@0	6037	* Parameters:
sl@0	6038	* Return: None
sl@0	6039	* --------------------------------------------------------------------------*/
sl@0	6040
sl@0	6041	void CVDecTestEngine::CorruptEngineL()
sl@0	6042	{
sl@0	6043	PRINT((_L("CVDecTestEngine::CorruptEngin(), In")))
sl@0	6044	if( iInputEnd )
sl@0	6045	{
sl@0	6046	return;
sl@0	6047	}
sl@0	6048	if( iFrameCounter <= iInterval )
sl@0	6049	{
sl@0	6050	if( iFrameCounter < iInterval )
sl@0	6051	{
sl@0	6052	iFrameCounter++;
sl@0	6053	return;
sl@0	6054	}
sl@0	6055	else
sl@0	6056	{
sl@0	6057	iCorruptCounter++;
sl@0	6058	}
sl@0	6059	}
sl@0	6060	else
sl@0	6061	{
sl@0	6062	User::Leave( KErrGeneral);
sl@0	6063	}
sl@0	6064	TInt frameLength = iCodedInBuffer->iData.Size();
sl@0	6065	TInt maxLength = iCodedInBuffer->iData.MaxLength();
sl@0	6066
sl@0	6067	TUint8* memoryLocation = NULL;
sl@0	6068	TPtr8 tmpPointer(memoryLocation, frameLength, maxLength );
sl@0	6069	HBufC8* tempBuff = NULL;
sl@0	6070	tempBuff = HBufC8::NewL(iInBuffSize);
sl@0	6071	CleanupStack::PushL( tempBuff );
sl@0	6072	iMemAlloc++;
sl@0	6073	#ifdef __MEM_CHECK_
sl@0	6074	PRINT((_L("CVDecTestEngine::CorruptEngineL, mem alloc, tempBuff") ))
sl@0	6075	#endif
sl@0	6076	tmpPointer.Set(tempBuff->Des());
sl@0	6077
sl@0	6078	if( iFilter == 0 )
sl@0	6079	{
sl@0	6080	//Filter 0
sl@0	6081	PRINT((_L("CVDecTestEngine::CorruptEngin(),Filter 0, In")))
sl@0	6082
sl@0	6083
sl@0	6084	TInt lengthCopy = (TInt)( frameLength * iPercentage / 100 );
sl@0	6085
sl@0	6086
sl@0	6087	tmpPointer.Set(iCodedInBuffer->iData);
sl@0	6088
sl@0	6089	TInt corruptLength = frameLength - lengthCopy;
sl@0	6090	TInt corruptLen = 0;
sl@0	6091	for( TInt i = 0; i < corruptLength; i++ )
sl@0	6092	{
sl@0	6093	tmpPointer.Append('F');
sl@0	6094	corruptLen++;
sl@0	6095	}
sl@0	6096	PRINT((_L("CVDecTestEngine::CorruptEngin(),[%d] bytes are corrupted"), corruptLen ) )
sl@0	6097	iCodedInBuffer->iData.Set(tmpPointer);
sl@0	6098
sl@0	6099	PRINT((_L("CVDecTestEngine::CorruptEngin(),Filter 0, Out")))
sl@0	6100	}
sl@0	6101	else
sl@0	6102	{
sl@0	6103	// Filter 1
sl@0	6104	PRINT((_L("CVDecTestEngine::CorruptEngin(),Filter 1, In")))
sl@0	6105	// To be added here
sl@0	6106	TInt headerLen = 0;
sl@0	6107	if( iFrame == 0 )
sl@0	6108	{
sl@0	6109	headerLen = 16;
sl@0	6110
sl@0	6111	}
sl@0	6112	else
sl@0	6113	{
sl@0	6114	headerLen = 8;
sl@0	6115	}
sl@0	6116	TInt increment = (TInt)( ( frameLength - headerLen )/ ( ( frameLength - headerLen) * iPercentage / 100) ) - 1;
sl@0	6117
sl@0	6118	for(TInt i = headerLen; i < frameLength; )
sl@0	6119	{
sl@0	6120
sl@0	6121	TUint8* memorySeg = NULL;
sl@0	6122	TPtr8 segCopy(memorySeg,increment);
sl@0	6123	HBufC8* segBuff = NULL;
sl@0	6124	segBuff = HBufC8::NewL( increment );
sl@0	6125	#ifdef __MEM_CHECK_
sl@0	6126	PRINT((_L("CVDecTestEngine::CorruptEngine, mem alloc, segBuff") ))
sl@0	6127	#endif
sl@0	6128	iMemAlloc++;
sl@0	6129
sl@0	6130	CleanupStack::PushL( segBuff );
sl@0	6131	segCopy.Set(segBuff->Des());
sl@0	6132
sl@0	6133	if( i < frameLength - increment - 1 )
sl@0	6134	{
sl@0	6135	segCopy = iCodedInBuffer->iData.MidTPtr(i, increment );
sl@0	6136	segCopy.Append('F');
sl@0	6137	i++;
sl@0	6138	PRINT((_L("CVDecTestEngine::CorruptEngin(),[%d]th byte is corrupted"), i ) )
sl@0	6139	tmpPointer.Append( segCopy );
sl@0	6140	i += increment;
sl@0	6141	}
sl@0	6142	else // end of the frame
sl@0	6143	{
sl@0	6144	segCopy = iCodedInBuffer->iData.MidTPtr(i, (frameLength - i) );
sl@0	6145	tmpPointer.Append( segCopy );
sl@0	6146	i = frameLength;
sl@0	6147	}
sl@0	6148
sl@0	6149	CleanupStack::PopAndDestroy( segBuff );
sl@0	6150	iMemDelete++;
sl@0	6151	#ifdef __MEM_CHECK_
sl@0	6152	PRINT((_L("CVDecTestEngine::CorruptEngine, mem del, segBuff") ))
sl@0	6153	#endif
sl@0	6154	}
sl@0	6155	iCodedInBuffer->iData.Set(tmpPointer);
sl@0	6156
sl@0	6157	PRINT((_L("CVDecTestEngine::CorruptEngin(),Filter 1, Out")))
sl@0	6158	}
sl@0	6159	if( iCorruptCounter == iFrameNum )
sl@0	6160	{
sl@0	6161	iFrameCounter = 0;
sl@0	6162	iCorruptCounter = 0;
sl@0	6163	}
sl@0	6164	CleanupStack::PopAndDestroy( tempBuff );
sl@0	6165	iMemDelete++;
sl@0	6166	#ifdef __MEM_CHECK_
sl@0	6167	PRINT((_L("CVDecTestEngine::CorruptEngine, mem del, tempBuff") ))
sl@0	6168	#endif
sl@0	6169	PRINT((_L("CVDecTestEngine::CorruptEngin(), Out")))
sl@0	6170	}
sl@0	6171
sl@0	6172
sl@0	6173	/* ----------------------------------------------------------------------------
sl@0	6174	* Name: CVDecTestEngine::CorruptEngineL(TVideoInputBuffer*
sl@0	6175	aCodedInBuffer)
sl@0	6176	* Purpose: Make the content in the buffer corrupted
sl@0	6177	* Note:
sl@0	6178	* Parameters: TVideoInputBuffer* aCodedInBuffer
sl@0	6179	* Return: None
sl@0	6180	* --------------------------------------------------------------------------*/
sl@0	6181
sl@0	6182	void CVDecTestEngine::CorruptEngineL( TVideoInputBuffer* aCodedInBuffer )
sl@0	6183	{
sl@0	6184	PRINT((_L("CVDecTestEngine::CorruptEngin(TVideoInputBuffer* aCodedInBuffer), In")))
sl@0	6185	iFrameWriteLength = aCodedInBuffer->iData.Length();
sl@0	6186	if( iInputEnd )
sl@0	6187	{
sl@0	6188	return;
sl@0	6189	}
sl@0	6190	if( iFrameCounter <= iInterval )
sl@0	6191	{
sl@0	6192	if( iFrameCounter < iInterval )
sl@0	6193	{
sl@0	6194	iFrameCounter++;
sl@0	6195	PRINT((_L("CVDecTestEngine::CorruptEngin(TVideoInputBuffer* aCodedInBuffer), Out")))
sl@0	6196	return;
sl@0	6197	}
sl@0	6198	else
sl@0	6199	{
sl@0	6200	iCorruptCounter++;
sl@0	6201	}
sl@0	6202	}
sl@0	6203	else
sl@0	6204	{
sl@0	6205	User::Leave( KErrGeneral);
sl@0	6206	}
sl@0	6207
sl@0	6208	TInt frameLength = aCodedInBuffer->iData.Size();
sl@0	6209	TInt maxLength = aCodedInBuffer->iData.MaxLength();
sl@0	6210
sl@0	6211	TUint8* memoryLocation = NULL;
sl@0	6212	TPtr8 tmpPointer(memoryLocation, frameLength, maxLength );
sl@0	6213	HBufC8* tempBuff = NULL;
sl@0	6214	tempBuff = HBufC8::NewL(iInBuffSize);
sl@0	6215	iMemAlloc++;
sl@0	6216	CleanupStack::PushL( tempBuff );
sl@0	6217	#ifdef __MEM_CHECK_
sl@0	6218	PRINT((_L("CVDecTestEngine::CorruptEngine, mem alloc, tempBuff") ))
sl@0	6219	#endif
sl@0	6220	tmpPointer.Set(tempBuff->Des());
sl@0	6221
sl@0	6222	if( iFilter == 0 )
sl@0	6223	{
sl@0	6224	//Filter 0
sl@0	6225	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 0, In")))
sl@0	6226	tmpPointer.Set( aCodedInBuffer->iData );
sl@0	6227	PRINT((_L("Length of tmpPointer, %d"), tmpPointer.Length() ) )
sl@0	6228
sl@0	6229	TInt corruptLength = (TInt)( ( frameLength - 8 )* iPercentage / 100 );
sl@0	6230
sl@0	6231	TInt copyLength = frameLength - corruptLength;
sl@0	6232
sl@0	6233	TInt corruptLen = 0;
sl@0	6234
sl@0	6235	for( TInt i = copyLength; i < frameLength; i++ )
sl@0	6236	{
sl@0	6237	// Corrupt the byte by chaning its value instead of setting "zero"
sl@0	6238	if( tmpPointer[i] < 0x05 )
sl@0	6239	{
sl@0	6240	tmpPointer[i] += 0x05;
sl@0	6241	}
sl@0	6242	else
sl@0	6243	{
sl@0	6244	tmpPointer[i] -= 0x05;
sl@0	6245	}
sl@0	6246	corruptLen++;
sl@0	6247	}
sl@0	6248	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),[%d] bytes are corrupted"), corruptLen ) )
sl@0	6249
sl@0	6250	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 0, Out")))
sl@0	6251	}
sl@0	6252	else if( iFilter == 1)
sl@0	6253	{
sl@0	6254	// Filter 1
sl@0	6255	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 1, In")))
sl@0	6256	tmpPointer.Set( aCodedInBuffer->iData );
sl@0	6257	PRINT((_L("Length of tmpPointer, %d"), tmpPointer.Length() ) )
sl@0	6258	// To be added here
sl@0	6259	// first 8 bytes of each frame should not be corrupted
sl@0	6260	TInt headerLen = 8;
sl@0	6261
sl@0	6262	TInt increment = (TInt)( ( frameLength - headerLen )/ ( ( frameLength - headerLen) * iPercentage / 100) ) - 1;
sl@0	6263	TInt corruptLen = 0;
sl@0	6264	for(TInt i = headerLen + 1; i < frameLength; i += increment)
sl@0	6265	{
sl@0	6266	// Corrupt the byte by chaning its value instead of setting "zero"
sl@0	6267	if( tmpPointer[i] < 0x05 )
sl@0	6268	{
sl@0	6269	tmpPointer[i] += 0x05;
sl@0	6270	}
sl@0	6271	else
sl@0	6272	{
sl@0	6273	tmpPointer[i] -= 0x05;
sl@0	6274	}
sl@0	6275	// tmpPointer[i] = 0x00;
sl@0	6276	corruptLen ++;
sl@0	6277	}
sl@0	6278	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),[%d] bytes are corrupted"), corruptLen ) )
sl@0	6279
sl@0	6280	PRINT(_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 1, Out"))
sl@0	6281	}
sl@0	6282	else if( iFilter == 2)
sl@0	6283	{
sl@0	6284	PRINT(_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 2, In"))
sl@0	6285	tmpPointer.Set( aCodedInBuffer->iData );
sl@0	6286	PRINT((_L("Length of tmpPointer, %d"), tmpPointer.Length() ) )
sl@0	6287
sl@0	6288	TInt corruptLength = (TInt)( ( frameLength - 8 )* iPercentage / 100 );
sl@0	6289
sl@0	6290	//TInt copyLength = frameLength - corruptLength;
sl@0	6291	iFrameWriteLength -= corruptLength;
sl@0	6292	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),[%d] bytes are removed"), corruptLength ) )
sl@0	6293	// Modify the framesize value in the frame header
sl@0	6294	TUint32 finalSize = (TUint32)( iFrameWriteLength - 8 );
sl@0	6295	for( TInt i = 0; i < 3; i++ )
sl@0	6296	{
sl@0	6297	tmpPointer[i] = (TUint8) ( ( finalSize & ( (0x000000ff)<<(8i) ) )>> (i8) );
sl@0	6298	}
sl@0	6299	/* the above assignment equals followings
sl@0	6300	tmpPointer[0] = (TUint8)( finalSize & ~(0xffffff00) );
sl@0	6301	tmpPointer[1] = (TUint8)( ( finalSize & ~(0xffff00ff))>>8 );
sl@0	6302	tmpPointer[2] = (TUint8)( ( finalSize & ~(0xff00ffff))>>16 );
sl@0	6303	*/
sl@0	6304
sl@0	6305	PRINT(_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 2, Out"))
sl@0	6306	}
sl@0	6307	else // iFilter == 3
sl@0	6308	{
sl@0	6309	PRINT(_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 3, In"))
sl@0	6310	tmpPointer.Set( aCodedInBuffer->iData );
sl@0	6311	TInt corruptLength = (TInt)( ( frameLength - 8 )* iPercentage / 100 );
sl@0	6312
sl@0	6313	//TInt copyLength = frameLength - corruptLength;
sl@0	6314	iFrameWriteLength -= corruptLength;
sl@0	6315	// Modify the framesize value in the frame header
sl@0	6316	TUint32 finalSize = (TUint32)( iFrameWriteLength - 8 );
sl@0	6317	for( TInt i = 0; i < 3; i++ )
sl@0	6318	{
sl@0	6319
sl@0	6320	tmpPointer[i] = (TUint8) ( ( finalSize & ( (0x000000ff)<<(8i) ) )>> (i8) );
sl@0	6321	}
sl@0	6322	TInt headerLen = 8;
sl@0	6323	// Copy the other bytes for the header
sl@0	6324	for( TInt i = 3; i < headerLen; i++ )
sl@0	6325	{
sl@0	6326
sl@0	6327	tmpPointer[i] = aCodedInBuffer->iData[i];
sl@0	6328	}
sl@0	6329	TInt increment = (TInt)( ( frameLength - headerLen )/ ( ( frameLength - headerLen) * iPercentage / 100) ) - 1;
sl@0	6330	TInt incrementCounter = 0;
sl@0	6331	TInt byteCounter = 0;
sl@0	6332	TInt j = headerLen;
sl@0	6333	for( TInt i = headerLen; i < iFrameWriteLength; i++ )
sl@0	6334	{
sl@0	6335
sl@0	6336	// metadata assignment
sl@0	6337	tmpPointer[i] = aCodedInBuffer->iData[j];
sl@0	6338	if( byteCounter < corruptLength )
sl@0	6339	{
sl@0	6340	incrementCounter++;
sl@0	6341	}
sl@0	6342
sl@0	6343	j++;
sl@0	6344	if( incrementCounter == increment )
sl@0	6345	{
sl@0	6346	j++;
sl@0	6347	incrementCounter = 0;
sl@0	6348	byteCounter++;
sl@0	6349	}
sl@0	6350	}
sl@0	6351
sl@0	6352
sl@0	6353	PRINT(_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer),Filter 3, Out"))
sl@0	6354	}
sl@0	6355
sl@0	6356
sl@0	6357
sl@0	6358	aCodedInBuffer->iData.Set(tmpPointer);
sl@0	6359	if( iCorruptCounter == iFrameNum )
sl@0	6360	{
sl@0	6361	iFrameCounter = 0;
sl@0	6362	iCorruptCounter = 0;
sl@0	6363	}
sl@0	6364	CleanupStack::PopAndDestroy( tempBuff );
sl@0	6365	iMemDelete++;
sl@0	6366	#ifdef __MEM_CHECK_
sl@0	6367	PRINT((_L("CVDecTestEngine::CorrupEngineL, mem del, tempBuff") ))
sl@0	6368	#endif
sl@0	6369	PRINT((_L("CorruptEngineL(TVideoInputBuffer* aCodedInBuffer), Out")))
sl@0	6370	}
sl@0	6371
sl@0	6372
sl@0	6373
sl@0	6374	/* ----------------------------------------------------------------------------
sl@0	6375	* Name: CVDecTestEngine::CreateCorruptedFile()
sl@0	6376	* Purpose: Make the content in the buffer corrupted and output to a file
sl@0	6377	* Note:
sl@0	6378	* Parameters:
sl@0	6379	* Return: None
sl@0	6380	* --------------------------------------------------------------------------*/
sl@0	6381
sl@0	6382	TInt CVDecTestEngine::CreateCorruptedFileL()
sl@0	6383	{
sl@0	6384	PRINT((_L("CVDecTestEngine::CreateCorruptedFileL, In")));
sl@0	6385	// Only support VC-1 decoder
sl@0	6386
sl@0	6387	// make new buffer for the data read from the file
sl@0	6388	HBufC8* tmpBuff = NULL;
sl@0	6389
sl@0	6390	TVideoInputBuffer* codedBuffer = new(ELeave) TVideoInputBuffer;
sl@0	6391	CleanupStack::PushL( codedBuffer );
sl@0	6392
sl@0	6393	tmpBuff = HBufC8::NewL(iInBuffSize);
sl@0	6394	CleanupStack::PushL( tmpBuff );
sl@0	6395	codedBuffer->iData.Set(tmpBuff->Des());
sl@0	6396	// read content of the file in the buffer
sl@0	6397	TInt err = 0;
sl@0	6398
sl@0	6399	TInt frameDropNumCounter = 0;
sl@0	6400	while ( !iInputEnd )
sl@0	6401	{
sl@0	6402	// Read the VC1 input video from the very beginning
sl@0	6403	if( iCodecType == EVC1)
sl@0	6404	{
sl@0	6405	err = ReadVC1FrameL( codedBuffer );
sl@0	6406	}
sl@0	6407	else if( iCodecType == EMPEG4 )
sl@0	6408	{
sl@0	6409	err = ReadMPEG4FrameL( codedBuffer );
sl@0	6410	}
sl@0	6411	else
sl@0	6412	{
sl@0	6413
sl@0	6414	}
sl@0	6415
sl@0	6416
sl@0	6417	if( err < 0)
sl@0	6418	{
sl@0	6419	PRINT((_L("CVDecTestEngine::CreateCorruptedFileL, Error reading file") ))
sl@0	6420	return KErrGeneral;
sl@0	6421	}
sl@0	6422	if( err == 0 )
sl@0	6423	{
sl@0	6424	PRINT((_L("CVDecTestEngine::LoadNextFrameL, End of file is found") ))
sl@0	6425	break;
sl@0	6426	}
sl@0	6427	else
sl@0	6428	{
sl@0	6429	// the frame is successfully read and ready to be corrupted
sl@0	6430
sl@0	6431	// make some bytes corrupted
sl@0	6432	if( !iFrameDropMarker )
sl@0	6433	{
sl@0	6434	CorruptEngineL( codedBuffer );
sl@0	6435	PRINT((_L("Corruption is done")));
sl@0	6436	}
sl@0	6437	}
sl@0	6438
sl@0	6439	// Prepare a buffer for copying the bytes from the frame buffer
sl@0	6440	/*
sl@0	6441	TInt copyLen = codedBuffer->iData.Size();
sl@0	6442
sl@0	6443	TUint8* memorySeg = NULL;
sl@0	6444	TPtr8 segCopy(memorySeg,copyLen);
sl@0	6445	HBufC8* segBuff = NULL;
sl@0	6446	segBuff = HBufC8::NewL( copyLen );
sl@0	6447	CleanupStack::PushL( segBuff );
sl@0	6448	segCopy.Set(segBuff->Des());
sl@0	6449	*/
sl@0	6450	if( iFrameDropMarker )
sl@0	6451	{
sl@0	6452	iFrameWriteLength = codedBuffer->iData.Length();
sl@0	6453	// drop the frame specified by the user
sl@0	6454	if( iFrameDropCounter < iFrameDropInterval )
sl@0	6455	{
sl@0	6456	PRINT((_L("CVDecTestEngine::CreateCorruptedFileL,iFrameWriteLength [%d]"), iFrameWriteLength ) )
sl@0	6457	err = iOutCorruptedFile.Write(codedBuffer->iData, iFrameWriteLength );
sl@0	6458	PRINT((_L("Output to the file for frame drop successful")));
sl@0	6459	if ( err!= KErrNone )
sl@0	6460	{
sl@0	6461	PRINT((_L("Output corrupted File write Failed")));
sl@0	6462	iOutCorruptedFile.Close();
sl@0	6463	}
sl@0	6464
sl@0	6465
sl@0	6466
sl@0	6467	}
sl@0	6468	else
sl@0	6469	{
sl@0	6470	frameDropNumCounter++;
sl@0	6471	PRINT((_L("Frame is dropped!")));
sl@0	6472	}
sl@0	6473
sl@0	6474	if( frameDropNumCounter == iFrameDropNum )
sl@0	6475	{
sl@0	6476	iFrameDropCounter = 0;
sl@0	6477	frameDropNumCounter = 0;
sl@0	6478	}
sl@0	6479	}
sl@0	6480	else //write corrupted frame to the file
sl@0	6481	{
sl@0	6482	// Prepare a buffer for copying the bytes from the frame buffer
sl@0	6483	/* TInt copyLen = codedBuffer->iData.Size();
sl@0	6484
sl@0	6485	TUint8* memorySeg = NULL;
sl@0	6486	TPtr8 segCopy(memorySeg,copyLen);
sl@0	6487	HBufC8* segBuff = NULL;
sl@0	6488	segBuff = HBufC8::NewL( copyLen );
sl@0	6489	CleanupStack::PushL( segBuff );
sl@0	6490	segCopy.Set(segBuff->Des());
sl@0	6491
sl@0	6492	*/
sl@0	6493	PRINT((_L("CVDecTestEngine::CreateCorruptedFileL,iFrameWriteLength [%d]"), iFrameWriteLength ) )
sl@0	6494	err = iOutCorruptedFile.Write(codedBuffer->iData, iFrameWriteLength );
sl@0	6495
sl@0	6496	if ( err!= KErrNone )
sl@0	6497	{
sl@0	6498	PRINT((_L("Output corrupted File write Failed")));
sl@0	6499	iOutCorruptedFile.Close();
sl@0	6500	}
sl@0	6501	PRINT((_L("Output corrupted File is successful")));
sl@0	6502
sl@0	6503	}
sl@0	6504
sl@0	6505	}
sl@0	6506	iOutCorruptedFile.Close();
sl@0	6507	CleanupStack::PopAndDestroy( tmpBuff );
sl@0	6508	CleanupStack::PopAndDestroy( codedBuffer );
sl@0	6509	PRINT((_L("CVDecTestEngine::CreateCorruptedFileL, Out")));
sl@0	6510	return KErrNone;
sl@0	6511	}
sl@0	6512
sl@0	6513	/* ----------------------------------------------------------------------------
sl@0	6514	* Name: CVDecTestEngine::OpenFileToWriteL()
sl@0	6515	* Purpose: Open output File To Write
sl@0	6516	* Note: Memory buffer output is used
sl@0	6517	* Parameters: TFileName& aOutFileName
sl@0	6518	* Return: None
sl@0	6519	* --------------------------------------------------------------------------*/
sl@0	6520
sl@0	6521
sl@0	6522	void CVDecTestEngine::OpenFileToWriteL(TFileName& aInFileName)
sl@0	6523	{
sl@0	6524	PRINT((_L("CVDecTestEngine::OpenFileToWrite, In")));
sl@0	6525	TInt err = KErrNone;
sl@0	6526
sl@0	6527	iOutCorruptedFileName.Copy(aInFileName);
sl@0	6528
sl@0	6529	err = iOutCorruptedFile.Replace(iFs, iOutCorruptedFileName, EFileShareExclusive\|EFileWrite);
sl@0	6530
sl@0	6531	iOutCorruptedFileOpen = ETrue;
sl@0	6532
sl@0	6533
sl@0	6534	if ( err!= KErrNone )
sl@0	6535	{
sl@0	6536	PRINT((_L("CVDecTestEngine::OpenFileToWrite, Output corrupted File Replace Failed")));
sl@0	6537	iOutCorruptedFile.Close();
sl@0	6538	}
sl@0	6539
sl@0	6540	AssertTIntEqualL(KErrNone,err);
sl@0	6541	PRINT((_L("CVDecTestEngine::OpenFileToWrite, Out")));
sl@0	6542	}
sl@0	6543
sl@0	6544
sl@0	6545	/* ----------------------------------------------------------------------------
sl@0	6546	* Name: CVDecTestEngine::ReadVC1FrameL()
sl@0	6547	* Purpose:
sl@0	6548	* Note:
sl@0	6549	* Parameters: None
sl@0	6550	* Return: None
sl@0	6551	* --------------------------------------------------------------------------*/
sl@0	6552
sl@0	6553	TInt CVDecTestEngine::ReadVC1FrameL(TVideoInputBuffer* aCodedInBuffer)
sl@0	6554	{
sl@0	6555	// Note: this function is used as part of corrupt engine to make input
sl@0	6556	// VC1 video corrupted for codec robustness test
sl@0	6557	// Reading VC1 input video from the very beginning of the file
sl@0	6558	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, In")));
sl@0	6559	unsigned int frameDataSize = 4; //4 Bytes to obain the framesize
sl@0	6560	unsigned int frameSize=0;
sl@0	6561	unsigned int Timestamp;
sl@0	6562	TInt err = 0;
sl@0	6563	TUint8* ptr = new (ELeave) TUint8[frameDataSize];
sl@0	6564	iMemAlloc++;
sl@0	6565	#ifdef __MEM_CHECK_
sl@0	6566	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, mem alloc, ptr") ))
sl@0	6567	#endif
sl@0	6568	TPtr8 frameData(ptr, frameDataSize);
sl@0	6569	if ( (err = iInFile.Read(frameData, frameDataSize)) != KErrNone)
sl@0	6570	{
sl@0	6571	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Error reading file") ))
sl@0	6572	return err;
sl@0	6573	}
sl@0	6574
sl@0	6575	if (frameData.Length() < 4)
sl@0	6576	{
sl@0	6577	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, File end found") ))
sl@0	6578	aCodedInBuffer->iData.SetLength( 0 );
sl@0	6579	delete ptr;
sl@0	6580	ptr = NULL;
sl@0	6581	iMemDelete++;
sl@0	6582	iInputEnd = ETrue;
sl@0	6583	return KErrNone;
sl@0	6584	}
sl@0	6585
sl@0	6586	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Reading Item") ))
sl@0	6587	ReadItemLE(ptr, 4, (TUint8 *)&frameSize);
sl@0	6588	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, before AND frameSize: %x"), frameSize ))
sl@0	6589
sl@0	6590	//RCV_V2_FRAMESIZE_FLAGS
sl@0	6591	frameSize = frameSize & ~(0xff000000);
sl@0	6592
sl@0	6593	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, frameSize: %d"), frameSize ))
sl@0	6594
sl@0	6595	//Now obtain the Timestamp of the frame
sl@0	6596	if ( (err = iInFile.Read(frameData, frameDataSize)) != KErrNone)
sl@0	6597	{
sl@0	6598	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Error reading file %d"), err ))
sl@0	6599	return err;
sl@0	6600	}
sl@0	6601
sl@0	6602	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Reading Item2") ))
sl@0	6603	ReadItemLE(ptr, 4, (TUint8 *)&Timestamp);
sl@0	6604	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Timestamp: %d"), Timestamp ))
sl@0	6605	delete ptr;
sl@0	6606	iMemDelete++;
sl@0	6607	#ifdef __MEM_CHECK_
sl@0	6608	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, mem del, ptr") ))
sl@0	6609	#endif
sl@0	6610	if (frameSize != 0)
sl@0	6611	{
sl@0	6612	//Send metadata in the first frame
sl@0	6613	if (iFrame==0)
sl@0	6614	{
sl@0	6615	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, iFrame num == 0, %d"), iFrame ))
sl@0	6616	TInt pos = - ( KVc1HeaderLength + 8 ); // assume the codec is configured
sl@0	6617	err = iInFile.Seek(ESeekCurrent,pos);
sl@0	6618
sl@0	6619	// header length is 36, KVc1HeaderLength = 36
sl@0	6620	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, file header, 36 bytes")))
sl@0	6621	if ( (err = iInFile.Read(aCodedInBuffer->iData, KVc1HeaderLength)) != KErrNone)
sl@0	6622	{
sl@0	6623	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Error reading file %d"), err ))
sl@0	6624	return err;
sl@0	6625	}
sl@0	6626
sl@0	6627	}
sl@0	6628	else
sl@0	6629	{
sl@0	6630	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, iFrame num = %d"), iFrame ))
sl@0	6631	TInt pos = -8;
sl@0	6632	err = iInFile.Seek(ESeekCurrent, pos);
sl@0	6633	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, read file: %d"), err ))
sl@0	6634	if ( (err = iInFile.Read(aCodedInBuffer->iData, frameSize+8)) != KErrNone)
sl@0	6635	{
sl@0	6636	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, Error reading file %d"), err ))
sl@0	6637	return err;
sl@0	6638	}
sl@0	6639	}
sl@0	6640
sl@0	6641	TInt currentPos = 0;
sl@0	6642	iInFile.Seek(ESeekCurrent, currentPos );
sl@0	6643	PRINT((_L("CVDecTestEngine::ReadVC1FrameL, currentPos %d"), currentPos ))
sl@0	6644	currentPos = 0;
sl@0	6645
sl@0	6646	/* Not necessary
sl@0	6647	aCodedInBuffer->iSequenceNumber = iFrame;
sl@0	6648	aCodedInBuffer->iOptions = TVideoInputBuffer::EPresentationTimestamp;
sl@0	6649
sl@0	6650	aCodedInBuffer->iPresentationTimestamp = Timestamp;
sl@0	6651	iTimeToPlay = aCodedInBuffer->iPresentationTimestamp ;
sl@0	6652
sl@0	6653
sl@0	6654	aCodedInBuffer->iDecodingTimestamp = Timestamp;
sl@0	6655	iPresentationTimestamp = aCodedInBuffer->iPresentationTimestamp ;
sl@0	6656	*/
sl@0	6657
sl@0	6658
sl@0	6659	}
sl@0	6660
sl@0	6661	iFrame++;
sl@0	6662	iFrameDropCounter++;
sl@0	6663	PRINT(_L("CVDecTestEngine::ReadVC1FrameL.. Out"));
sl@0	6664	return frameSize;
sl@0	6665	}
sl@0	6666
sl@0	6667
sl@0	6668
sl@0	6669	/* ----------------------------------------------------------------------------
sl@0	6670	* Name: CVDecTestEngine::ReadMPEG4FrameL()
sl@0	6671	* Purpose:
sl@0	6672	* Note:
sl@0	6673	* Parameters: None
sl@0	6674	* Return: None
sl@0	6675	* --------------------------------------------------------------------------*/
sl@0	6676
sl@0	6677	TInt CVDecTestEngine::ReadMPEG4FrameL(TVideoInputBuffer* aCodedInBuffer)
sl@0	6678	{
sl@0	6679	// Note: this function is used as part of corrupt engine to make input
sl@0	6680	// MPEG4 video corrupted for codec robustness test
sl@0	6681	// Reading MPEG4 input video from the very beginning of the file
sl@0	6682	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, In")));
sl@0	6683	TInt buffLength = iInBuffSize;
sl@0	6684
sl@0	6685	//TUint8* testData =NULL;
sl@0	6686	TInt err = KErrNone;
sl@0	6687
sl@0	6688	if ( aCodedInBuffer->iData.MaxLength() < buffLength )
sl@0	6689	{
sl@0	6690	err = KErrOverflow;
sl@0	6691	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, Buffer is small, [%d]Byte"),aCodedInBuffer->iData.MaxLength()))
sl@0	6692	return err;
sl@0	6693	}
sl@0	6694
sl@0	6695	aCodedInBuffer->iData.SetLength(0);
sl@0	6696
sl@0	6697	//Buffer is not full, reset size of buffer
sl@0	6698	if ( aCodedInBuffer->iData.Length() < buffLength)
sl@0	6699	{
sl@0	6700	buffLength = aCodedInBuffer->iData.Length();
sl@0	6701	}
sl@0	6702
sl@0	6703
sl@0	6704
sl@0	6705	TInt pos = 0;
sl@0	6706	TBool found = EFalse;
sl@0	6707	TBool firstStartCode = EFalse;
sl@0	6708	//TUint8 byte = 0;
sl@0	6709	TInt currentPos = 0;
sl@0	6710	iInFile.Seek(ESeekCurrent, currentPos );
sl@0	6711	if( currentPos != 0 && currentPos == iCurrentFilePos )
sl@0	6712	{
sl@0	6713	iInputEnd = ETrue;
sl@0	6714	}
sl@0	6715	else
sl@0	6716	{
sl@0	6717	iCurrentFilePos = currentPos;
sl@0	6718	}
sl@0	6719	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, currentPos %d"), currentPos ))
sl@0	6720	while (!iInputEnd && !found)
sl@0	6721	{
sl@0	6722	TInt zeroCounter = 0;
sl@0	6723	err = iInFile.Read(aCodedInBuffer->iData, 1 ); // read one byte
sl@0	6724	if( aCodedInBuffer->iData.Length() == 0 )
sl@0	6725	{
sl@0	6726	pos++;
sl@0	6727	iInputEnd = ETrue;
sl@0	6728	break;
sl@0	6729	}
sl@0	6730
sl@0	6731	while( aCodedInBuffer->iData[0] == 0x00 && !iInputEnd )
sl@0	6732	{
sl@0	6733	zeroCounter++;
sl@0	6734	pos++;
sl@0	6735	err = iInFile.Read(aCodedInBuffer->iData, 1 ); // read one byte
sl@0	6736	}
sl@0	6737	pos++;
sl@0	6738	if ((zeroCounter >= 2) && (aCodedInBuffer->iData[0] == 0x01))
sl@0	6739	{
sl@0	6740	//byte = ReadByteFromFile();
sl@0	6741	err = iInFile.Read(aCodedInBuffer->iData, 1 ); // read one byte
sl@0	6742	//PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, iData %d, f2"), aCodedInBuffer->iData[0] ))
sl@0	6743	pos++;
sl@0	6744	//if (byte == 0xB6 && !firstStartCode)
sl@0	6745	if( aCodedInBuffer->iData[0] == 0xB6 && !firstStartCode )
sl@0	6746	{
sl@0	6747	firstStartCode = ETrue;
sl@0	6748	}
sl@0	6749	//else if (byte != 0xB1 && firstStartCode)
sl@0	6750	else if( aCodedInBuffer->iData[0]!= 0xB1 && firstStartCode )
sl@0	6751	{
sl@0	6752	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, end of mpeg-4 picture found [%d]"), pos-4))
sl@0	6753	found = ETrue;
sl@0	6754	}
sl@0	6755	}
sl@0	6756	}
sl@0	6757	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, pos (read length), %d"), pos))
sl@0	6758	TInt backward = 0 - pos;
sl@0	6759	err = iInFile.Seek(ESeekCurrent, backward );// go back
sl@0	6760
sl@0	6761	if( err != KErrNone)
sl@0	6762	{
sl@0	6763	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, Error seeking file %d"), err ))
sl@0	6764	return err;
sl@0	6765	}
sl@0	6766
sl@0	6767	if (iInputEnd)
sl@0	6768	{
sl@0	6769	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, inputEndFound, %d"), pos))
sl@0	6770	pos--;
sl@0	6771	}
sl@0	6772	else
sl@0	6773	{
sl@0	6774	pos -= 4;
sl@0	6775	}
sl@0	6776
sl@0	6777
sl@0	6778	currentPos = 0;
sl@0	6779	err = iInFile.Seek( ESeekCurrent, currentPos);
sl@0	6780	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, position goes back to the beginning, %d"), currentPos))
sl@0	6781	if ( (err = iInFile.Read(aCodedInBuffer->iData, pos )) != KErrNone)
sl@0	6782	{
sl@0	6783	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, Error reading file %d"), err ))
sl@0	6784	return err;
sl@0	6785	}
sl@0	6786	if( aCodedInBuffer->iData.Length() < 4 )
sl@0	6787	{
sl@0	6788	iInputEnd = ETrue;
sl@0	6789	}
sl@0	6790	iFrameDropCounter++;
sl@0	6791	iFrame++;
sl@0	6792	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, iFrameDropCounter, %d"), iFrameDropCounter))
sl@0	6793	PRINT((_L("CVDecTestEngine::ReadMPEG4FrameL, Out")));
sl@0	6794	return pos;
sl@0	6795	}
sl@0	6796
sl@0	6797	/* ----------------------------------------------------------------------------
sl@0	6798	* Name: CVDecTestEngine::SetFrameDrop()
sl@0	6799	* Purpose:
sl@0	6800	* Note:
sl@0	6801	* Parameters: TInt aFrameInterval, TInt aFrameNum, TBool aFrameDropMarker
sl@0	6802	* Return: None
sl@0	6803	* --------------------------------------------------------------------------*/
sl@0	6804
sl@0	6805	void CVDecTestEngine::SetFrameDrop(TInt aFrameInterval, TInt aFrameNum, TBool aFrameDropMarker )
sl@0	6806	{
sl@0	6807	PRINT(_L("CVDecTestEngine::SetFrameDrop, In"));
sl@0	6808
sl@0	6809
sl@0	6810	iFrameDropInterval = aFrameInterval;
sl@0	6811	iFrameDropNum = aFrameNum;
sl@0	6812	iFrameDropMarker = aFrameDropMarker;
sl@0	6813
sl@0	6814
sl@0	6815	PRINT(_L("CVDecTestEngine::SetFrameDrop, Out"));
sl@0	6816	}
sl@0	6817
sl@0	6818	/* ----------------------------------------------------------------------------
sl@0	6819	* Name: CVDecTestEngine::SetFLVPassword()
sl@0	6820	* Purpose:
sl@0	6821	* Note:
sl@0	6822	* Parameters: TDesC8& aPassword
sl@0	6823	* Return: None
sl@0	6824	* --------------------------------------------------------------------------*/
sl@0	6825	void CVDecTestEngine::SetFLVPassword(TDesC8& aPassword)
sl@0	6826	{
sl@0	6827	PRINT(_L("CVDecTestEngine::SetFLVPassword, In"));
sl@0	6828
sl@0	6829	_LIT8(KNullTerminate, "\0");
sl@0	6830	iSetPassword = ETrue;
sl@0	6831	iPasswordForFLV.Copy( aPassword);
sl@0	6832	iPasswordForFLV.Append( KNullTerminate );
sl@0	6833	TBuf16<128> passwordPrint;
sl@0	6834	passwordPrint.Copy( iPasswordForFLV );
sl@0	6835
sl@0	6836	PRINT((_L("CVDecTestEngine::SetFLVPassword, iPasswordForFLV [%S]"), &passwordPrint))
sl@0	6837	PRINT(_L("CVDecTestEngine::SetFLVPassword, Out"));
sl@0	6838
sl@0	6839	}
sl@0	6840
sl@0	6841	/* ----------------------------------------------------------------------------
sl@0	6842	* Name: CVDecTestEngine::EnablingInstantFpsL()
sl@0	6843	* Purpose:
sl@0	6844	* Note:
sl@0	6845	* Parameters: TFileName& aOutFileName
sl@0	6846	* Return: None
sl@0	6847	* --------------------------------------------------------------------------*/
sl@0	6848	void CVDecTestEngine::EnableInstantFpsL(TFileName& aOutFileName)
sl@0	6849	{
sl@0	6850	TInt err = KErrNone;
sl@0	6851	if (!iFrameMeasurement)
sl@0	6852	{
sl@0	6853
sl@0	6854	PRINT((_L("CVDecTestEngine::EnableInstantFpsL(), Frame measurement is not enabled")))
sl@0	6855
sl@0	6856	User::Leave(KErrGeneral);
sl@0	6857	}
sl@0	6858
sl@0	6859	err = iFpsFile.Replace(iFs, aOutFileName, EFileShareExclusive\|EFileWrite);
sl@0	6860
sl@0	6861	if ( err != KErrNone)
sl@0	6862	{
sl@0	6863	PRINT((_L("CVDecTestEngine::EnableInstantFpsL, Output File open Failed")));
sl@0	6864	User::Leave(err);
sl@0	6865	}
sl@0	6866
sl@0	6867	iInstantFpsEnabled = ETrue;
sl@0	6868	}
sl@0	6869
sl@0	6870	/* ----------------------------------------------------------------------------
sl@0	6871	* Name: CVDecTestEngine::SetSecondScreenAccess
sl@0	6872	* Purpose: Set second screen
sl@0	6873	* Note:
sl@0	6874	* Parameters: TBool aStatus
sl@0	6875	* Return: None
sl@0	6876	* --------------------------------------------------------------------------*/
sl@0	6877	void CVDecTestEngine::SetSecondScreenAccess(TBool aStatus)
sl@0	6878	{
sl@0	6879	iUseSecondScreen = aStatus;
sl@0	6880	}
sl@0	6881	// End of File

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--