diff -r 000000000000 -r 40261b775718 mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayThree.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayThree.cpp Tue Feb 02 01:56:55 2010 +0200 @@ -0,0 +1,1998 @@ + +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// TestDevVideoPlay.cpp +// +// + +#include "TestDevVideoPlay.h" +#include "TestDevVideoPlayTestData.h" +#include "TestDevVideoPlugins/decoder.h" +#include "TestDevVideoPlugins/postproc.h" +#include + +void CTestDevVideoPlayResume::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayResume::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayResume::CTestDevVideoPlayResume(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayResume* CTestDevVideoPlayResume::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayResume* self = new(ELeave) CTestDevVideoPlayResume(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayResume::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; +// TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Resume")); + + // expected results + switch(iTestType) + { + case ETestValid: +// expErr = KErrNone; // EABI warning removal + break; + case ETestDecoderOnly: + selPost = EFalse; + break; + case ETestPostProcOnly: + selDec = EFalse; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder + if (selDec) + { +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + } + + // select post-processor + if (selPost) + { +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // check not already playing + TBool playing = aDevVideoPlay.IsPlaying(); + if (playing) + { + ERR_PRINTF1(_L("Error - DevVideoPlay already playing!")); + return EInconclusive; + } + + // call resume on DevVideoPlay then check IsPlaying() + aDevVideoPlay.Resume(); + playing = aDevVideoPlay.IsPlaying(); + + if (!playing) + { + ERR_PRINTF1(_L("IsPlaying() returned EFalse - expected ETrue")); + ret = EFail; + } + else + INFO_PRINTF1(_L("Resume() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlaySetPosition::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlaySetPosition::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlaySetPosition::CTestDevVideoPlaySetPosition(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetPosition* CTestDevVideoPlaySetPosition::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetPosition* self = new(ELeave) CTestDevVideoPlaySetPosition(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + TInt testPos = KTestPosition; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetPosition")); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestBothFatal: + expErr = KErrDied; + testPos = KTestPositionFatal; + break; + case ETestDecoderFatal: + expErr = KErrDied; + testPos = KTestPositionFatal; + // fall through to set post proc to false; + case ETestDecoderOnly: + selPost = EFalse; + break; + case ETestPostProcFatal: + expErr = KErrDied; + testPos = KTestPositionFatal; + // fall through to set decoder to false; + case ETestPostProcOnly: + selDec = EFalse; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder + if (selDec) + { +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + } + + // select post-processor + if (selPost) + { +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + TTimeIntervalMicroSeconds pos(testPos); + + // call SetPosition + aDevVideoPlay.SetPosition(pos); + + // if no PANIC and iError is as expected then test has passed + // if performing a fatal test then expect iError = KErrDied + if (iError == expErr) + { + ERR_PRINTF3(_L("SetPosition() got error %d; Expected %d"), iError, expErr); + } + else + { + INFO_PRINTF1(_L("SetPosition() called successfully")); + } + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayFreezePicture::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayFreezePicture::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayFreezePicture::CTestDevVideoPlayFreezePicture(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayFreezePicture* CTestDevVideoPlayFreezePicture::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayFreezePicture* self = new(ELeave) CTestDevVideoPlayFreezePicture(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayFreezePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: FreezePicture")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + TTimeIntervalMicroSeconds pos(KTestPosition); + + // call FreezePicture + aDevVideoPlay.FreezePicture(pos); + + // if no PANIC then test has passed + + INFO_PRINTF1(_L("FreezePicture() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayReleaseFreeze::CTestDevVideoPlayReleaseFreeze(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayReleaseFreeze* CTestDevVideoPlayReleaseFreeze::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayReleaseFreeze* self = new(ELeave) CTestDevVideoPlayReleaseFreeze(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayReleaseFreeze::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: ReleaseFreeze")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + TTimeIntervalMicroSeconds pos(KTestPosition); + + // call ReleaseFreeze + aDevVideoPlay.ReleaseFreeze(pos); + + // if no PANIC then test has passed + + INFO_PRINTF1(_L("ReleaseFreeze() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayDecodingPosition::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayDecodingPosition::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayDecodingPosition::CTestDevVideoPlayDecodingPosition(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayDecodingPosition* CTestDevVideoPlayDecodingPosition::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayDecodingPosition* self = new(ELeave) CTestDevVideoPlayDecodingPosition(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayDecodingPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: DecodingPosition")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // get decoding position + TTimeIntervalMicroSeconds decPos = aDevVideoPlay.DecodingPosition(); + + // check against test data + TTimeIntervalMicroSeconds testTime(KTestDecodePosition); + if (decPos != testTime) + { + ERR_PRINTF3(_L("DecodingPosition() incorrect - gave %d (expected %d)"), + I64LOW(decPos.Int64()), KTestDecodePosition); + ret = EFail; + } + else + INFO_PRINTF1(_L("DecodingPosition() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayPlaybackPosition::CTestDevVideoPlayPlaybackPosition(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayPlaybackPosition* CTestDevVideoPlayPlaybackPosition::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayPlaybackPosition* self = new(ELeave) CTestDevVideoPlayPlaybackPosition(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayPlaybackPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: PlaybackPosition")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // get playback position + TTimeIntervalMicroSeconds playPos = aDevVideoPlay.PlaybackPosition(); + + // check against test data + TTimeIntervalMicroSeconds testTime(KTestPlayPosition); + if (playPos != testTime) + { + ERR_PRINTF3(_L("PlaybackPosition() incorrect - gave %d (expected %d)"), + I64LOW(playPos.Int64()), KTestPlayPosition); + ret = EFail; + } + else + INFO_PRINTF1(_L("PlaybackPosition() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayPreDecoderBufferBytes::CTestDevVideoPlayPreDecoderBufferBytes(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayPreDecoderBufferBytes* CTestDevVideoPlayPreDecoderBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayPreDecoderBufferBytes* self = new(ELeave) CTestDevVideoPlayPreDecoderBufferBytes(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayPreDecoderBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: PreDecoderBufferBytes")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // get pre-decoder buffer bytes + TUint decBytes = aDevVideoPlay.PreDecoderBufferBytes(); + + // check against test data + if (decBytes != KTestPreDecoderBytes) + { + ERR_PRINTF3(_L("PreDecoderBufferBytes() incorrect - gave %d (expected %d)"), + decBytes, KTestPreDecoderBytes); + ret = EFail; + } + else + INFO_PRINTF1(_L("PreDecoderBufferBytes() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayPictureBufferBytes::CTestDevVideoPlayPictureBufferBytes(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayPictureBufferBytes* CTestDevVideoPlayPictureBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayPictureBufferBytes* self = new(ELeave) CTestDevVideoPlayPictureBufferBytes(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayPictureBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: PictureBufferBytes")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // get picture buffer bytes + TUint picBytes = aDevVideoPlay.PictureBufferBytes(); + + // check against test data + if (picBytes != KTestPictureBytes) + { + ERR_PRINTF3(_L("PictureBufferBytes() incorrect - gave %d (expected %d)"), + picBytes, KTestPictureBytes); + ret = EFail; + } + else + INFO_PRINTF1(_L("PictureBufferBytes() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayGetPictureCounters::CTestDevVideoPlayGetPictureCounters(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetPictureCounters* CTestDevVideoPlayGetPictureCounters::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetPictureCounters* self = new(ELeave) CTestDevVideoPlayGetPictureCounters(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayGetPictureCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetPictureCounters")); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestDecoderOnly: + selPost = EFalse; + break; + case ETestPostProcOnly: + selDec = EFalse; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + if (selDec) + { + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + } + + // select post-processor + if (selPost) + { + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + CMMFDevVideoPlay::TPictureCounters picCounts; + + // get picture counters from DevVideoPlay + aDevVideoPlay.GetPictureCounters(picCounts); + + // N.B. PicturesSkipped is sum of decoder and post processor so + // we have to add these + CMMFDevVideoPlay::TPictureCounters testCounts = GetTestPictureCounters(); + if (hwDecoder && hwPostProc) + { + // account for both decoder and post processor + testCounts.iPicturesSkipped *= 2; + } + else if (hwPostProc) + { + // no decoded samples from a post processor + testCounts.iPicturesDecoded = 0; + } + + if (!ComparePictureCounters(picCounts, testCounts)) + { + ERR_PRINTF1(_L("GetPictureCounters() comparison with test data failed!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("GetPictureCounters() comparison with test data passed.")); + INFO_PRINTF3(_L("GetPictureCounters(), %d = %d"), err, expErr); + } + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayGetBitstreamCounters::CTestDevVideoPlayGetBitstreamCounters(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetBitstreamCounters* CTestDevVideoPlayGetBitstreamCounters::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetBitstreamCounters* self = new(ELeave) CTestDevVideoPlayGetBitstreamCounters(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayGetBitstreamCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBitstreamCounters")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));// EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + CMMFDevVideoPlay::TBitstreamCounters bitCounts; + + // get bitstream counters from DevVideoPlay + aDevVideoPlay.GetBitstreamCounters(bitCounts); + + if (!CompareBitstreamCounters(bitCounts, GetTestBitstreamCounters())) + { + ERR_PRINTF1(_L("GetBitstreamCounters() comparison with test data failed!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("GetBitstreamCounters() comparison with test data passed.")); + INFO_PRINTF3(_L("GetBitstreamCounters(), %d = %d"), err, expErr); + } + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayNumFreeBuffers::CTestDevVideoPlayNumFreeBuffers(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayNumFreeBuffers* CTestDevVideoPlayNumFreeBuffers::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayNumFreeBuffers* self = new(ELeave) CTestDevVideoPlayNumFreeBuffers(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayNumFreeBuffers::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: NumFreeBuffers")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + TUint numBuffers = 0; + + // get number of free buffers from DevVideoPlay + numBuffers = aDevVideoPlay.NumFreeBuffers(); + + if (numBuffers != KTestNumFreeBuffers) + { + ERR_PRINTF1(_L("NumFreeBuffers() comparison with test data failed!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("NumFreeBuffers() comparison with test data passed.")); + INFO_PRINTF3(_L("NumFreeBuffers(), %d = %d"), numBuffers, KTestNumFreeBuffers); + } + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlaySetComplexityLevel::CTestDevVideoPlaySetComplexityLevel(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetComplexityLevel* CTestDevVideoPlaySetComplexityLevel::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetComplexityLevel* self = new(ELeave) CTestDevVideoPlaySetComplexityLevel(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetComplexityLevel::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetComplexityLevel")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // set complexity level on decoder + aDevVideoPlay.SetComplexityLevel(hwDecoder, KTestComplexityLevel1); + + // set complexity level on post-processor + aDevVideoPlay.SetComplexityLevel(hwPostProc, KTestComplexityLevel2); + + // if no PANIC then test has passed + INFO_PRINTF3(_L("SetComplexityLevel(), %d, %d"), KTestComplexityLevel1, KTestComplexityLevel2); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayNumComplexityLevels::CTestDevVideoPlayNumComplexityLevels(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayNumComplexityLevels* CTestDevVideoPlayNumComplexityLevels::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayNumComplexityLevels* self = new(ELeave) CTestDevVideoPlayNumComplexityLevels(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayNumComplexityLevels::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: NumComplexityLevels")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // get num complexity levels on decoder + TUint levs1 = aDevVideoPlay.NumComplexityLevels(hwDecoder); + + // get num complexity levels on post-processor + TUint levs2 = aDevVideoPlay.NumComplexityLevels(hwPostProc); + + // check return values against test data + if (levs1 != KTestNumComplexityLevels1 || levs2 != KTestNumComplexityLevels2) + { + ERR_PRINTF3(_L("Error - comparison against test data failed! (%d, %d)"), levs1, levs2); + } + else + { + INFO_PRINTF3(_L("NumComplexityLevels(), %d, %d"), levs1, levs2); + } + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayGetComplexityLevelInfo::CTestDevVideoPlayGetComplexityLevelInfo(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetComplexityLevelInfo* CTestDevVideoPlayGetComplexityLevelInfo::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetComplexityLevelInfo* self = new(ELeave) CTestDevVideoPlayGetComplexityLevelInfo(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayGetComplexityLevelInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetComplexityLevelInfo")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; + THwDeviceId hwPostProc = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + CMMFDevVideoPlay::TComplexityLevelInfo levInfo1; + CMMFDevVideoPlay::TComplexityLevelInfo levInfo2; + + // get complexity level info on decoder + aDevVideoPlay.GetComplexityLevelInfo(hwDecoder, KTestComplexityLevel1, levInfo1); + + // get complexity level info on post-processor + aDevVideoPlay.GetComplexityLevelInfo(hwPostProc, KTestComplexityLevel2, levInfo2); + + CMMFDevVideoPlay::TComplexityLevelInfo testInfo1 = GetTestLevelInfo(KTestComplexityLevel1); + CMMFDevVideoPlay::TComplexityLevelInfo testInfo2 = GetTestLevelInfo(KTestComplexityLevel2); + + // check return values against test data + if (!CompareLevelInfos(levInfo1, testInfo1) || !CompareLevelInfos(levInfo2, testInfo2)) + { + ERR_PRINTF1(_L("Error - comparison against test data failed!")); + } + else + { + INFO_PRINTF1(_L("Comparison against test data passed ok.")); + INFO_PRINTF1(_L("GetComplexityLevelInfo() called successfully")); + } + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayGetBuffer::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayGetBuffer::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +void CTestDevVideoPlayGetBuffer::MdvpoNewBuffers() + { + INFO_PRINTF1(_L("CTestDevVideoPlayGetBuffer::MdvpoNewBuffers()")); + iCalledBack = ETrue; + } + +CTestDevVideoPlayGetBuffer::CTestDevVideoPlayGetBuffer(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetBuffer* CTestDevVideoPlayGetBuffer::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetBuffer* self = new(ELeave) CTestDevVideoPlayGetBuffer(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayGetBuffer::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBuffer")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + TVideoInputBuffer* newBuff = NULL; + + // get a buffer of a certain size from DevVideoPlay + TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) ); + // callback will occur and newBuff will be set to new buffer + + if (err != expErr) + { + ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + TBool buffSuccess = EFalse; + + // check callback has been called and buffer is correct + if (newBuff && iCalledBack) + { + TTimeIntervalMicroSeconds testTime(KTestBufferSize); + if ( (newBuff->iDecodingTimestamp == testTime) && + (newBuff->iOptions == KTestBufferOptions) && + (newBuff->iData == KTestBufferString) ) + { + buffSuccess = ETrue; + } + } + + if (!buffSuccess) + { + ERR_PRINTF1(_L("Received buffer is corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Buffer received correctly")); + INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr); + } + } + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayWriteCodedData::CTestDevVideoPlayWriteCodedData(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayWriteCodedData* CTestDevVideoPlayWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayWriteCodedData* self = new(ELeave) CTestDevVideoPlayWriteCodedData(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: WriteCodedData")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // construct a video input buffer structure with a valid timestamp and + // write this DevVideoPlay. Call will leave on error. + TVideoInputBuffer* newBuff = NULL; + TPtrC8 testBufferStringPtr(KTestBufferString); + TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length())); + if (err) + { + ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay")); + return EInconclusive; + } + + // initialize newBuff with test data + newBuff->iOptions = KTestBufferOptions; + newBuff->iDecodingTimestamp = KTestBufferSize; + newBuff->iData.Zero(); + newBuff->iData.Append(testBufferStringPtr); + + // write buffer to DevVideoPlay + TRAP(err, aDevVideoPlay.WriteCodedDataL(newBuff) ) + + if (err != expErr) + { + ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Coded data sent successfully")); + INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr); + } + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayScanAndCopyCodedData::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayScanAndCopyCodedData::CTestDevVideoPlayScanAndCopyCodedData(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayScanAndCopyCodedData* CTestDevVideoPlayScanAndCopyCodedData::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayScanAndCopyCodedData* self = new(ELeave) CTestDevVideoPlayScanAndCopyCodedData(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayScanAndCopyCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy: ScanAndCopyCodedDataL")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + + // construct a video input buffer structure with a valid timestamp and + // write this DevVideoPlay. Call will leave on error. + TVideoInputBuffer* newBuff = NULL; + TPtrC8 testBufferStringPtr(KTestBufferString); + TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length())); + if (err) + { + ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay")); + return EInconclusive; + } + + //clean out pre-set stuff from buffer + newBuff->iData.Zero(); + //set ptr to test data + TPtrC8 testBufferString(KTestBufferString); + HBufC8* bufferDataArea = testBufferString.AllocL(); + CleanupStack::PushL(bufferDataArea); + TPtr8 dataAreaPtr = bufferDataArea->Des(); + TFramePortion framePortion = EFramePortionEndFragment; + + MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy)); + + TInt consumed = 0; + // write buffer to DevVideoPlay using new interface + TRAP(err, ciOne->ScanAndCopyCodedDataL(dataAreaPtr, newBuff, consumed, framePortion)); + + //compare buffer to test data + if ((newBuff->iData != KTestBufferString) || consumed != newBuff->iData.Length()) + { + err = KErrCorrupt; + } + + if (err != expErr) + { + ERR_PRINTF3(_L("ScanAndCopyCodedDataL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Coded data sent successfully")); + INFO_PRINTF3(_L("ScanAndCopyCodedDataL(), %d = %d"), err, expErr); + } + CleanupStack::PopAndDestroy(bufferDataArea); + return ret; + } + +//------------------------------------------------------------------ + +void CTestDevVideoPlayExtensionWriteCodedData::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayExtensionWriteCodedData::CTestDevVideoPlayExtensionWriteCodedData(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayExtensionWriteCodedData* CTestDevVideoPlayExtensionWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayExtensionWriteCodedData* self = new(ELeave) CTestDevVideoPlayExtensionWriteCodedData(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayExtensionWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy: WriteCodedData")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + THwDeviceId hwDecoder = 0; + + // select decoder + TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // construct a video input buffer structure with a valid timestamp and + // write this DevVideoPlay. Call will leave on error. + TVideoInputBuffer* newBuff = NULL; + TPtrC8 testBufferStringPtr(KTestBufferString); + TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length())); + if (err) + { + ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay")); + return EInconclusive; + } + + // initialize newBuff with test data + newBuff->iOptions = KTestBufferOptions; + newBuff->iDecodingTimestamp = KTestBufferSize; + newBuff->iData.Zero(); + newBuff->iData.Append(testBufferStringPtr); + + TFramePortion framePortion = EFramePortionEndFragment; + + MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy)); + + // write buffer to DevVideoPlay using new interface + TRAP(err, ciOne->WriteCodedDataL(newBuff, framePortion)); + + if (err != expErr) + { + ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Coded data sent successfully")); + INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr); + } + return ret; + } + +//------------------------------------------------------------------ + +void CTestDevVideoPlayWritePicture::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayWritePicture::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +void CTestDevVideoPlayWritePicture::MdvpoReturnPicture(TVideoPicture* aPicture) + { + INFO_PRINTF1(_L("CTestDevVideoPlayWritePicture::MdvpoReturnPicture()")); + + iPicture = aPicture; + } + +CTestDevVideoPlayWritePicture::CTestDevVideoPlayWritePicture(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayWritePicture* CTestDevVideoPlayWritePicture::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayWritePicture* self = new(ELeave) CTestDevVideoPlayWritePicture(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayWritePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: WritePicture")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // construct a video picture structure with a valid timestamp and + // write this DevVideoPlay. If the same picture comes back through the + // MdvpoReturnPicture() callback then test has passed. + TVideoPicture picture; + TTimeIntervalMicroSeconds picTime(KTestPictureTimestamp); + picture.iTimestamp = picTime; + picture.iOptions = TVideoPicture::ETimestamp; + + // write picture to DevVideoPlay + TRAP(err, aDevVideoPlay.WritePictureL(&picture) ) + + if (err != expErr) + { + ERR_PRINTF3(_L("WritePicture() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + TBool picSuccess = EFalse; + + // check callback has been called and picture is correct + if (iPicture) + { + if ( (iPicture->iTimestamp == picTime) && + (iPicture->iOptions == TVideoPicture::ETimestamp) ) + { + picSuccess = ETrue; + } + } + + if (!picSuccess) + { + ERR_PRINTF1(_L("Received picture is corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Original picture received correctly")); + INFO_PRINTF3(_L("WritePicture(), %d = %d"), err, expErr); + } + } + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayInputEnd::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayInputEnd::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +void CTestDevVideoPlayInputEnd::MdvpoStreamEnd() + { + INFO_PRINTF1(_L("CTestDevVideoPlayInputEnd::MdvpoStreamEnd()")); + + // keep track on number of times this callback is called + iEndCount++; + } + +CTestDevVideoPlayInputEnd::CTestDevVideoPlayInputEnd(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayInputEnd* CTestDevVideoPlayInputEnd::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayInputEnd* self = new(ELeave) CTestDevVideoPlayInputEnd(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayInputEnd::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; +// TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: InputEnd")); + + // expected results + switch(iTestType) + { + case ETestValid: +// expErr = KErrNone; // EABI warning removal + break; + case ETestDecoderOnly: + selPost = EFalse; + break; + case ETestPostProcOnly: + selDec = EFalse; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + +// THwDeviceId hwDecoder = 0; +// THwDeviceId hwPostProc = 0; + + // select decoder + if (selDec) + { +// TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + } + + // select post-processor + if (selPost) + { +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + } + // initialize CDevVideoPlay and wait for response + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); + return EInconclusive; + } + + // call input end on DevVideoPlay and check callback counter == 1 + aDevVideoPlay.InputEnd(); + + if (iEndCount != 1) + { + ERR_PRINTF2(_L("Error - MdvpoStreamEnd only called %d times!"), iEndCount); + ret = EFail; + } + else + INFO_PRINTF1(_L("InputEnd() called successfully")); + + return ret; + } +//------------------------------------------------------------------- + +void CTestDevVideoGetBufferWithoutInitialize::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestGetBufferWithoutInitialize::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +void CTestDevVideoGetBufferWithoutInitialize::MdvpoNewBuffers() + { + INFO_PRINTF1(_L("CTestGetBufferWithoutInitialize::MdvpoNewBuffers()")); + iCalledBack = ETrue; + } + +CTestDevVideoGetBufferWithoutInitialize::CTestDevVideoGetBufferWithoutInitialize(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoGetBufferWithoutInitialize* CTestDevVideoGetBufferWithoutInitialize::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoGetBufferWithoutInitialize* self = new(ELeave) CTestDevVideoGetBufferWithoutInitialize(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoGetBufferWithoutInitialize::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBuffer")); + INFO_PRINTF1(_L("To test the scenario wherein GetBufferL is called without calling initialize")); + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + + TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize decoder")); + return EInconclusive; + } + + // select post-processor + TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + TVideoInputBuffer* newBuff = NULL; + // iError is set by the MdvpoInitComplete callback + TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) ); + // callback will occur and newBuff will be set to new buffer + if (err != expErr) + { + ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + TBool buffSuccess = EFalse; + + // check callback has been called and buffer is correct + if (newBuff && iCalledBack) + { + TTimeIntervalMicroSeconds testTime(KTestBufferSize); + if ( (newBuff->iDecodingTimestamp == testTime) && + (newBuff->iOptions == KTestBufferOptions) && + (newBuff->iData == KTestBufferString) ) + { + buffSuccess = ETrue; + } + } + + if (!buffSuccess) + { + ERR_PRINTF1(_L("Received buffer is corrupt!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("Buffer received correctly")); + INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr); + } + } + + return ret; + } +//----------------------------------------------------------------------- +