Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/srtdecoder/src/testsrtdecoder.cpp@260cb5ec6c19

     1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <bautils.h>

    17 #include <bitdev.h>

    18 #include <gulutil.h>

    20 #include "srtdecoder.h"

    21 #include "srtreader.h"

    22 #include "testsrtdecoder.h"

    24 _LIT(KSampleSubtitleSRTFilepath1, "c:\\mm\\subtitle1.srt");

    25 _LIT(KSampleSubtitleSRTFilepath2, "c:\\mm\\subtitle2.srt");

    27 // subtitlebmp0.mbm -- subtitlebmp9.mbm: bitmaps for comparison

    28 _LIT(KSubtitleTargetBitmapFilePathSpec, "c:\\mm\\subtitlebmp%d.mbm");

    29 // subtitlecurbmp0.mbm -- subtitlecurbmp9.mbm: runtime bitmaps for comparison,

    30 // will be removed unless MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA is defined

    31 _LIT(KSubtitleCurrentBitmapFilePathSpec, "c:\\mm\\subtitlecurbmp%d.mbm");

    33 // defining MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA means re-creating the test data (bitmaps) for comparison, instead

    34 // of doing the comparison with the existing test data

    35 // at runtime with the spec of KSubtitleCurrentBitmapFilePathSpec

    36 #ifndef MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

    37 // #define MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

    38 #endif

    40 void RTestSrtDecoderStep::InitializeTestStepL(TBool aCreateSrtReaderOnly, const TDesC& aSrtFilePath)

    41     {

    42     __MM_HEAP_MARK;

    43     iSrtReader = CSrtReader::NewL(aSrtFilePath);

    45     iCreateSrtReaderOnly = aCreateSrtReaderOnly;

    46     if (!iCreateSrtReaderOnly)

    47         {

    48         User::LeaveIfError(iRbsSession.Connect());

    49         iSrtDecoder = CSrtSubtitleDecoder::NewL(*iSrtReader);

    50         }

    51     }

    53 void RTestSrtDecoderStep::UnInitializeTestStep()

    54     {

    55     if (!iCreateSrtReaderOnly)

    56         {

    57         iRbsSession.Disconnect();

    58         delete iSrtDecoder;

    59         }

    60     delete iSrtReader;

    61     __MM_HEAP_MARKEND;

    62     }

    64 // Implementation of the generic test step

    65 TBool RTestSrtDecoderStep::CompareFilesL(RFs &aFs, const TDesC& aFilePath1, const TDesC& aFilePath2)

    66     {

    67     TBool identical = EFalse;

    68     RFile file1;

    69     RFile file2;

    70     TInt file1Size = 0;

    71     TInt file2Size = 0;

    73     if (aFilePath1 == aFilePath2)

    74         {

    75         identical = ETrue;

    76         }

    77     else

    78         {

    79         User::LeaveIfError(file1.Open(aFs, aFilePath1, EFileRead));

    80         CleanupClosePushL(file1);

    81         User::LeaveIfError(file2.Open(aFs, aFilePath2, EFileRead));

    82         CleanupClosePushL(file2);

    84         User::LeaveIfError(file1.Size(file1Size));

    85         User::LeaveIfError(file2.Size(file2Size));

    87         if (file1Size == file2Size)

    88             {

    89             TBuf8<256> buffer1;

    90             TBuf8<256> buffer2;

    92             identical = ETrue;

    93             while(ETrue)

    94                 {

    95                 User::LeaveIfError(file1.Read(buffer1));

    96                 User::LeaveIfError(file2.Read(buffer2));

    98                 if (buffer1 != buffer2)

    99                     {

   100                     identical = EFalse;

   101                     break;

   102                     }

   104                 if (0 == buffer1.Length())

   105                     {

   106                     break;

   107                     }

   108                 }

   109             }

   111         CleanupStack::PopAndDestroy(&file2);

   112         CleanupStack::PopAndDestroy(&file1);

   113         }

   115     return identical;

   116     }

   118 TBool RTestSrtDecoderStep::IsFontAvailableL(const TDesC& aTypefaceName)

   119     {

   120     TBool avail = EFalse;

   121     TSize bmpSize(100, 100);

   123     CFbsBitmap* sampleBitmap = new (ELeave) CFbsBitmap();

   124  	CleanupStack::PushL(sampleBitmap);

   126  	User::LeaveIfError(sampleBitmap->Create(bmpSize, EColor16MA));

   128     CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL(sampleBitmap);

   129     CleanupStack::PushL(bmpDevice);

   131     if (0 != FontUtils::TypefaceAttributes(*bmpDevice, aTypefaceName))

   132         {

   133         const TInt KSubtitleFontMaxSpecHeights = 128;

   134         CArrayFix<TInt> *listHeights = new (ELeave) CArrayFixFlat<TInt>(KSubtitleFontMaxSpecHeights);

   135         CleanupStack::PushL(listHeights);

   137         FontUtils::GetAvailableHeightsInTwipsL(*bmpDevice, aTypefaceName, *listHeights);

   138         for (TInt i = 0; i < listHeights->Count(); i++)

   139             {

   140             if (KSrtTargetTypefaceHeightInTwips == (*listHeights)[i])

   141                 {

   142                 avail = ETrue;

   143                 break;

   144                 }

   145             }

   147         CleanupStack::PopAndDestroy(listHeights);

   148         }

   150     CleanupStack::PopAndDestroy(bmpDevice);

   151     CleanupStack::PopAndDestroy(sampleBitmap);

   153     return avail;

   154     }

   156 TBool RTestSrtDecoderStep::CompareBmpFilesL(TInt aStartIndex, TInt aEndIndex, const TDesC& aSrcFilePathSpec, const TDesC& aDestFilePathSpec)

   157     {

   158     TBool identical = ETrue;

   159     TBuf <KMaxFullName> bitmapFilename1;

   160     TBuf <KMaxFullName> bitmapFilename2;

   161     RFs rfs;

   162     User::LeaveIfError(rfs.Connect());

   163     CleanupClosePushL(rfs);

   164     for (TInt i = aStartIndex; i <= aEndIndex; i++)

   165         {

   166         bitmapFilename1.Format(aDestFilePathSpec, i);

   167         bitmapFilename2.Format(aSrcFilePathSpec, i);

   168         if (!CompareFilesL(rfs, bitmapFilename1, bitmapFilename2))

   169             {

   170             identical = EFalse;

   171             break;

   172             }

   173         }

   174     CleanupStack::PopAndDestroy(&rfs);

   176     return identical;

   177     }

   179 void RTestSrtDecoderStep::DeleteTempFiles(TInt aStartIndex, TInt aEndIndex, const TDesC& aFilePathSpec)

   180     {

   181     TBuf <KMaxFullName> bitmapFilename;

   182     RFs rfs;

   184     if (KErrNone == rfs.Connect())

   185         {

   186         for (TInt i = aStartIndex ; i <= aEndIndex; i++)

   187             {

   188             bitmapFilename.Format(aFilePathSpec, i);

   189             BaflUtils::DeleteFile(rfs, bitmapFilename);

   190             }

   191         }

   192     }

   195 // Implementation of RTestSrtDecoderStep0002

   197 RTestSrtDecoderStep0002::RTestSrtDecoderStep0002()

   198 	{

   199 	iTestStepName = _L("MM-MMF-SUBTITLE-SRTDECODER-U-0002-HP");

   200 	}

   202 TVerdict RTestSrtDecoderStep0002::DoTestStepPreambleL()

   203     {

   204     InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath1);

   206     // Install the Active Scheduler

   207     iActiveScheduler = new(ELeave) CActiveScheduler;

   208     CActiveScheduler::Install(iActiveScheduler);

   209 	iActiveSchedulerStarted = EFalse;

   211     InitWservL();

   213     return EPass;

   214     }

   216 TVerdict RTestSrtDecoderStep0002::DoTestStepPostambleL()

   217     {

   218     UninitWserv();

   219     CActiveScheduler::Install(NULL);

   220 	delete iActiveScheduler;

   221     iActiveScheduler = NULL;

   223     UnInitializeTestStep();

   225     return EPass;

   226     }

   228 TVerdict RTestSrtDecoderStep0002::DoTestStepL()

   229 	{

   230 	INFO_PRINTF1(_L("Enter DoTestStepL"));

   231 	TVerdict result = EPass;

   233     TRAPD(err, TestGetNextFrameL());

   234     if (KErrNone != err)

   235         {

   236         result = EFail;

   237         ERR_PRINTF2(_L("Error - RTestSrtDecoderStep0002::TestGetNextFrameL failed. error code %d. "), err);

   238         }

   240     INFO_PRINTF1(_L("Exit DoTestStepL"));

   241 	return result;

   242 	}

   244 void RTestSrtDecoderStep0002::InitWservL()

   245     {

   246     TInt err = iWs.Connect();

   248     if (err != KErrNone)

   249         {

   250         // Access violation if ws is null

   251         ERR_PRINTF2(_L("Error - Failed to connect to RWsSession. error code %d. "), err);

   252         User::Leave(err);

   253         }

   255     iScreen = new (ELeave) CWsScreenDevice(iWs); // make device for this session

   256     User::LeaveIfError(iScreen->Construct()); // and complete its construction

   258     iRootWindow = RWindowGroup(iWs);

   259     User::LeaveIfError(iRootWindow.Construct((TUint32)this, ETrue));

   261     iWindow = new(ELeave) RWindow(iWs);

   262     User::LeaveIfError(((RWindow*)iWindow)->Construct(iRootWindow,((TUint32)(this)) + 1));

   263     iWindow->SetExtent(TPoint(0,0), iScreen->SizeInPixels());

   264     iWindow->SetVisible(ETrue);

   265     iWindow->SetRequiredDisplayMode(EColor16MA);

   267     // Light Sky Blue 135-206-250

   268     TRgb backgroundColour = TRgb(135, 206, 250);

   269     iWindow->SetBackgroundColor(backgroundColour);

   271     iGc = new(ELeave) CWindowGc(iScreen);

   272 	User::LeaveIfError(iGc->Construct());

   274     iWindow->Activate();

   275     iWs.Flush();

   276     }

   278 void RTestSrtDecoderStep0002::UninitWserv()

   279     {

   280     if (iWindow)

   281         {

   282         iWindow->Close();

   283         delete iWindow;

   284         iWindow = NULL;

   285         }

   287     iRootWindow.Close();

   288     delete iScreen;

   289     iScreen = NULL;

   291     delete iGc;

   292     iGc = NULL;

   294     iWs.Flush();

   295     iWs.Close();

   296     }

   298 void RTestSrtDecoderStep0002::PrepGc()

   299 	{

   300 	iGc->Activate(*iWindow);

   301 	iWindow->Invalidate();

   302 	iWindow->BeginRedraw();

   304 	iGc->Clear(TRect(iScreen->SizeInPixels()));

   305 	iWs.Flush();

   306 	}

   308 void RTestSrtDecoderStep0002::RetireGc()

   309 	{

   310 	iGc->Deactivate();

   311 	iWindow->EndRedraw();

   312 	iWs.Flush();

   313 	}

   315 void RTestSrtDecoderStep0002::DrawBitmap(CFbsBitmap& aBitmap)

   316 	{

   317 	PrepGc();

   319     TSize size = iScreen->SizeInPixels();

   320     TInt width = size.iWidth;

   321     TInt height = size.iHeight;

   322     TPoint pos(0, 0);

   324     // Draw a square border

   325     iGc->SetPenColor(TRgb(255,0,0));

   326     iGc->DrawLine(TPoint(0,0),TPoint(0,height-1));

   327     iGc->DrawLine (TPoint (0, height-1), TPoint (width-1, height-1));

   328     iGc->DrawLine(TPoint(width-1,height-1),TPoint(width-1,0));

   329     iGc->DrawLine (TPoint (width-1, 0), TPoint (0, 0));

   331     // Draw a line between the corners of the window

   332     iGc->DrawLine(TPoint(0,0),TPoint(width, height));

   333     iGc->DrawLine (TPoint (0, height), TPoint (width, 0));

   335 	// Draw bitmap

   336 	iGc->BitBlt(pos, &aBitmap);

   338 	RetireGc();

   339 	}

   341 void RTestSrtDecoderStep0002::TestGetNextFrameL()

   342     {

   343     // start/stop for multiple times is also tested.

   344     const TInt64 KSrtMicroSecondsInAMilliSecond = 1000;

   345     const TInt64 KSrtMicroSecondsInASecond = KSrtMicroSecondsInAMilliSecond * 1000;

   346     const TInt64 KSrtMicroSecondsInAMinute = KSrtMicroSecondsInASecond * 60;

   347     const TInt64 KSrtMicroSecondsInAnHour = KSrtMicroSecondsInAMinute * 60;

   348     const TInt KSrtSetPosTestCount = 6;

   349     const TInt KSrtNumOfFrames = 10;

   351     TTimeIntervalMicroSeconds videoPos[KSrtSetPosTestCount] =

   352         {

   353         0,

   354         KSrtMicroSecondsInAMinute,

   355         1 * KSrtMicroSecondsInAMinute + 2 * KSrtMicroSecondsInASecond + 1 * KSrtMicroSecondsInAMilliSecond,

   356         1 * KSrtMicroSecondsInAMinute + 6 * KSrtMicroSecondsInASecond + 20 * KSrtMicroSecondsInAMilliSecond,

   357         1 * KSrtMicroSecondsInAnHour + 1 * KSrtMicroSecondsInAMinute + 20 * KSrtMicroSecondsInASecond + 1 * KSrtMicroSecondsInAMilliSecond,

   358         2 * KSrtMicroSecondsInAnHour

   359         };

   361     TInt expectedNumOfFrames[KSrtSetPosTestCount] =

   362         {

   363         10,

   364         8,

   365         6,

   366         6,

   367         2,

   368         0

   369         };

   371     // check if the required Font is available before do the bitmap file comparison

   372     TInt requiredFontAvailable = IsFontAvailableL(KSrtTargetTypefaceName);

   373     if (!requiredFontAvailable)

   374         {

   375 #ifdef MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

   376         INFO_PRINTF1(_L("Required font is not available, cannot save bitmap data. "));

   377         User::Leave(KErrGeneral);

   378 #else

   379         INFO_PRINTF1(_L("Required font is not available, no bitmap comparison. "));

   380 #endif //MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

   381         }

   383     for (TInt i = 0; i < KSrtSetPosTestCount; i++)

   384 		{

   385 #ifdef __WINSCW__

   386 		TBool compareBitmap = (0 == i) && requiredFontAvailable;

   387 #else

   388 		TBool compareBitmap = EFalse;

   389 #endif //__WINSCW__

   391         TestGetNextFrameByPositionsL(videoPos[i], expectedNumOfFrames[i], compareBitmap);

   393         // verify the bitmaps

   394         if (compareBitmap)

   395             {

   396 #ifndef MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

   397             TBool compResult = CompareBmpFilesL(KSrtNumOfFrames - expectedNumOfFrames[i], KSrtNumOfFrames - 1, KSubtitleCurrentBitmapFilePathSpec, KSubtitleTargetBitmapFilePathSpec);

   399             DeleteTempFiles(KSrtNumOfFrames - expectedNumOfFrames[i], KSrtNumOfFrames - 1, KSubtitleCurrentBitmapFilePathSpec);

   401             if (!compResult)

   402                 {

   403                 INFO_PRINTF1(_L("At least one bitmap file does not match the expected one. "));

   404                 User::Leave(KErrGeneral);

   405                 }

   406 #endif //MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

   407             }

   408         }

   409     }

   411 void RTestSrtDecoderStep0002::TestGetNextFrameByPositionsL(const TTimeIntervalMicroSeconds& aPosition, TInt aExpectedNumOfFrames, TBool aSaveBitmap)

   412     {

   413     TRect dirtyRegion;

   414     TTimeIntervalMicroSeconds displayTime = 0;

   415     TTimeIntervalMicroSeconds displayDuration = 0;

   416     TInt64 tDisplayTime = 0;

   417     TInt64 tDisplayDuration = 0;

   418     TSize bmpSize(600, 300);

   419     TInt numOfFrames = 0;

   420  	TInt err = KErrNone;

   421  	TBuf <KMaxFullName> bitmapFilename;

   423  	CFbsBitmap* sampleBitmap = new (ELeave) CFbsBitmap();

   424  	CleanupStack::PushL(sampleBitmap);

   426     User::LeaveIfError(sampleBitmap->Create(bmpSize, EColor16MA));

   428     iSrtDecoder->SetVideoPosition(aPosition);

   429     iSrtDecoder->Start();

   431     while (KErrNone == err)

   432         {

   433         TRAP(err, iSrtDecoder->GetNextFrameL(*sampleBitmap, dirtyRegion, displayTime, displayDuration));

   434         if (KErrNone == err)

   435             {

   436             // show bitmap

   437             DrawBitmap(*sampleBitmap);

   439             // save bitmap for the possible comparison

   440             if (aSaveBitmap)

   441                 {

   442                 bitmapFilename.Format(KSubtitleCurrentBitmapFilePathSpec, numOfFrames);

   443                 User::LeaveIfError(sampleBitmap->Save(bitmapFilename));

   444                 }

   446             if ((dirtyRegion.iTl.iX >= dirtyRegion.iBr.iX) ||

   447                 (dirtyRegion.iTl.iY >= dirtyRegion.iBr.iY))

   448                 {

   449                 INFO_PRINTF2(_L("Invalid dirty region received. (frame %d)"), numOfFrames);

   450                 User::Leave(KErrGeneral);

   451                 }

   453             tDisplayTime = displayTime.Int64()/1000;

   454             tDisplayDuration = displayDuration.Int64()/1000;

   455             INFO_PRINTF4(_L("Frame[%d]: displayTime: %dms, displayDuration: %dms."),

   456                 numOfFrames,

   457                 I64LOW(tDisplayTime),

   458                 I64LOW(tDisplayDuration));

   460             numOfFrames++;

   461             }

   462         }

   464     CleanupStack::PopAndDestroy(sampleBitmap);

   466     iSrtDecoder->Stop();

   468     if (KErrEof != err)

   469         {

   470         User::Leave(err);

   471         }

   473     if (aExpectedNumOfFrames != numOfFrames)

   474         {

   475         INFO_PRINTF2(_L("The number of frame (%d) is unexpected. "), numOfFrames);

   476         User::Leave(KErrGeneral);

   477         }

   478     }

   481 // Implementation of RTestSrtDecoderStep0101

   483 RTestSrtDecoderStep0101::RTestSrtDecoderStep0101()

   484 	{

   485 	iTestStepName = _L("MM-MMF-SUBTITLE-SRTDECODER-U-0101-HP");

   486 	}

   488 TVerdict RTestSrtDecoderStep0101::DoTestStepPreambleL()

   489     {

   490     InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath2);

   492     return EPass;

   493     }

   495 TVerdict RTestSrtDecoderStep0101::DoTestStepPostambleL()

   496     {

   497     UnInitializeTestStep();

   499     return EPass;

   500     }

   502 TVerdict RTestSrtDecoderStep0101::DoTestStepL()

   503 	{

   504 	INFO_PRINTF1(_L("Enter DoTestStepL"));

   505 	TVerdict result = EPass;

   507     TRAPD(err, TestGetNextFrameL());

   508     if (KErrNone != err)

   509         {

   510         result = EFail;

   511         ERR_PRINTF2(_L("Error - RTestSrtDecoderStep0101::TestGetNextFrameL failed. error code %d. "), err);

   512         INFO_PRINTF1(_L("Exit CSrtDecoder"));

   513 	    return result;

   514         }

   516     INFO_PRINTF1(_L("Exit DoTestStepL"));

   517 	return result;

   518 	}

   520 void RTestSrtDecoderStep0101::TestGetNextFrameL()

   521     {

   522     TInt numOfValidFrame = 0;

   523     const TInt KSrtCase0101ExpectedValidFrame = 6;

   524     TRect dirtyRegion;

   525     TTimeIntervalMicroSeconds displayTime = 0;

   526     TTimeIntervalMicroSeconds displayDuration = 0;

   527     TSize bmpSize(320, 120);

   529     CFbsBitmap* sampleBitmap = new (ELeave) CFbsBitmap();

   530  	CleanupStack::PushL(sampleBitmap);

   532  	TInt err = sampleBitmap->Create(

   533 		bmpSize,

   534         EColor16MA

   535         );

   536     User::LeaveIfError(err);

   538     iSrtDecoder->SetVideoPosition(0);

   539     iSrtDecoder->Start();

   541     while (KErrNone == err)

   542         {

   543         TRAP(err, iSrtDecoder->GetNextFrameL(*sampleBitmap, dirtyRegion, displayTime, displayDuration));

   544         if (KErrNone == err)

   545             {

   546             numOfValidFrame++;

   547             }

   548         else if (KErrArgument == err)

   549             {

   550             err = KErrNone;

   551             }

   552         }

   554     CleanupStack::PopAndDestroy(sampleBitmap);

   556     iSrtDecoder->Stop();

   558     if (err != KErrEof)

   559         {

   560         User::Leave(err);

   561         }

   563     if (KSrtCase0101ExpectedValidFrame != numOfValidFrame)

   564         {

   565         INFO_PRINTF2(_L("The number of valid frame (%d) is unexpected. "), numOfValidFrame);

   566         User::Leave(KErrGeneral);

   567         }

   568     }

   570 // Implementation of RTestSrtDecoderStep0103

   572 RTestSrtDecoderStep0103::RTestSrtDecoderStep0103()

   573 	{

   574 	iTestStepName = _L("MM-MMF-SUBTITLE-SRTDECODER-U-0103-HP");

   575 	}

   577 TVerdict RTestSrtDecoderStep0103::DoTestStepPreambleL()

   578     {

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

   581     return EPass;

   582     }

   584 TVerdict RTestSrtDecoderStep0103::DoTestStepPostambleL()

   585     {

   586     RFbsSession::Disconnect();

   588     return EPass;

   589     }

   591 TVerdict RTestSrtDecoderStep0103::DoTestStepL()

   592 	{

   593 	INFO_PRINTF1(_L("Enter DoTestStepL"));

   594 	TVerdict result = EFail;

   595 	TSize bmpSize(120, 320);

   597     CFbsBitmap* sampleBitmap = new (ELeave) CFbsBitmap();

   598  	CleanupStack::PushL(sampleBitmap);

   599  	User::LeaveIfError(sampleBitmap->Create(bmpSize, EColor16MA));

   601     for (TInt failRate = 1; ; ++failRate)

   602         {

   603         __UHEAP_SETFAIL(RHeap::EFailNext, failRate);

   604     	__UHEAP_MARK;

   606     	TRAPD(error, TestGetNextFrameL(*sampleBitmap));

   607     	RDebug::Printf("Ending iteration %d.  Result = %d. Failures = %d", failRate, error, __UHEAP_CHECKFAILURE);

   609         __UHEAP_MARKEND;

   611     	if ((error != KErrNone) && (error != KErrNoMemory))

   612     	    {

   613     	    ERR_PRINTF3(_L("RTestSrtDecoderStep0103: TESTS FAILED TO COMPLETE (failRate=%i) error code: %d\n"), failRate, error);

   614     		break;

   615     	    }

   617         TAny* const pointer = User::Alloc(1);

   618     	User::Free(pointer);

   619     	if (!pointer)

   620     		{

   621     		result = EPass;

   622     		break;

   623     		}

   624         }

   626     __UHEAP_RESET;

   628     CleanupStack::PopAndDestroy(sampleBitmap);

   630     INFO_PRINTF1(_L("Exit DoTestStepL"));

   631 	return result;

   632 	}

   634 void RTestSrtDecoderStep0103::TestGetNextFrameL(CFbsBitmap& aBitmap)

   635     {

   636     TRect dirtyRegion;

   637     CSrtReader *srtReader = CSrtReader::NewL(KSampleSubtitleSRTFilepath1);

   638     CleanupStack::PushL(srtReader);

   640     CSrtSubtitleDecoder *srtDecoder = CSrtSubtitleDecoder::NewL(*srtReader);

   641     CleanupStack::PushL(srtDecoder);

   643     TInt err = KErrNone;

   644     TTimeIntervalMicroSeconds displayTime = 0;

   645     TTimeIntervalMicroSeconds displayDuration = 0;

   647  	srtDecoder->SetVideoPosition(0);

   648     srtDecoder->Start();

   650     while (KErrNone == err)

   651         {

   652         TRAP(err, srtDecoder->GetNextFrameL(aBitmap, dirtyRegion, displayTime, displayDuration));

   653         }

   655     if (err != KErrEof)

   656         {

   657         User::LeaveIfError(err);

   658         }

   660     srtDecoder->Stop();

   662     CleanupStack::PopAndDestroy(srtDecoder);

   663     CleanupStack::PopAndDestroy(srtReader);

   664     }

   666 RTestSrtDecoderStep0105::RTestSrtDecoderStep0105()

   667 	{

   668 	iTestStepName = _L("MM-MMF-SUBTITLE-SRTDECODER-U-0105-HP");

   669 	}

   671 TVerdict RTestSrtDecoderStep0105::DoTestStepL()

   672 	{

   673 	iSrtDecoder->Start();

   674 	iSrtDecoder->Start();

   676 	ERR_PRINTF1(_L("Panic expected, so failing"));

   677 	return EFail;

   678 	}

   680 TVerdict RTestSrtDecoderStep0105::DoTestStepPreambleL()

   681 	{

   682 	InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath1);

   683 	return EPass;

   684 	}

   686 TVerdict RTestSrtDecoderStep0105::DoTestStepPostambleL()

   687 	{

   688 	UnInitializeTestStep();

   689 	return EPass;

   690 	}

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