diff -r 000000000000 -r b8ed18f6c07b mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayTwo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayTwo.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,1790 @@ + +// 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 + +CTestDevVideoPlaySetInputCrop::CTestDevVideoPlaySetInputCrop(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetInputCrop* CTestDevVideoPlaySetInputCrop::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetInputCrop* self = new(ELeave) CTestDevVideoPlaySetInputCrop(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetInputCrop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetInputCrop")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set input crop on decoder + TRect testRect1(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD); + TRAP(err, aDevVideoPlay.SetInputCropOptionsL(hwDecoder, testRect1) ) + + // set input crop on post-processor + TRect testRect2(KTestInputCropRectD, KTestInputCropRectC, KTestInputCropRectB, KTestInputCropRectA); + TRAP(err2, aDevVideoPlay.SetInputCropOptionsL(hwPostProc, testRect2) ) + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetInputCropOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetInputCropOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetInputCropOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetYuvToRgbOptionsFormat::CTestDevVideoPlaySetYuvToRgbOptionsFormat(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetYuvToRgbOptionsFormat* CTestDevVideoPlaySetYuvToRgbOptionsFormat::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetYuvToRgbOptionsFormat* self = new(ELeave) CTestDevVideoPlaySetYuvToRgbOptionsFormat(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetYuvToRgbOptionsFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetYuvToRgbOptionsFormat")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set YUV to RGB options with formats on decoder + TRAP(err, aDevVideoPlay.SetYuvToRgbOptionsL(hwDecoder, KTestYuvToRgb1, KTestYuvFormat1, KTestRgbFormat1) ); + + // set YUV to RGB options with formats on post-processor + TRAP(err2, aDevVideoPlay.SetYuvToRgbOptionsL(hwPostProc, KTestYuvToRgb2, KTestYuvFormat2, KTestRgbFormat2) ); + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetYuvToRgbOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetYuvToRgbOptions::CTestDevVideoPlaySetYuvToRgbOptions(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetYuvToRgbOptions* CTestDevVideoPlaySetYuvToRgbOptions::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetYuvToRgbOptions* self = new(ELeave) CTestDevVideoPlaySetYuvToRgbOptions(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetYuvToRgbOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetYuvToRgbOptions")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set YUV to RGB options with formats on decoder + TRAP(err, aDevVideoPlay.SetYuvToRgbOptionsL(hwDecoder, KTestYuvToRgb1) ); + + // set YUV to RGB options with formats on post-processor + TRAP(err2, aDevVideoPlay.SetYuvToRgbOptionsL(hwPostProc, KTestYuvToRgb2) ); + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetYuvToRgbOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetRotate::CTestDevVideoPlaySetRotate(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetRotate* CTestDevVideoPlaySetRotate::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetRotate* self = new(ELeave) CTestDevVideoPlaySetRotate(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetRotate::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetRotate")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set rotate options on decoder + TRAP(err, aDevVideoPlay.SetRotateOptionsL(hwDecoder, KTestRotate1) ); + + // set rotate options on post-processor + TRAP(err2, aDevVideoPlay.SetRotateOptionsL(hwPostProc, KTestRotate2) ); + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetRotateOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetRotateOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetRotateOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetScale::CTestDevVideoPlaySetScale(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetScale* CTestDevVideoPlaySetScale::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetScale* self = new(ELeave) CTestDevVideoPlaySetScale(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetScale::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetScale")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set scale options on decoder + TSize testScale1(KTestScaleX, KTestScaleY); + TRAP(err, aDevVideoPlay.SetScaleOptionsL(hwDecoder, testScale1, ETrue) ); + + TSize testScale2(KTestScaleY, KTestScaleX); + // set scale options on post-processor + TRAP(err2, aDevVideoPlay.SetScaleOptionsL(hwPostProc, testScale2, ETrue) ); + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetScaleOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetScaleOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetScaleOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetCrop::CTestDevVideoPlaySetCrop(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetCrop* CTestDevVideoPlaySetCrop::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetCrop* self = new(ELeave) CTestDevVideoPlaySetCrop(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetCrop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetCrop")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set output crop options on decoder + TRect testRect1(KTestOutputCropRectA, KTestOutputCropRectB, KTestOutputCropRectC, KTestOutputCropRectD); + TRAP(err, aDevVideoPlay.SetOutputCropOptionsL(hwDecoder, testRect1) ); + + // set output crop options on post-processor + TRect testRect2(KTestOutputCropRectD, KTestOutputCropRectC, KTestOutputCropRectB, KTestOutputCropRectA); + TRAP(err2, aDevVideoPlay.SetOutputCropOptionsL(hwPostProc, testRect2) ); + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetOutputCropOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetOutputCropOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetOutputCropOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetPostProcOptions::CTestDevVideoPlaySetPostProcOptions(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetPostProcOptions* CTestDevVideoPlaySetPostProcOptions::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetPostProcOptions* self = new(ELeave) CTestDevVideoPlaySetPostProcOptions(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetPostProcOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetPostProcOptions")); + + // expected results + if (iTestType != ETestValid) + { + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt err = KErrNone; + TInt err2 = 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; + } + + // set post-processor options on decoder + TRAP(err, aDevVideoPlay.SetPostProcSpecificOptionsL(hwDecoder, KTestPostProcOptions1) ); + + // set post-processor options on post-processor + TRAP(err2, aDevVideoPlay.SetPostProcSpecificOptionsL(hwPostProc, KTestPostProcOptions2) ); + + + if ((err != expErr) || (err2 != expErr)) + { + ERR_PRINTF3(_L("SetPostProcSpecificOptionsL() on Decoder gave error %d (expected %d)"),err, expErr); + ERR_PRINTF3(_L("SetPostProcSpecificOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF4(_L("SetPostProcSpecificOptionsL(), %d, %d= %d"), err, err2, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetClockSource::CTestDevVideoPlaySetClockSource(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetClockSource* CTestDevVideoPlaySetClockSource::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetClockSource* self = new(ELeave) CTestDevVideoPlaySetClockSource(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetClockSource::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; +// TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetClockSource")); + + // 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, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal +// TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize post processor")); + return EInconclusive; + } + } + + CSystemClockSource *time1 = NULL; + + // no parameters so no need to have a separate 'test clock source' + TRAP(err, time1 = CSystemClockSource::NewL()); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't construct system clock class")); + + return EInconclusive; + } + + // set clock source + aDevVideoPlay.SetClockSource(time1); + + // if there is no panic then test has passed + + INFO_PRINTF1(_L("SetClockSourceL() called correctly on HW Devices.")); + + // delete clock source + delete time1; time1 = NULL; + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetVideoOutput::CTestDevVideoPlaySetVideoOutput(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetVideoOutput* CTestDevVideoPlaySetVideoOutput::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetVideoOutput* self = new(ELeave) CTestDevVideoPlaySetVideoOutput(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetVideoOutput::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetVideoOutput")); + + // 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; + } + + expErr = KErrHardwareNotAvailable;//Post processor plugin will leave with this if it gets + //the method call correctly + + TRAP(err, aDevVideoPlay.SetVideoDestScreenL(ETrue) ) + + if (err != expErr) + { + ERR_PRINTF3(_L("SetVideoDestScreenL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetVideoDestScreenL(), %d = %d"), err, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySynchronizeDecoding::CTestDevVideoPlaySynchronizeDecoding(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySynchronizeDecoding* CTestDevVideoPlaySynchronizeDecoding::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySynchronizeDecoding* self = new(ELeave) CTestDevVideoPlaySynchronizeDecoding(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySynchronizeDecoding::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SynchronizeDecoding")); + + // 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; + } + + // call synchronize decoding on Decoder + aDevVideoPlay.SynchronizeDecoding(ETrue); + // if this doesn't panic then test passes + + INFO_PRINTF1(_L("SynchronizeDecoding() called successfully.")); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetBufferOptions::CTestDevVideoPlaySetBufferOptions(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetBufferOptions* CTestDevVideoPlaySetBufferOptions::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetBufferOptions* self = new(ELeave) CTestDevVideoPlaySetBufferOptions(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetBufferOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetBufferOptions")); + + // 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 buffer options to the test data + CMMFDevVideoPlay::TBufferOptions buffOptions = GetTestBufferOptions(); + + // set buffer options on decoder [will leave on error] + TRAP(err, aDevVideoPlay.SetBufferOptionsL(buffOptions) ); + + if (err != expErr) + { + ERR_PRINTF3(_L("SetBufferOptionsL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetBufferOptions(), %d = %d"), err, expErr); + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlayGetBufferOptions::CTestDevVideoPlayGetBufferOptions(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayGetBufferOptions* CTestDevVideoPlayGetBufferOptions::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayGetBufferOptions* self = new(ELeave) CTestDevVideoPlayGetBufferOptions(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayGetBufferOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBufferOptions")); + + // 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; + } + + // get buffer options from the decoder + CMMFDevVideoPlay::TBufferOptions buffOptions; + aDevVideoPlay.GetBufferOptions(buffOptions); + + // compare this to the test data + if ( !CompareBufferOptions(buffOptions, GetTestBufferOptions()) ) + { + ERR_PRINTF1(_L("GetBufferOptions() comparison with test data failed!")); + ret = EFail; + } + else + { + INFO_PRINTF1(_L("GetBufferOptions() comparison with test data passed.")); + INFO_PRINTF3(_L("GetBufferOptions(), %d = %d"), err, expErr); + } + + return ret; + } +//------------------------------------------------------------------ + +CTestDevVideoPlaySetHrdVbv::CTestDevVideoPlaySetHrdVbv(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetHrdVbv* CTestDevVideoPlaySetHrdVbv::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetHrdVbv* self = new(ELeave) CTestDevVideoPlaySetHrdVbv(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetHrdVbv::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetHrdVbv")); + + // 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; + } + + HBufC8* hrdVbvParams = NULL; + TRAP(err, hrdVbvParams = KTestHrdVbvParams().AllocL()); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize hrd/vbv params")); + return EInconclusive; + } + + // set hrd/vbv spec on decoder + aDevVideoPlay.SetHrdVbvSpec(KTestHrdVbvSpec, *hrdVbvParams); + // if this doesn't panic then test has passed + + // delete copy + delete hrdVbvParams; hrdVbvParams = NULL; + + INFO_PRINTF1(_L("SetHrdVbvSpec() called successfully.")); + + return ret; + } + +//------------------------------------------------------------------ + +void CTestDevVideoPlayInit::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayInit::CTestDevVideoPlayInit(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayInit* CTestDevVideoPlayInit::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayInit* self = new(ELeave) CTestDevVideoPlayInit(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayInit::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Init")); + + // 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 in iError + // iError is set by the MdvpoInitComplete callback + aDevVideoPlay.Initialize(); + + if (iError != expErr) + { + ERR_PRINTF3(_L("Initialize() gave error %d (expected %d)"),iError, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("Initialize(), %d = %d"), iError, expErr); + + return ret; + } + +//------------------------------------------------------------------ + +void CTestDevVideoPlayStartDSA::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayStartDSA::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayStartDSA::CTestDevVideoPlayStartDSA(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayStartDSA* CTestDevVideoPlayStartDSA::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayStartDSA* self = new(ELeave) CTestDevVideoPlayStartDSA(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayStartDSA::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: StartDSA")); + + // 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; + } + + // screen device is independant of DevVideo so we can construct one here + // and just check that it is non NULL at the plugin + CFbsScreenDevice *screenDev = NULL; + TRAP(err, screenDev = CFbsScreenDevice::NewL(_L("scdv"), EColor16)); + if (err != KErrNone) + { + ERR_PRINTF1(_L("Error - couldn't initialize screen device")); + //return EInconclusive; + } + + TRect dsaRect(KTestDSARectA, KTestDSARectB, KTestDSARectC, KTestDSARectD); + TRegionFix<1> reg1(dsaRect); + + // start direct screen access + TRAP(err, aDevVideoPlay.StartDirectScreenAccessL(dsaRect, *screenDev, reg1) ); + + // delete screen device and rect + delete screenDev; + screenDev = NULL; + + reg1.Clear(); + + if (err != expErr) + { + ERR_PRINTF3(_L("StartDirectScreenAccessL() gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("StartDirectScreenAccessL(), %d = %d"), err, expErr); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlaySetClipRegion::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlaySetClipRegion::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlaySetClipRegion::CTestDevVideoPlaySetClipRegion(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetClipRegion* CTestDevVideoPlaySetClipRegion::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetClipRegion* self = new(ELeave) CTestDevVideoPlaySetClipRegion(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetClipRegion::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetClipRegion")); + + // 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; + } + + TRect dsaRect(KTestDSARectA, KTestDSARectB, KTestDSARectC, KTestDSARectD); + TRegionFix<1> reg1(dsaRect); + + // set clip region + aDevVideoPlay.SetScreenClipRegion(reg1); + + // clear region + reg1.Clear(); + + // if no PANIC then test has passed + INFO_PRINTF1(_L("SetScreenClipRegion() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlaySetPauseClipFail::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlaySetPauseClipFail::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlaySetPauseClipFail::CTestDevVideoPlaySetPauseClipFail(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlaySetPauseClipFail* CTestDevVideoPlaySetPauseClipFail::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlaySetPauseClipFail* self = new(ELeave) CTestDevVideoPlaySetPauseClipFail(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlaySetPauseClipFail::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: SetPauseClipFail")); + + // 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; + } + + // set pause on clip fail to ETrue + aDevVideoPlay.SetPauseOnClipFail(ETrue); + + // if no PANIC then test has passed + INFO_PRINTF1(_L("SetPauseClipFail() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayAbortDSA::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayAbortDSA::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayAbortDSA::CTestDevVideoPlayAbortDSA(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayAbortDSA* CTestDevVideoPlayAbortDSA::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayAbortDSA* self = new(ELeave) CTestDevVideoPlayAbortDSA(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayAbortDSA::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: AbortDSA")); + + // 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; + } + + // abort direct screen access [is there a way to check this?] + aDevVideoPlay.AbortDirectScreenAccess(); + + INFO_PRINTF1(_L("AbortDirectScreenAccess() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayIsPlaying::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayIsPlaying::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayIsPlaying::CTestDevVideoPlayIsPlaying(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayIsPlaying* CTestDevVideoPlayIsPlaying::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayIsPlaying* self = new(ELeave) CTestDevVideoPlayIsPlaying(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayIsPlaying::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: IsPlaying")); + + // 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; + } + + TBool playing = ETrue; + + // check DevVideoPlay is not playing + playing = aDevVideoPlay.IsPlaying(); + + if (playing) + { + ERR_PRINTF1(_L("IsPlaying() reported ETrue - expected EFalse!")); + ret = EFail; + } + else + INFO_PRINTF1(_L("IsPlaying() returned EFalse as expected")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayRedraw::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayRedraw::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayRedraw::CTestDevVideoPlayRedraw(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayRedraw* CTestDevVideoPlayRedraw::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayRedraw* self = new(ELeave) CTestDevVideoPlayRedraw(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayRedraw::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Redraw")); + + // 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; + } + + // call redraw [is there a way to check this?] + aDevVideoPlay.Redraw(); + + INFO_PRINTF1(_L("Redraw() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayStart::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayStart::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayStart::CTestDevVideoPlayStart(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayStart* CTestDevVideoPlayStart::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayStart* self = new(ELeave) CTestDevVideoPlayStart(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayStart::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; +// TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Start")); + + // 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)); // EABIO 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 start on DevVideoPlay then check IsPlaying() + aDevVideoPlay.Start(); + playing = aDevVideoPlay.IsPlaying(); + + if (!playing) + { + ERR_PRINTF1(_L("IsPlaying() returned EFalse - expected ETrue")); + ret = EFail; + } + else + INFO_PRINTF1(_L("Start() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayStop::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayStop::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayStop::CTestDevVideoPlayStop(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayStop* CTestDevVideoPlayStop::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayStop* self = new(ELeave) CTestDevVideoPlayStop(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayStop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; +// TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Stop")); + + // 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 DevVideoPlay has started playing then call stop + aDevVideoPlay.Start(); + TBool playing = aDevVideoPlay.IsPlaying(); + + if (!playing) + { + ERR_PRINTF1(_L("Error - couldn't start playback!")); + return EInconclusive; + } + + // call stop + aDevVideoPlay.Stop(); + playing = aDevVideoPlay.IsPlaying(); + + if (playing) + { + ERR_PRINTF1(_L("IsPlaying() returned ETrue - expected EFalse")); + ret = EFail; + } + else + INFO_PRINTF1(_L("Stop() called successfully")); + + return ret; + } +//------------------------------------------------------------------ + +void CTestDevVideoPlayPause::MdvpoInitComplete(TInt aError) + { + INFO_PRINTF2(_L("CTestDevVideoPlayPause::MdvpoInitComplete(): Error = %d"), aError); + + iError = aError; + } + +CTestDevVideoPlayPause::CTestDevVideoPlayPause(const TDesC& aTestName, TTestType aTestType) + :CTestDevVideoPlayStep(aTestName, aTestType) + { + } + +CTestDevVideoPlayPause* CTestDevVideoPlayPause::NewL(const TDesC& aTestName, TTestType aTestType) + { + CTestDevVideoPlayPause* self = new(ELeave) CTestDevVideoPlayPause(aTestName, aTestType); + return self; + } + +TVerdict CTestDevVideoPlayPause::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) + { + TVerdict ret = EPass; +// TInt expErr = KErrNone; + TBool selDec = ETrue; + TBool selPost = ETrue; + + INFO_PRINTF1(_L("CMMFDevVideoPlay: Pause")); + + // 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 DevVideoPlay has started playing then call pause + aDevVideoPlay.Start(); + TBool playing = aDevVideoPlay.IsPlaying(); + + if (!playing) + { + ERR_PRINTF1(_L("Error - couldn't start playback!")); + return EInconclusive; + } + + // call pause + aDevVideoPlay.Pause(); + playing = aDevVideoPlay.IsPlaying(); + + if (playing) + { + ERR_PRINTF1(_L("IsPlaying() returned ETrue - expected EFalse")); + ret = EFail; + } + else + INFO_PRINTF1(_L("Pause() called successfully")); + + return ret; + } +//------------------------------------------------------------------ +