diff -r 000000000000 -r 5d29cba61097 omxilvideocomps/omxilgraphicsink/tsrc/src/graphicsinktestbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omxilvideocomps/omxilgraphicsink/tsrc/src/graphicsinktestbase.cpp Fri Oct 08 22:09:17 2010 +0100 @@ -0,0 +1,1882 @@ +/* +* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +#include "graphicsinktestbase.h" +#include +#include +#include + +const TInt MAXNUMOFBUFFERS = 30; // Due to the size of buffers we limit the max number of buffers + +/* + * There are known issues due to limitations in the OMX core with tests that repeatedly load + * and unload buffers. If left to run until the timer runs out they inevitably end up failing + * and causing problems for subsequent test steps due to iffy clean-up. This constant is therefore + * used to limit the amount of test iterations to a "safe" number. + */ +const TInt KMaxTestIterations = 25; + +CGraphicsSinkTestBase::CGraphicsSinkTestBase() + { + iTestIteration = 0; + iTestTimedOut = EFalse; + iWaitForResources = EFalse; + iExecuteToIdleCount = 0; + iDoEmptyBufferDoneLimit = 20; + iExecutingToIdle = ETrue; + iDoEmptyBufferDoneCount = 0; + iIdleToExecuteCount = 0; + iPauseStateCount = 0; + } + +CGraphicsSinkTestBase::~CGraphicsSinkTestBase() + { + + } + +void CGraphicsSinkTestBase::WaitForEvent(OMX_EVENTTYPE aEvent) + { + INFO_PRINTF2(_L("Wait for event %d cmd"),aEvent); + iEventToWaitFor = aEvent; + CActiveScheduler::Start(); + } + +void CGraphicsSinkTestBase::DoFillBufferDone(OMX_HANDLETYPE /*aComponent*/,OMX_BUFFERHEADERTYPE* /*aBufferHeader*/) + { + // Should never be called as graphic sink does not support this + INFO_PRINTF1(_L("CGraphicsSinkTestBase::DoFillBufferDone")); + } + +void CGraphicsSinkTestBase::DoEmptyBufferDone(OMX_HANDLETYPE aComponent,OMX_BUFFERHEADERTYPE* aBufferHeader) + { + // INFO_PRINTF3(_L("CGraphicsSinkTestBase::DoEmptyBufferDone: Count %d Limit %d"), iDoEmptyBufferDoneCount,iDoEmptyBufferDoneLimit); + + //INFO_PRINTF2(_L("CGraphicsSinkTestBase::DoEmptyBufferDone: Received pBuffer 0x%08x"), aBufferHeader->pBuffer ); + + TInt error = iInputBufferHeaders.Append(aBufferHeader); + if (error != KErrNone) + { + ERR_PRINTF1(_L("OOM ERROR")); + CActiveScheduler::Stop(); + return SetTestStepError(error); + } + + if (iIgnoreNextBufferDone) + { + iIgnoreNextBufferDone = EFalse; + return; + } + + if (iInputBufferHeaders.Count() == 0) + { + ERR_PRINTF1(_L("iInputBufferHeaders count has dropped to 0")); + CActiveScheduler::Stop(); + return SetTestStepResult(EFail); + } + + iDoEmptyBufferDoneCount++; + + OMX_COMPONENTTYPE* comp = static_cast(aComponent); + + if (iTestCase == 10) + { + if ((iDoEmptyBufferDoneCount < iDoEmptyBufferDoneLimit || iDoEmptyBufferDoneLimit == 0) && !iTestTimedOut) + { + iInputBufferHeader = iInputBufferHeaders[0]; + iInputBufferHeaders.Remove(0); + + iInputBufferHeader->nFilledLen = iOmxParamPortInput.format.video.nFrameWidth * + COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat) * + iOmxParamPortInput.format.video.nFrameHeight; + + iInputBufferHeader->nFlags = OMX_BUFFERFLAG_SYNCFRAME; + + iOmxErrorType = comp->EmptyThisBuffer(comp,iInputBufferHeader); + if (OMX_ErrorNone != iOmxErrorType) + { + ERR_PRINTF1(_L("EmptyThisBuffer returned an error")); + PrintOmxError(iOmxErrorType); + return SetTestStepError(iOmxErrorType); + } + + if (iTestStep == 6) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + } + } + else + { + iDoEmptyBufferDoneCount = 0; + iIgnoreNextBufferDone = ETrue; + if (iTestStep != 5 && iTestStep != 6) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + } + } + } + else + { + if (TestStepName() == (_L("MMVIDEO-OMX-GS-005-05-HP"))) + { + iDoEmptyBufferDoneCount = 0; + } + + if (iDoEmptyBufferDoneCount < iDoEmptyBufferDoneLimit && !iTestTimedOut) + { + //INFO_PRINTF2(_L("CGraphicsSinkTestBase::DoEmptyBufferDone: Sending pBuffer 0x%08x"), iInputBufferHeaders[0]->pBuffer ); + + iInputBufferHeader = iInputBufferHeaders[0]; + iInputBufferHeaders.Remove(0); + + TInt bytesperpixel = COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat); + iInputBufferHeader->nFilledLen = iOmxParamPortInput.format.video.nFrameWidth * bytesperpixel * + iOmxParamPortInput.format.video.nFrameHeight; + iInputBufferHeader->nOffset = aBufferHeader->nOffset; + iInputBufferHeader->nFlags = OMX_BUFFERFLAG_SYNCFRAME; + + iOmxErrorType = comp->EmptyThisBuffer(comp,iInputBufferHeader); + if (OMX_ErrorNone != iOmxErrorType) + { + ERR_PRINTF1(_L("EmptyThisBuffer returned an error")); + PrintOmxError(iOmxErrorType); + return SetTestStepError(iOmxErrorType); + } + } + else + { + iDoEmptyBufferDoneCount = 0; + iIgnoreNextBufferDone = ETrue; + if (TestStepName() != (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + if (iExecutingToIdle) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + } + else + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StatePause,0); + } + } + } + } + } + + +TVerdict CGraphicsSinkTestBase::DoGSCompAllocTestL() + { + TVerdict result = EPass; + + // Create a callback handler, graphic sink handle and destroy it + iError = OMX_Init(); + if(iError != OMX_ErrorNone) + { + iError = OMX_Deinit(); + User::Leave(KErrNoMemory); + } + + delete iCallbackHandler; + iCallbackHandler = NULL; + TRAPD(error, iCallbackHandler = CCallbackHandler::NewL(*this)); + + if (!error) + { + OMX_CALLBACKTYPE* omxCallbacks = *iCallbackHandler; + OMX_PTR appData = iCallbackHandler; + OMX_HANDLETYPE graphicsSinkHandle = NULL; + OMX_STRING graphicsSinkComponentName = "OMX.SYMBIAN.VIDEO.GRAPHICSINK"; + + iError = OMX_GetHandle( + &graphicsSinkHandle, + graphicsSinkComponentName, + appData, + omxCallbacks); + + if (iError == OMX_ErrorNone) + { + iGraphicSinkCompHandle = (OMX_COMPONENTTYPE*)graphicsSinkHandle; + OMX_FreeHandle(iGraphicSinkCompHandle); + delete iCallbackHandler; + iCallbackHandler = NULL; + iError = OMX_Deinit(); + if(iError != OMX_ErrorNone) + { + User::Leave(KErrGeneral); + } + } + else + { + result = EFail; + PrintOmxError(iError); + ERR_PRINTF2(_L("Unexpected %d return OMX_GetHandle"), iError); + delete iCallbackHandler; + iCallbackHandler = NULL; + iError = OMX_Deinit(); + User::Leave(KErrNoMemory); + } + } + else + { + ERR_PRINTF2(_L("Unexpected %d return CCallbackHandler::NewL()"), iError); + result = EFail; + iError = OMX_Deinit(); + User::Leave(KErrNoMemory); + } + + return result; + } + + +void CGraphicsSinkTestBase::DoEventHandler(OMX_HANDLETYPE aComponent, OMX_EVENTTYPE aEvent, + TUint aData1, TUint aData2, TAny* aExtra) + { +/* OMX_COMPONENTTYPE* comp = static_cast(aComponent); + if (comp == iCameraSourceCompHandle && + aEvent == OMX_EventCmdComplete && + aData1 == OMX_CommandPortDisable && + (aData2 == KCameraVCPortIndex || aData2 == KCameraClockPortIndex)) + { + return; + } +*/ + OMX_ERRORTYPE errorEvent = static_cast( aData1 ); + + switch (aEvent) + { + case OMX_EventError: + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-001-01-HP"))) + { + ErrorEventTask_001(errorEvent); + } + else + { + switch (errorEvent) + { + case OMX_ErrorFormatNotDetected: + { + // INFO_PRINTF1(_L("DoEventHandler: OMX_EventError [OMX_ErrorFormatNotDetected]")); + PrintOmxError(OMX_ErrorFormatNotDetected); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + case OMX_ErrorIncorrectStateOperation: + { + // INFO_PRINTF1(_L("DoEventHandler: OMX_EventError [OMX_ErrorIncorrectStateOperation]")); + if(TestStepName() == (_L("MMVIDEO-OMX-GS-002-04-HP"))) + { + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + CActiveScheduler::Stop(); + return SetTestStepError(PrintOmxError(OMX_ErrorIncorrectStateOperation)); + } + case OMX_ErrorInvalidState: + { + // INFO_PRINTF1(_L("DoEventHandler: OMX_EventError [OMX_ErrorInvalidState]")); + CActiveScheduler::Stop(); + PrintOmxError(OMX_ErrorInvalidState); + return SetTestStepError(KErrGeneral); + } + case OMX_ErrorPortUnpopulated: + { + // INFO_PRINTF1(_L("DoEventHandler: OMX_EventError [OMX_ErrorPortUnpopulated]")); + if (TestStepName() == (_L("MMVIDEO-OMX-GS-006-02-HP"))) + { + if (--iInputBufferHeadersCount == 0) + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + default: + { + INFO_PRINTF2(_L("DoEventHandler: OMX_EventError [%d]"), aData1); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + } + } + } + case OMX_EventBufferFlag: + { + break; + } + case OMX_EventCmdComplete: + { + InitiateNextStateTransition(aComponent, aData1, aData2, aExtra); + break; + } + case OMX_EventPortSettingsChanged: + { + if(iEventToWaitFor == aEvent) + { + iEventToWaitFor = OMX_EventMax; + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + else + { + UpdateSettingChanged(aComponent, aData1, aData2, aExtra); + } + break; + } + + /* case OMX_EventNokiaFirstFrameDisplayed: + { + break; + }*/ + + default: + { + INFO_PRINTF2(_L("DoEventHandler: OMX Event [%d]"), aEvent); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + } + } + +void CGraphicsSinkTestBase::InitiateNextStateTransition(OMX_HANDLETYPE /*aComponent*/, TUint /*aData1*/, + TUint aData2, TAny* /*aExtra*/) + { + switch(aData2) + { + case OMX_StateLoaded: + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-002-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-002-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-002-03-HP"))) + { + LoadedStateTask_002(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-003-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-003-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-003-03-HP"))) + { + LoadedStateTask_003(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-004-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-04-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-05-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + LoadedStateTask_004(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-005-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-005-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-005-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-005-04-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-005-05-HP"))) + { + LoadedStateTask_005(); + } + else + { + if (TestStepName() == (_L("MMVIDEO-OMX-GS-006-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-006-02-HP"))) + { + LoadedStateTask_006(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-007-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-02-HP")) || + TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-04-HP"))) + { + LoadedStateTask_007(); + } + else + { + if (iTestCase == 9) + { + LoadedStateTransitionTask(); + } + else + { + if (iTestCase == 10) + { + LoadedStateBufferTask(); + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::DoEventHandler State set to OMX_StateLoaded")); + } + } + } + } + } + } + } + } + break; + } + case OMX_StateWaitForResources: + { + if (iTestCase == 9) + { + WaitForResourcesTransitionTask(); + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::DoEventHandler State set to OMX_StateWaitForResources")); + } + break; + } + case OMX_StateIdle: + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-002-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-002-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-002-03-HP"))) + { + IdleStateTask_002(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-003-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-003-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-003-03-HP"))) + { + IdleStateTask_003(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-004-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-04-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-05-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + IdleStateTask_004(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-005-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-005-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-005-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-005-04-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-005-05-HP"))) + { + IdleStateTask_005(); + } + else + { + if (TestStepName() == (_L("MMVIDEO-OMX-GS-006-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-006-02-HP"))) + { + IdleStateTask_006(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-007-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-02-HP")) || + TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-04-HP"))) + { + IdleStateTask_007(); + } + else + { + if (iTestCase == 9) + { + IdleStateTransitionTask(); + } + else + { + if (iTestCase == 10) + { + IdleStateBufferTask(); + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::DoEventHandler State set to OMX_StateIdle")); + } + } + } + } + } + } + } + } + break; + } + case OMX_StateExecuting: + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-004-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-04-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-05-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + ExecutingStateTask_004(); + } + else + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-005-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-005-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-005-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-005-04-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-005-05-HP"))) + { + ExecutingStateTask_005(); + } + else + { + if (TestStepName() == (_L("MMVIDEO-OMX-GS-007-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP"))) + { + ExecutingStateTask_007(); + } + else + { + if (iTestCase == 9) + { + ExecutingStateTransitionTask(); + } + else + { + if (iTestCase == 10) + { + ExecutingStateBufferTask(); + } + else + { + switch(iPreviousState) + { + case OMX_StateIdle: + { + iPreviousState = OMX_StateExecuting; + EmptyThisBufferTask(); + break; + } + case OMX_StatePause: + { + iPreviousState = OMX_StateExecuting; + EmptyThisBufferTask(); + break; + } + } + } + } + } + } + } + break; + } + case OMX_StatePause: + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-007-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-02-HP")) || + TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-04-HP"))) + { + PauseStateTask_007(); + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::DoEventHandler State set to OMX_StatePause")); + } + break; + } + case OMX_StateInvalid: + { + if(TestStepName() == (_L("MMVIDEO-OMX-GS-001-01-HP"))) + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::GSTest001: Loaded to Invalid")); + // Not really intended for loaded to invalid test but booleon needed + iExecutingToIdle = EFalse; + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::DoEventHandler State set to OMX_StateInvalid")); + } + break; + } + } + } + +void CGraphicsSinkTestBase::UpdateSettingChanged(OMX_HANDLETYPE /*aComponent*/,TUint aData1,TUint /*aData2*/,TAny* /*aExtra*/) + { + TInt err = KErrGeneral; + + if(aData1 == iSurfaceConfigExt || + aData1 == OMX_IndexConfigCommonScale || + aData1 == OMX_IndexConfigCommonOutputSize || + aData1 == OMX_IndexConfigCommonInputCrop || + aData1 == OMX_IndexConfigCommonOutputCrop || + aData1 == OMX_IndexConfigCommonExclusionRect) + { + // port setting has been changed with Configs + TSurfaceId surfaceId; + (*iSurfaceConfig).GetSurfaceId(surfaceId); + // INFO_PRINTF2(_L("Surface Id:%d"),surfaceId); + err = iWindow->SetBackgroundSurface(*iSurfaceConfig, ETrue); + if(KErrNone != err) + { + ERR_PRINTF2(_L("SetSurfaceId fails with error: %d"),err); + SetTestStepError(KErrGeneral); + return SetTestStepResult(EFail); + } + // SetBackgroundSurface OK + } + } + + +void CGraphicsSinkTestBase::CloseTestStep() + { + delete iCamOutputBuffer; + + FreeBuffer( iGraphicSinkCompHandle, 0, iInputBufferHeaders, OMX_ErrorNone ); + iInputBufferHeaders.Reset(); + + COmxGsTestBase::CloseTest(); + } + +void CGraphicsSinkTestBase::EmptyThisBufferTask() + { + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::EmptyThisBufferTask: Empty this buffer task Count %d"),iDoEmptyBufferDoneCount); + + TInt bytesperpixel = COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat); + // CGraphicsSinkTestBase::EmptyThisBufferTask: Fill COmxILMMBuffer* with colour + FillCCamBuffer(iChunk, iOmxParamPortInput.format.video.nFrameWidth,iOmxParamPortInput.format.video.nFrameHeight,bytesperpixel,iOmxParamPortInput.nBufferCountActual); + + //INFO_PRINTF2(_L("CGraphicsSinkTestBase::EmptyThisBufferTask: Sending pBuffer 0x%08x"), iInputBufferHeaders[0]->pBuffer ); + + iInputBufferHeader = iInputBufferHeaders[0]; + iInputBufferHeader->nFilledLen = iOmxParamPortInput.format.video.nFrameWidth * + COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat) * + iOmxParamPortInput.format.video.nFrameHeight; + iInputBufferHeaders.Remove(0); + iOmxErrorType = iGraphicSinkCompHandle->EmptyThisBuffer(iGraphicSinkCompHandle,iInputBufferHeader); + + + if (OMX_ErrorNone != iOmxErrorType) + { + ERR_PRINTF1(_L("EmptyThisBuffer returned an error")); + return SetTestStepError(KErrGeneral); + } + + if (TestStepName() == (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle, 0); + } + else + { + if( iIgnoreNextBufferDone ){ + iIgnoreNextBufferDone = EFalse; + return; + } + // else... + + //INFO_PRINTF2(_L("CGraphicsSinkTestBase::EmptyThisBufferTask: Sending pBuffer 0x%08x"), iInputBufferHeaders[0]->pBuffer ); + + iInputBufferHeader = iInputBufferHeaders[0]; + iInputBufferHeaders.Remove(0); + iInputBufferHeader->nFilledLen = iOmxParamPortInput.format.video.nFrameWidth * + COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat) * + iOmxParamPortInput.format.video.nFrameHeight; + iInputBufferHeader->nFlags = OMX_BUFFERFLAG_SYNCFRAME; + iOmxErrorType = iGraphicSinkCompHandle->EmptyThisBuffer(iGraphicSinkCompHandle,iInputBufferHeader); + if (OMX_ErrorNone != iOmxErrorType) + { + ERR_PRINTF1(_L("EmptyThisBuffer returned an error")); + return SetTestStepError(KErrGeneral); + } + } + } + +void CGraphicsSinkTestBase::DoROmxGsTestSetup() + { + TRAPD(err,CreateWindowL()); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CreateWindow Failed %d"),err); + return SetTestStepError(err); + } + + OMX_INDEXTYPE videoSurfaceConfigIndex = OMX_IndexMax; + + iError = iGraphicSinkCompHandle->GetExtensionIndex(iGraphicSinkCompHandle, const_cast(sOmxSymbianGfxSurfaceConfig), &videoSurfaceConfigIndex); + if(OMX_ErrorNone != iError) + { + ERR_PRINTF1(_L("OMX_GetExtensionIndex Failed")); + PrintOmxError(iError); + return SetTestStepError(KErrGeneral); + } + + OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION surfaceConfig; + surfaceConfig.nSize = sizeof(OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION); + surfaceConfig.nVersion = TOmxILSpecVersion(); + surfaceConfig.nPortIndex = 0; + + GetParameter(iGraphicSinkCompHandle, videoSurfaceConfigIndex, &surfaceConfig); + if(NULL == surfaceConfig.pSurfaceConfig) + { + ERR_PRINTF1(_L("GetParameter Failed 01")); + return SetTestStepError(KErrGeneral); + } + + iSurfaceConfig = reinterpret_cast(surfaceConfig.pSurfaceConfig); + // INFO_PRINTF2(_L("SurfaceConfig : %x"), iSurfaceConfig); + TSurfaceId surfaceId; + (*iSurfaceConfig).GetSurfaceId(surfaceId); + // INFO_PRINTF2(_L("Surface Id:%d: "),surfaceId); + + // Get default OMX_PARAM_PORTDEFINITIONTYPE paramaters + iOmxParamPortInput.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE); + iOmxParamPortInput.nVersion = TOmxILSpecVersion(); + iOmxParamPortInput.nPortIndex = 0; + GetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + + // Set the color format to the supported type OMX_COLOR_FormatCbYCrY + // initial settings + iOmxParamPortInput.format.video.eColorFormat = OMX_COLOR_FormatCbYCrY; + iOmxParamPortInput.format.video.nFrameWidth = 320; + iOmxParamPortInput.format.video.nFrameHeight = 240; + iOmxParamPortInput.format.video.nStride = 320*2; + iOmxParamPortInput.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + +void CGraphicsSinkTestBase::DeleteCCameraBuf() + { + // Clean up from AllocateCCameraBuf + if (iCamOutputBuffer) + { + delete iCamOutputBuffer; + iCamOutputBuffer = NULL; + + iTestChunk.Close(); + iSurfaceUpdateSession.CancelAllUpdateNotifications(); + iSurfaceUpdateSession.Close(); + iSurfaceManager.CloseSurface(iSurfaceId); + iSurfaceId = TSurfaceId::CreateNullId(); + iSurfaceManager.Close(); + } + } + +void CGraphicsSinkTestBase::AllocateCCameraBuf() + { + // Setting paramters for surface manager + iOmxParamPortInput.format.video.eColorFormat = OMX_COLOR_FormatCbYCrY; + iOmxParamPortInput.format.video.xFramerate = 0; + iOmxParamPortInput.format.video.nFrameHeight = 320; + iOmxParamPortInput.format.video.nFrameWidth = 240; + iOmxParamPortInput.format.video.nStride = iOmxParamPortInput.format.video.nFrameWidth * COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + GetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + + // Create surface manager + RSurfaceManager::TSurfaceCreationAttributesBuf bf; + RSurfaceManager::TSurfaceCreationAttributes& b = bf(); + + b.iSize.iWidth = iOmxParamPortInput.format.video.nFrameWidth; + b.iSize.iHeight = iOmxParamPortInput.format.video.nFrameHeight; + b.iBuffers = iOmxParamPortInput.nBufferCountActual; + b.iPixelFormat = EUidPixelFormatRGB_565; // Look for conversion method + b.iStride = iOmxParamPortInput.format.video.nStride; + b.iOffsetToFirstBuffer = 0; + b.iOffsetBetweenBuffers = 0; // let surfacemanager choose. +#ifndef __WINSCW__ + b.iAlignment = RSurfaceManager::EPageAligned; +#else + b.iAlignment = 2; //TBC //working algn = 2z +#endif + b.iContiguous = ETrue; + b.iMappable = ETrue; + + TInt grapherr = InitialiseSurfaceManager(); + if(grapherr != KErrNone && grapherr != KErrAlreadyExists) + { + ERR_PRINTF1(_L("CGraphicsSurfaceSink::NewL FAILED")); + return SetTestStepError(grapherr); + } + + TRAPD(error, iCamOutputBuffer = COmxILMMBuffer::NewL(iTestChunk)); + if(error != KErrNone) + { + ERR_PRINTF1(_L("COmxILMMBuffer::NewL FAILED")); + return SetTestStepError(error); + } + + TInt ret = CreateAndMapSurface(bf, iCamOutputBuffer->SurfaceId()); + if(ret != KErrNone) + { + ERR_PRINTF2(_L("CreateAndMapSurfaceL FAILED: %d"), ret); + return SetTestStepError(ret); + } + //INFO_PRINTF2(_L("CGraphicsSinkTestBase::UseBufferTask: Chunk size: %d"),iCamOutputBuffer->Chunk().Size()); + + RSurfaceManager::TInfoBuf surfacebuf; + ret = iSurfaceManager.SurfaceInfo(iCamOutputBuffer->SurfaceId(), surfacebuf); + if(ret != KErrNone) + { + ERR_PRINTF1(_L("RSurfaceManager::SurfaceInfo FAILED")); + return SetTestStepError(ret); + } + + // INFO_PRINTF2(_L("Surface Id:%d "),iCamOutputBuffer->SurfaceId()); + iCamOutputBuffer->SurfaceInfoV01() = surfacebuf(); + // INFO_PRINTF2(_L("Handle of RChunk graph: %d"),iCamOutputBuffer->Chunk().Handle()); + + TInt numberofbuffer = b.iBuffers; + for(TInt i = 0 ; i < numberofbuffer; i++ ) + { + TInt offset; + iSurfaceManager.GetBufferOffset(iCamOutputBuffer->SurfaceId(),i,offset); + + //INFO_PRINTF3(_L("CGraphicsSinkTestBase::AllocateCCameraBuf() offset no %d = %d"), i , offset); + + iCamOutputBuffer->OffsetInfoArray().Append(offset); + } + + } + +void CGraphicsSinkTestBase::AllocateBufferTask() + { + TInt bytesperpixel = COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat); + TInt size = bytesperpixel * iOmxParamPortInput.format.video.nFrameWidth * iOmxParamPortInput.format.video.nFrameHeight; + + // Assume that allocate buffer is only called in state loaded + iPreviousState = OMX_StateLoaded; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + AllocateBuffer(iGraphicSinkCompHandle,&iInputBufferHeader,0,NULL,size,&iInputBufferHeaders,iOmxParamPortInput.nBufferCountActual); + // This also confirms that the buffer count is correct, as is shouldnt be zero + if (iInputBufferHeaders.Count() == 0) + { + ERR_PRINTF2(_L("CGraphicsSinkTestBase::AllocateBufferTask: iInputBufferHeaders Count %d"),iInputBufferHeaders.Count()); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + iInputBufferHeadersCount = iInputBufferHeaders.Count(); + // Create COmxILMMBuffer* + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::AllocateBufferTask: reinterpret_cast COmxILMMBuffer* %d"),iInputBufferHeaders[0]->pInputPortPrivate); + + + // duplicate chunk given from component by getconfig + OMX_INDEXTYPE sharedChunkMetadataExtensionIndex; + // due to chunk extension support in gfx + if (OMX_ErrorNone == OMX_GetExtensionIndex( + iGraphicSinkCompHandle, + OMX_SYMBIAN_INDEX_CONFIG_SHAREDCHUNKMETADATA_NAME, + &sharedChunkMetadataExtensionIndex)) + { + // Communicate the shared chunk metadata to the tunnelled + // component + OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE configSharedChunkMetadata; + configSharedChunkMetadata.nSize = sizeof(OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE); + configSharedChunkMetadata.nVersion = TOmxILSpecVersion(); + configSharedChunkMetadata.nPortIndex = 0; + + (void) OMX_GetConfig(iGraphicSinkCompHandle, + sharedChunkMetadataExtensionIndex, + &configSharedChunkMetadata); + + + //map the chunk into this process + RThread chunkOwnerThread; + User::LeaveIfError(chunkOwnerThread.Open(TThreadId(configSharedChunkMetadata.nOwnerThreadId))); + CleanupClosePushL(chunkOwnerThread); + + iChunk.SetHandle(configSharedChunkMetadata.nHandleId); + User::LeaveIfError(iChunk.Duplicate(chunkOwnerThread)); + CleanupStack::PopAndDestroy(&chunkOwnerThread); + + } + else + { + ERR_PRINTF1(_L("Failed to fetch shared chunk metadata from gfx sink.")); + CActiveScheduler::Stop(); + return SetTestStepError( KErrGeneral ); + } + + } + +void CGraphicsSinkTestBase::UseBufferTask() + { + TInt size = 0; + if( iCamOutputBuffer->OffsetInfoArray().Count() < 2 ){ + iSurfaceManager.GetBufferOffset( iCamOutputBuffer->SurfaceId(), 0, size ); + } + else{ + size = iCamOutputBuffer->OffsetInfoArray()[1] - iCamOutputBuffer->OffsetInfoArray()[0]; + } + + // Assume that use buffer is only called in state loaded + iPreviousState = OMX_StateLoaded; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + + // due to chunk extension support in gfx + OMX_INDEXTYPE sharedChunkMetadataExtensionIndex; + if (OMX_ErrorNone == OMX_GetExtensionIndex( + iGraphicSinkCompHandle, + OMX_SYMBIAN_INDEX_CONFIG_SHAREDCHUNKMETADATA_NAME, + &sharedChunkMetadataExtensionIndex)) + { + // Communicate the shared chunk metadata to the tunnelled + // component + OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE configSharedChunkMetadata; + configSharedChunkMetadata.nSize = sizeof(OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE); + configSharedChunkMetadata.nVersion = TOmxILSpecVersion(); + configSharedChunkMetadata.nPortIndex = 0; + configSharedChunkMetadata.nHandleId = iCamOutputBuffer->Chunk().Handle(); + configSharedChunkMetadata.nOwnerThreadId = RThread().Id().Id(); + + iError = OMX_SetConfig(iGraphicSinkCompHandle, + sharedChunkMetadataExtensionIndex, + &configSharedChunkMetadata); + + if (OMX_ErrorNone != iError) + { + ERR_PRINTF1(_L("CGraphicsSinkTestBase::UseBufferTask: Set shared chunk config error!")); + return SetTestStepError(PrintOmxError(iError)); + } + } + + + for (TInt i = 0 ; i < iOmxParamPortInput.nBufferCountActual; i++) + { + //INFO_PRINTF4(_L("CGraphicsSinkTestBase::UseBufferTask: size = %d, chunk base = 0x%08x, offset = %d.") , size, iCamOutputBuffer->Chunk().Base(), iCamOutputBuffer->OffsetInfoArray()[i] ); + iError = iGraphicSinkCompHandle->UseBuffer(iGraphicSinkCompHandle, + &iOutputBufferHeader, + 0, // input port + NULL, /*iCamOutputBuffer,*/ // pAppPrivate + size, // update + iCamOutputBuffer->Chunk().Base() + iCamOutputBuffer->OffsetInfoArray()[i] /* // change made due to OMXILBufferClass */); // + if (OMX_ErrorNone != iError) + { + ERR_PRINTF1(_L("CGraphicsSinkTestBase::UseBufferTask: UseBuffer Error")); + return SetTestStepError(PrintOmxError(iError)); + } + // INFO_PRINTF2(_L("surface ID y : %d"), iCamOutputBuffer->SurfaceId()); + // INFO_PRINTF2(_L("Buffer offset : %d"), iCamOutputBuffer->iBufferOffset); + if (iOutputBufferHeaders.Append(iOutputBufferHeader) != KErrNone) + { + ERR_PRINTF1(_L("OOM ERROR")); + return SetTestStepError(KErrGeneral); + } + } + } + +void CGraphicsSinkTestBase::AllocateBufferTaskStress() + { + // Color format should be default value: OMX_COLOR_Format16bitRGB565 + TInt bytesperpixel = COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat); + TInt size = bytesperpixel * iOmxParamPortInput.format.video.nFrameWidth * iOmxParamPortInput.format.video.nFrameHeight; + + // Assume that allocate buffer is only called in state loaded + iPreviousState = OMX_StateLoaded; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + + for(TInt i = 0 ; i < iOmxParamPortInput.nBufferCountActual; i++ ) + { + iOmxErrorType = iGraphicSinkCompHandle->AllocateBuffer(iGraphicSinkCompHandle,&iInputBufferHeader,0,NULL,size); + if (iOmxErrorType != OMX_ErrorNone) + { + if (iOmxErrorType == OMX_ErrorInsufficientResources) + { + INFO_PRINTF2(_L("CGraphicsSinkTestBase::AllocateBufferTaskStress: AllocateBuffer returned InsufficientResources & nBufferCountActual was set to %d"),iOmxParamPortInput.nBufferCountActual); + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + else + { + CActiveScheduler::Stop(); + return SetTestStepError(PrintOmxError(iOmxErrorType)); + } + } + + // Used for tracking + TRAPD(err,iInputBufferHeaders.AppendL(iInputBufferHeader)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("AppendL Buffer Failed %d"),err); + CActiveScheduler::Stop(); + return SetTestStepError(err); + } + } + + // This also confirms that the buffer count is correct, as is shouldnt be zero + if (iInputBufferHeaders.Count() == 0) + { + ERR_PRINTF2(_L("CGraphicsSinkTestBase::AllocateBufferTaskStress: iInputBufferHeaders Count %d"),iInputBufferHeaders.Count()); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + + // Create COmxILMMBuffer* + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::AllocateBufferTaskStress: reinterpret_cast COmxILMMBuffer* %d"),iInputBufferHeaders[0]->pInputPortPrivate); + //iCamBuf = static_cast(iInputBufferHeaders[0]->pInputPortPrivate); + // duplicate chunk given from component by getconfig + OMX_INDEXTYPE sharedChunkMetadataExtensionIndex; + // due to chunk extension support in gfx + if (OMX_ErrorNone == OMX_GetExtensionIndex( + iGraphicSinkCompHandle, + OMX_SYMBIAN_INDEX_CONFIG_SHAREDCHUNKMETADATA_NAME, + &sharedChunkMetadataExtensionIndex)) + { + // Communicate the shared chunk metadata to the tunnelled + // component + OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE configSharedChunkMetadata; + configSharedChunkMetadata.nSize = sizeof(OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE); + configSharedChunkMetadata.nVersion = TOmxILSpecVersion(); + configSharedChunkMetadata.nPortIndex = 0; + + (void) OMX_GetConfig(iGraphicSinkCompHandle, + sharedChunkMetadataExtensionIndex, + &configSharedChunkMetadata); + + + //map the chunk into this process + RThread chunkOwnerThread; + User::LeaveIfError(chunkOwnerThread.Open(TThreadId(configSharedChunkMetadata.nOwnerThreadId))); + CleanupClosePushL(chunkOwnerThread); + + iChunk.SetHandle(configSharedChunkMetadata.nHandleId); + User::LeaveIfError(iChunk.Duplicate(chunkOwnerThread)); + CleanupStack::PopAndDestroy(&chunkOwnerThread); + + } + else + { + ERR_PRINTF1(_L("Failed to fetch shared chunk metadata from gfx sink.")); + CActiveScheduler::Stop(); + return SetTestStepError( KErrGeneral ); + } + } + +void CGraphicsSinkTestBase::FreeBufferTask(RPointerArray* aBufferHeaders, + OMX_U32 aPortIndex,TBool aSendCommand) + { + if (aSendCommand) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0); + } + + FreeBuffer(iGraphicSinkCompHandle,aPortIndex,*aBufferHeaders); + aBufferHeaders->Reset(); + } + +void CGraphicsSinkTestBase::FreeBufferTaskAlt(RPointerArray aBufferHeaders, + OMX_U32 aPortIndex,TBool aSendCommand) + { + if (aSendCommand) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0); + } + + FreeBuffer(iGraphicSinkCompHandle,aPortIndex,aBufferHeaders); + } + +void CGraphicsSinkTestBase::FillCCamBuffer(const RChunk& aCamBuf, OMX_U32 aFrameWidth, + OMX_U32 aFrameHeight, TInt aBytePerPixel, TInt aNumOfActualBuffer) + { + // FillThisBuffer + TRgb red_col(255,0,0); + TRgb blue_col(0,255,0); + TRgb green_col(0,0,255); + TRgb black_col(0,0,0); + TUint32 red_color = red_col.Color64K(); + TUint32 blue_color = blue_col.Color64K(); + TUint32 green_color = green_col.Color64K(); + TUint32 black_color = black_col.Color64K(); + TUint32 col[] = {red_color, blue_color, green_color, black_color}; + + TInt stride = aFrameWidth * aBytePerPixel; + TInt colIndex = 0; + for(TInt index=0; indexChunk().Base() + aCamBuf->BufferOffset(); + TUint8* surfacePtr = aCamBuf.Base() + (iOmxParamPortInput.nBufferSize * index); + TUint8* linePtr = surfacePtr; + + TUint16* ptr = reinterpret_cast(surfacePtr); + + // Fill first line + for (TInt xx = 0; xx < aFrameWidth; xx++) + { + colIndex = Math::Random() % 4; + ptr[xx] = (TUint16)col[colIndex]; + //ptr[xx] = (TUint16)col[colIndex%4]; + colIndex++; + } + + // Now copy that to the other lines + for (TInt yy = 1; yy < aFrameHeight; yy++) + { + linePtr += stride; + Mem::Move(linePtr, surfacePtr, stride); + } + } + } + +void CGraphicsSinkTestBase::CreateOmxParamPortDefinitionType(OMX_PARAM_PORTDEFINITIONTYPE* aOmxParamPortType) + { + aOmxParamPortType->nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE); + aOmxParamPortType->nVersion = TOmxILSpecVersion(); + aOmxParamPortType->nPortIndex = 0; + GetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,aOmxParamPortType,OMX_ErrorNone); + // initial settings + aOmxParamPortType->format.video.nFrameWidth = 320; + aOmxParamPortType->format.video.nFrameHeight = 240; + aOmxParamPortType->format.video.eColorFormat = OMX_COLOR_FormatCbYCrY; + aOmxParamPortType->format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; + aOmxParamPortType->format.video.xFramerate = 0; + aOmxParamPortType->format.video.nStride = 320*2; + aOmxParamPortType->format.video.nSliceHeight = 10; + aOmxParamPortType->format.video.nBitrate = 96000; + } + +void CGraphicsSinkTestBase::CreateOmxVideoParamPortFormatType(OMX_VIDEO_PARAM_PORTFORMATTYPE* aOmxVideoParamPortType) + { + aOmxVideoParamPortType->nSize = sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE); + aOmxVideoParamPortType->nVersion = TOmxILSpecVersion(); + aOmxVideoParamPortType->nPortIndex = 0; + aOmxVideoParamPortType->nIndex = 0; + // The following 2 values should be over written by the correct ones for this index + aOmxVideoParamPortType->eCompressionFormat = OMX_VIDEO_CodingUnused; + aOmxVideoParamPortType->eColorFormat = OMX_COLOR_FormatCrYCbY; + aOmxVideoParamPortType->xFramerate = 0; + GetParameter(iGraphicSinkCompHandle,OMX_IndexParamVideoPortFormat,aOmxVideoParamPortType,OMX_ErrorNone); + } + +void CGraphicsSinkTestBase::CompareU32Param(OMX_U32 aSetParamType, OMX_U32 aGetParamType) + { + if (aSetParamType != aGetParamType) + { + ERR_PRINTF3(_L("Comparison failed: Set value: %d Get value: %d"),aSetParamType,aGetParamType); + return SetTestStepError(KErrGeneral); + } + } + +void CGraphicsSinkTestBase::CompareCFTParam(OMX_COLOR_FORMATTYPE aInputParamType, OMX_COLOR_FORMATTYPE aOutputParamType, OMX_INDEXTYPE aIndexType) + { + if (aInputParamType != aOutputParamType) + { + ERR_PRINTF3(_L("Comparison failed: set value: %d Index : %X"),aInputParamType,aIndexType); + ERR_PRINTF3(_L("Comparison failed: get value: %d Index : %X"),aOutputParamType,aIndexType); + return SetTestStepError(KErrGeneral); + } + } + +void CGraphicsSinkTestBase::CompareVCTParam(OMX_VIDEO_CODINGTYPE aInputParamType, OMX_VIDEO_CODINGTYPE aOutputParamType, OMX_INDEXTYPE aIndexType) + { + if (aInputParamType != aOutputParamType) + { + ERR_PRINTF3(_L("Comparison failed: set value: %d Index : %X"),aInputParamType,aIndexType); + ERR_PRINTF3(_L("Comparison failed: get value: %d Index : %X"),aOutputParamType,aIndexType); + return SetTestStepError(KErrGeneral); + } + } + +void CGraphicsSinkTestBase::CompareBoolParam(OMX_BOOL aInputParamType, OMX_BOOL aOutputParamType, OMX_INDEXTYPE aIndexType) + { + if (aInputParamType != aOutputParamType) + { + ERR_PRINTF3(_L("Comparison failed: set value: %d Index : %X"),aInputParamType,aIndexType); + ERR_PRINTF3(_L("Comparison failed: get value: %d Index : %X"),aOutputParamType,aIndexType); + return SetTestStepError(KErrGeneral); + } + } + +TInt CGraphicsSinkTestBase::PostKickOffTestL(TInt aTimerId) + { + if (aTimerId == 1) + { + iTestTimedOut = ETrue; + return KErrNone; + } + else + { + if (iPreviousState == OMX_StatePause && (TestStepName() == (_L("MMVIDEO-OMX-GS-007-01-HP")) || + TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")))) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + return KErrNone; + } + else + { + if (iPreviousState == OMX_StatePause && (TestStepName() == (_L("MMVIDEO-OMX-GS-007-02-HP")) || + TestStepName() == (_L("MMVIDEO-OMX-GS-007-04-HP")))) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + return KErrNone; + } + } + } + return KErrNone; + } + +void CGraphicsSinkTestBase::ErrorEventTask_001(OMX_ERRORTYPE aOmxError) + { + // INFO_PRINTF2(_L("GSTest001: EventError iteration: %d"), iTestIteration); + if (iTestIteration == 0) + { + if (aOmxError == OMX_ErrorIncorrectStateTransition) + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateLoaded); + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StatePause,0,OMX_ErrorNone); + } + else + { + ERR_PRINTF1(_L("CGraphicsSinkTestBase::ErrorEventTask_001: Invoked incorrect error event")); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + } + if (iTestIteration == 1) + { + if (aOmxError == OMX_ErrorIncorrectStateTransition) + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateLoaded); + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0,OMX_ErrorNone); + } + else + { + ERR_PRINTF1(_L("CGraphicsSinkTestBase::ErrorEventTask_001: Invoked incorrect error event")); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + } + if (iTestIteration == 2) + { + if (aOmxError == OMX_ErrorSameState) + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateLoaded); + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateInvalid,0,OMX_ErrorNone); + } + else + { + ERR_PRINTF1(_L("CGraphicsSinkTestBase::ErrorEventTask_001: Invoked incorrect error event")); + CActiveScheduler::Stop(); + return SetTestStepError(KErrGeneral); + } + } + if (iTestIteration == 3) + { + if (iExecutingToIdle == EFalse && aOmxError == OMX_ErrorInvalidState) + { + // INFO_PRINTF1(_L("CGraphicsSinkTestBase::ErrorEventTask_001: Invoked correct error event")); + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + else + { + ERR_PRINTF1(_L("CGraphicsSinkTestBase::ErrorEventTask_001: Invoked incorrect error event")); + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + iTestIteration++; + } + + +void CGraphicsSinkTestBase::LoadedStateTask_002() + { + iPreviousState = OMX_StateLoaded; + // INFO_PRINTF2(_L("GSTest002: Test complete iteration: %d"), iTestIteration); + iTestIteration++; + + if(TestStepName() == (_L("MMVIDEO-OMX-GS-002-01-HP"))) + { + if (iTestIteration == 1) + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_002: __MM_HEAP_MARK")); + __UHEAP_MARK; + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_002: __MM_HEAP_MARKEND")); + __UHEAP_MARKEND; + iTestTimedOut = ETrue; + } + } + + if(TestStepName() == (_L("MMVIDEO-OMX-GS-002-03-HP"))) + { + // Only increase the buffer count every 5 times + iOmxParamPortInput.nBufferCountActual = iOmxParamPortInput.nBufferCountMin + iTestIteration/5; + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::LoadedStateTask_002: Setting nBufferCountActual: %d"), iOmxParamPortInput.nBufferCountActual); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + + if(iTestIteration < KMaxTestIterations && !iTestTimedOut) + { + AllocateBufferTask(); + } + else + { + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + +void CGraphicsSinkTestBase::IdleStateTask_002() + { + iPreviousState = OMX_StateIdle; + FreeBufferTask(&iInputBufferHeaders,0); + } + +void CGraphicsSinkTestBase::LoadedStateTask_003() + { + iPreviousState = OMX_StateLoaded; + // INFO_PRINTF2(_L("GSTest003: Test complete iteration: %d"), iTestIteration); + iTestIteration++; + + if(TestStepName() == (_L("MMVIDEO-OMX-GS-003-01-HP"))) + { + if (iTestIteration == 1) + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_003: __MM_HEAP_MARK")); + __UHEAP_MARK; + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_003: __MM_HEAP_MARKEND")); + DeleteCCameraBuf(); + __UHEAP_MARKEND; + iTestTimedOut = ETrue; + } + } + + if(TestStepName() == (_L("MMVIDEO-OMX-GS-003-03-HP"))) + { + // Only increase the buffer count every 5 times + iOmxParamPortInput.nBufferCountActual = iOmxParamPortInput.nBufferCountMin + iTestIteration/5; + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::LoadedStateTask_003: Setting nBufferCountActual: %d"), iOmxParamPortOutput.nBufferCountActual); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + + if(!iTestTimedOut) + { + DeleteCCameraBuf(); + AllocateCCameraBuf(); + UseBufferTask(); + } + else + { + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + +void CGraphicsSinkTestBase::IdleStateTask_003() + { + iPreviousState = OMX_StateIdle; + FreeBufferTask(&iOutputBufferHeaders,0); + } + +void CGraphicsSinkTestBase::LoadedStateTask_004() + { + // INFO_PRINTF2(_L("GSTest004: Test complete iteration: %d"), iTestIteration); + iTestIteration++; + + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateLoaded); + iPreviousState = OMX_StateLoaded; + if(TestStepName() == (_L("MMVIDEO-OMX-GS-004-01-HP"))) + { + if (iTestIteration == 1) + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_004: __MM_HEAP_MARK")); + __UHEAP_MARK; + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_004: __MM_HEAP_MARKEND")); + __UHEAP_MARKEND; + iTestTimedOut = ETrue; + } + } + + if(TestStepName() == (_L("MMVIDEO-OMX-GS-004-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-05-HP"))) + { + iOmxParamPortInput.nBufferCountActual = 5 + iTestIteration/5; + INFO_PRINTF2(_L("CGraphicsSinkTestBase::LoadedStateTask_004: Setting nBufferCountActual: %d"), iOmxParamPortInput.nBufferCountActual); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + + if(iTestIteration < KMaxTestIterations && !iTestTimedOut) + { + AllocateBufferTask(); + } + else + { + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + +void CGraphicsSinkTestBase::IdleStateTask_004() + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateIdle); + if(iPreviousState == OMX_StateLoaded) + { + iPreviousState = OMX_StateIdle; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + else if(iPreviousState == OMX_StateExecuting) + { + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::IdleStateTask_004: Executing to Idle task Count %d"),iExecuteToIdleCount); + iExecuteToIdleCount++; + iPreviousState = OMX_StateIdle; + + if (TestStepName() == (_L("MMVIDEO-OMX-GS-004-01-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-02-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-03-HP"))) + { + FreeBufferTask(&iInputBufferHeaders,0); + } + + if (TestStepName() == (_L("MMVIDEO-OMX-GS-004-04-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-004-05-HP")) + || TestStepName() == (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + if (iExecuteToIdleCount < 20) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + else + { + FreeBufferTask(&iInputBufferHeaders,0); + } + } + } + } + +void CGraphicsSinkTestBase::ExecutingStateTask_004() + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateExecuting); + iPreviousState = OMX_StateExecuting; + + if (TestStepName() == (_L("MMVIDEO-OMX-GS-004-06-HP"))) + { + iExecuteToIdleCount = 20; + iTestTimedOut = ETrue; + EmptyThisBufferTask(); + } + else + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle, 0); + } + } + +void CGraphicsSinkTestBase::LoadedStateTask_005() + { + // INFO_PRINTF2(_L("GSTest005: Test complete iteration: %d"), iTestIteration); + iTestIteration++; + + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateLoaded); + iPreviousState = OMX_StateLoaded; + if(TestStepName() == (_L("MMVIDEO-OMX-GS-005-01-HP"))) + { + if (iTestIteration == 1) + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_005: __MM_HEAP_MARK")); + __UHEAP_MARK; + } + else + { + INFO_PRINTF1(_L("CGraphicsSinkTestBase::LoadedStateTask_005: __MM_HEAP_MARKEND")); + __UHEAP_MARKEND; + iTestTimedOut = ETrue; + } + } + + if(TestStepName() == (_L("MMVIDEO-OMX-GS-005-03-HP"))) + { + iOmxParamPortInput.nBufferCountActual = Min(5 + iTestIteration, 100); // let's cap the amount of buffers :-) + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::LoadedStateTask_005: Setting nBufferCountActual: %d"), iOmxParamPortInput.nBufferCountActual); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + + if(iTestIteration < KMaxTestIterations && !iTestTimedOut) + { + AllocateBufferTask(); + } + else + { + + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + +void CGraphicsSinkTestBase::IdleStateTask_005() + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateIdle); + if(iPreviousState == OMX_StateLoaded) + { + iPreviousState = OMX_StateIdle; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + if(iPreviousState == OMX_StateExecuting) + { + iPreviousState = OMX_StateIdle; + if (TestStepName() == (_L("MMVIDEO-OMX-GS-005-04-HP")) && !iTestTimedOut) + { + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::IdleStateTask_005: Test complete iteration: %d"), iTestIteration); + iTestIteration++; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + else + { + FreeBufferTask(&iInputBufferHeaders,0); + } + } + } + +void CGraphicsSinkTestBase::ExecutingStateTask_005() + { + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateExecuting); + iPreviousState = OMX_StateExecuting; + EmptyThisBufferTask(); + } + +void CGraphicsSinkTestBase::LoadedStateTask_006() + { + // INFO_PRINTF2(_L("GSTest006: Test complete iteration: %d"), iTestIteration); + iTestIteration++; + + iPreviousState = OMX_StateLoaded; + if(TestStepName() == (_L("MMVIDEO-OMX-GS-006-01-HP")) && !iTestTimedOut) + { + iOmxParamPortInput.nBufferCountActual = iOmxParamPortInput.nBufferCountActual + 1; + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + AllocateBufferTaskStress(); + } + else + { + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + } + +void CGraphicsSinkTestBase::IdleStateTask_006() + { + iPreviousState = OMX_StateIdle; + if(TestStepName() == (_L("MMVIDEO-OMX-GS-006-01-HP"))) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0); + + FreeBuffer(iGraphicSinkCompHandle,0,iInputBufferHeaders); + iInputBufferHeaders.Reset(); + } + if(TestStepName() == (_L("MMVIDEO-OMX-GS-006-02-HP"))) + { + // Allocate to many buffers + TInt bytesperpixel = COmxILMMBuffer::BytesPerPixel(iOmxParamPortInput.format.video.eColorFormat); + TInt size = bytesperpixel * iOmxParamPortInput.format.video.nFrameWidth * iOmxParamPortInput.format.video.nFrameHeight; + + iOmxErrorType = iGraphicSinkCompHandle->AllocateBuffer(iGraphicSinkCompHandle,&iInputBufferHeader,0,NULL,size); + if (OMX_ErrorIncorrectStateOperation != iOmxErrorType) + { + ERR_PRINTF1(_L("AllocateBuffer failed to return error")); + CActiveScheduler::Stop(); + return SetTestStepError(PrintOmxError(iOmxErrorType)); + } + + // Confirm state remains OMX_StateIdle + GetState(iGraphicSinkCompHandle,&iOmxStateType,OMX_StateIdle); + + // FreeBuffer without calling SendCommand to OMX_StateLoaded + FreeBuffer(iGraphicSinkCompHandle, 0, iInputBufferHeaders); + iInputBufferHeaders.Reset(); + } + } + +void CGraphicsSinkTestBase::LoadedStateTask_007() + { + switch (iPreviousState) + { + case OMX_StateIdle: + { + iPreviousState = OMX_StateLoaded; + CActiveScheduler::Stop(); + return SetTestStepResult(EPass); + } + case OMX_StateWaitForResources: + { + // State is OMX_StateIdle from OMX_StateWaitForResources + break; + } + } + } + +void CGraphicsSinkTestBase::IdleStateTask_007() + { + switch (iPreviousState) + { + case OMX_StateLoaded: + { + iPreviousState = OMX_StateIdle; + if (TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")) || TestStepName() == (_L("MMVIDEO-OMX-GS-007-04-HP"))) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StatePause,0); + } + else + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + break; + } + case OMX_StateExecuting: + { + iPreviousState = OMX_StateIdle; + if (TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")) && !iTestTimedOut) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StatePause,0); + } + else + { + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::IdleStateTask_007:: Executing to Idle task Count %d"),iExecuteToIdleCount); + iExecuteToIdleCount++; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0); + + FreeBuffer(iGraphicSinkCompHandle,0,iInputBufferHeaders); + iInputBufferHeaders.Reset(); + } + break; + } + case OMX_StatePause: + { + iPreviousState = OMX_StateIdle; + if (TestStepName() == (_L("MMVIDEO-OMX-GS-007-04-HP")) && !iTestTimedOut) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StatePause,0); + } + else + { + if (iTestTimedOut) + { + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::IdleStateTask_007:: Executing to Idle task Count %d"),iExecuteToIdleCount); + iExecuteToIdleCount++; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0); + + FreeBuffer(iGraphicSinkCompHandle,0,iInputBufferHeaders); + iInputBufferHeaders.Reset(); + } + else + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + } + } + } + } + +void CGraphicsSinkTestBase::PauseStateTask_007() + { + iPreviousState = OMX_StatePause; + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::PauseStateTask_007:: Pause state task count %d"),iPauseStateCount); + if(++iPauseStateCount == 5) + { + iTestTimedOut = ETrue; + } + + if(iTestShutdown) + { + delete iTestShutdown; + } + + TRAPD(err, iTestShutdown = COmxGsTestShutdown::NewL(this,2)); + if(err) + { + ERR_PRINTF1(_L("OOM ERROR")); + CActiveScheduler::Stop(); + return SetTestStepError(err); + } + iInterval = KTSU_OMX_GS_PAUSE; + iTestShutdown->Start(iInterval,KErrGeneral, EPass); + } + +void CGraphicsSinkTestBase::ExecutingStateTask_007() + { + iPreviousState = OMX_StateExecuting; + // INFO_PRINTF2(_L("CGraphicsSinkTestBase::ExecutingStateTask_007 Idle to Executing task Count %d"),iIdleToExecuteCount); + iIdleToExecuteCount++; + + if (TestStepName() == (_L("MMVIDEO-OMX-GS-007-03-HP")) || iTestTimedOut) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + } + else + { + EmptyThisBufferTask(); + } + } + +void CGraphicsSinkTestBase::StartStateTransitionTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateLoaded); + iGphxPrevState = iState; + + if (iTestStep == 4) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateWaitForResources,0); + } + else + { + AllocateBufferTask(); + } + } + +void CGraphicsSinkTestBase::WaitForResourcesTransitionTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateWaitForResources); + iGphxPrevState = iState; + + if (iTestStep == 4) + { + iWaitForResources = ETrue; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateLoaded,0); + } + } + +void CGraphicsSinkTestBase::LoadedStateTransitionTask() + { + //INFO_PRINTF3(_L("GSTest00%d: Test complete iteration: %d"), iTestCase, iTestIteration); + iTestIteration++; + GetState(iGraphicSinkCompHandle,&iState,OMX_StateLoaded); + + iGphxPrevState = iState; + if(iTestStep == 1) + { + if (iTestIteration == 1) + { + INFO_PRINTF3(_L("LoadedStateTransitionTask_00%d_0%d: __MM_HEAP_MARK"), iTestCase,iTestStep); + __UHEAP_MARK; + } + else + { + INFO_PRINTF3(_L("LoadedStateTransitionTask_00%d_0%d: __MM_HEAP_MARKEND"), iTestCase,iTestStep); + __UHEAP_MARKEND; + iTestTimedOut = ETrue; + } + } + + if(iTestStep == 3) + { + if ((iOmxParamPortInput.nBufferCountMin + iTestIteration/10) <= MAXNUMOFBUFFERS) + { + iOmxParamPortInput.nBufferCountActual = iOmxParamPortInput.nBufferCountMin + iTestIteration/10; + //INFO_PRINTF3(_L("GSTest00%d: Setting INPUT nBufferCountActual: %d"),iTestCase,iOmxParamPortInput.nBufferCountActual); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + } + + if(iTestIteration < KMaxTestIterations && !iTestTimedOut) + { + if (iTestStep == 4 && iWaitForResources) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateWaitForResources,0); + } + else + { + iWaitForResources = EFalse; + AllocateBufferTask(); + } + } + else + { + CActiveScheduler::Stop(); + } + } + +void CGraphicsSinkTestBase::IdleStateTransitionTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateIdle); + if(iGphxPrevState == OMX_StateLoaded) + { + iGphxPrevState = iState; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + else if(iGphxPrevState == OMX_StateExecuting) + { + iGphxPrevState = iState; + FreeBufferTaskAlt(iInputBufferHeaders,0); + iInputBufferHeaders.Reset(); + } + } + +void CGraphicsSinkTestBase::ExecutingStateTransitionTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateExecuting); + iGphxPrevState = iState; + + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + } + +void CGraphicsSinkTestBase::StartBufferDoneTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateLoaded); + iGphxPrevState = iState; + + AllocateBufferTask(); + } + +void CGraphicsSinkTestBase::LoadedStateBufferTask() + { + // INFO_PRINTF3(_L("GSTest00%d: Test complete iteration: %d"), iTestCase, iTestIteration); + iTestIteration++; + GetState(iGraphicSinkCompHandle,&iState,OMX_StateLoaded); + iGphxPrevState = iState; + if(iTestStep == 1 || iTestStep == 5|| iTestStep == 6) + { + if (iTestIteration == 1) + { + INFO_PRINTF3(_L("LoadedStateTransitionTask_00%d_0%d: __MM_HEAP_MARK"), iTestCase,iTestStep); + __UHEAP_MARK; + } + else + { + INFO_PRINTF3(_L("LoadedStateTransitionTask_00%d_0%d: __MM_HEAP_MARKEND"), iTestCase,iTestStep); + __UHEAP_MARKEND; + iTestTimedOut = ETrue; + } + } + + if(iTestStep == 3) + { + OMX_U32 setbuffercount = iOmxParamPortInput.nBufferCountMin + iTestIteration/10; + if (setbuffercount <= MAXNUMOFBUFFERS && setbuffercount != iOmxParamPortInput.nBufferCountActual) + { + iOmxParamPortInput.nBufferCountActual = iOmxParamPortInput.nBufferCountMin + iTestIteration/10; + iDoEmptyBufferDoneLimit = iOmxParamPortInput.nBufferCountActual; + INFO_PRINTF4(_L("GSTest00%d: Setting INPUT nBufferCountActual: %d DoEmptyBufferDoneLimit: %d") + ,iTestCase,iOmxParamPortInput.nBufferCountActual,iDoEmptyBufferDoneLimit); + SetParameter(iGraphicSinkCompHandle,OMX_IndexParamPortDefinition,&iOmxParamPortInput); + } + } + + if(iTestIteration < KMaxTestIterations && !iTestTimedOut) + { + iWaitForResources = EFalse; + AllocateBufferTask(); + } + else + { + CActiveScheduler::Stop(); // End the test + } + } + +void CGraphicsSinkTestBase::IdleStateBufferTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateIdle); + if(iGphxPrevState == OMX_StateLoaded) + { + iGphxPrevState = iState; + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateExecuting,0); + } + else if(iGphxPrevState == OMX_StateExecuting) + { + iGphxPrevState = iState; + FreeBufferTaskAlt(iInputBufferHeaders,0); + iInputBufferHeaders.Reset(); + } + } + +void CGraphicsSinkTestBase::ExecutingStateBufferTask() + { + GetState(iGraphicSinkCompHandle,&iState,OMX_StateExecuting); + iGphxPrevState = iState; + + EmptyThisBufferTask(); + if (iTestStep == 5) + { + SendCommand(iGraphicSinkCompHandle,OMX_CommandStateSet,OMX_StateIdle,0); + } + }