// Copyright (c) 2008-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:

//

#include <bautils.h> 

#include <bitdev.h>

#include <gulutil.h>

#include "srtdecoder.h"

#include "srtreader.h"

#include "testsrtdecoder.h"

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

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

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

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

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

// will be removed unless MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA is defined

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

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

// of doing the comparison with the existing test data 

// at runtime with the spec of KSubtitleCurrentBitmapFilePathSpec  

#ifndef MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

// #define MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

#endif 

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

    {

    __MM_HEAP_MARK;

    iSrtReader = CSrtReader::NewL(aSrtFilePath);

    iCreateSrtReaderOnly = aCreateSrtReaderOnly;

    if (!iCreateSrtReaderOnly)

        {

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

        iSrtDecoder = CSrtSubtitleDecoder::NewL(*iSrtReader);

        }

    }

void RTestSrtDecoderStep::UnInitializeTestStep()

    {

    if (!iCreateSrtReaderOnly)

        {

        iRbsSession.Disconnect();

        delete iSrtDecoder;

        }

    delete iSrtReader;

    __MM_HEAP_MARKEND;

    }

// Implementation of the generic test step

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

    {

    TBool identical = EFalse;

    RFile file1;

    RFile file2;

    TInt file1Size = 0;

    TInt file2Size = 0;

    if (aFilePath1 == aFilePath2)

        {

        identical = ETrue;

        }

    else

        {

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

        CleanupClosePushL(file1);

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

        CleanupClosePushL(file2);

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

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

        if (file1Size == file2Size)

            {

            TBuf8<256> buffer1;

            TBuf8<256> buffer2;

            identical = ETrue;

            while(ETrue)

                {

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

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

                if (buffer1 != buffer2)

                    {

                    identical = EFalse;

                    break;

                    }

                if (0 == buffer1.Length())

                    {

                    break;

                    }

                }

            }

        CleanupStack::PopAndDestroy(&file2);

        CleanupStack::PopAndDestroy(&file1);

        }

    return identical;     

    }

TBool RTestSrtDecoderStep::IsFontAvailableL(const TDesC& aTypefaceName)

    {

    TBool avail = EFalse;

    TSize bmpSize(100, 100);

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

 	CleanupStack::PushL(sampleBitmap);

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

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

    CleanupStack::PushL(bmpDevice);

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

        {

        const TInt KSubtitleFontMaxSpecHeights = 128;

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

        CleanupStack::PushL(listHeights);

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

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

            {

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

                {

                avail = ETrue;

                break;

                }

            }

        CleanupStack::PopAndDestroy(listHeights);

        }

    CleanupStack::PopAndDestroy(bmpDevice);

    CleanupStack::PopAndDestroy(sampleBitmap);

    return avail; 

    }

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

    {

    TBool identical = ETrue;

    TBuf <KMaxFullName> bitmapFilename1;

    TBuf <KMaxFullName> bitmapFilename2;

    RFs rfs;

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

    CleanupClosePushL(rfs);

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

        {

        bitmapFilename1.Format(aDestFilePathSpec, i);

        bitmapFilename2.Format(aSrcFilePathSpec, i);

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

            {

            identical = EFalse;

            break;

            }

        }

    CleanupStack::PopAndDestroy(&rfs);

    return identical;

    }

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

    {

    TBuf <KMaxFullName> bitmapFilename;

    RFs rfs;

    if (KErrNone == rfs.Connect())

        {

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

            {

            bitmapFilename.Format(aFilePathSpec, i);

            BaflUtils::DeleteFile(rfs, bitmapFilename);

            }

        }

    }    

// Implementation of RTestSrtDecoderStep0002

RTestSrtDecoderStep0002::RTestSrtDecoderStep0002()

	{

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

	}

TVerdict RTestSrtDecoderStep0002::DoTestStepPreambleL()

    {

    InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath1);

    // Install the Active Scheduler

    iActiveScheduler = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(iActiveScheduler);

	iActiveSchedulerStarted = EFalse;

    InitWservL();

    return EPass;

    }

TVerdict RTestSrtDecoderStep0002::DoTestStepPostambleL()

    {

    UninitWserv();

    CActiveScheduler::Install(NULL);

	delete iActiveScheduler;

    iActiveScheduler = NULL;

    UnInitializeTestStep();

    return EPass;

    }

TVerdict RTestSrtDecoderStep0002::DoTestStepL()

	{

	INFO_PRINTF1(_L("Enter DoTestStepL"));

	TVerdict result = EPass;

    TRAPD(err, TestGetNextFrameL());

    if (KErrNone != err)

        {

        result = EFail;

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

        }

    INFO_PRINTF1(_L("Exit DoTestStepL"));

	return result;

	}

void RTestSrtDecoderStep0002::InitWservL()

    {

    TInt err = iWs.Connect();

    if (err != KErrNone)

        {

        // Access violation if ws is null

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

        User::Leave(err);

        }

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

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

    iRootWindow = RWindowGroup(iWs);

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

    iWindow = new(ELeave) RWindow(iWs);

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

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

    iWindow->SetVisible(ETrue);

    iWindow->SetRequiredDisplayMode(EColor16MA);

    // Light Sky Blue 135-206-250

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

    iWindow->SetBackgroundColor(backgroundColour);

    iGc = new(ELeave) CWindowGc(iScreen);

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

    iWindow->Activate();

    iWs.Flush();

    }

void RTestSrtDecoderStep0002::UninitWserv()

    {

    if (iWindow)

        {

        iWindow->Close();

        delete iWindow;

        iWindow = NULL;

        }

    iRootWindow.Close();

    delete iScreen;

    iScreen = NULL;

    delete iGc;

    iGc = NULL;

    iWs.Flush();

    iWs.Close();

    }

void RTestSrtDecoderStep0002::PrepGc()

	{

	iGc->Activate(*iWindow);

	iWindow->Invalidate();

	iWindow->BeginRedraw();

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

	iWs.Flush();

	}

void RTestSrtDecoderStep0002::RetireGc()

	{

	iGc->Deactivate();

	iWindow->EndRedraw();

	iWs.Flush();

	}

void RTestSrtDecoderStep0002::DrawBitmap(CFbsBitmap& aBitmap)

	{	

	PrepGc();

    TSize size = iScreen->SizeInPixels();

    TInt width = size.iWidth;

    TInt height = size.iHeight;

    TPoint pos(0, 0);

    // Draw a square border

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

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

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

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

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

    // Draw a line between the corners of the window

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

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

	// Draw bitmap

	iGc->BitBlt(pos, &aBitmap);

	RetireGc();

	}

void RTestSrtDecoderStep0002::TestGetNextFrameL()

    {

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

    const TInt64 KSrtMicroSecondsInAMilliSecond = 1000;

    const TInt64 KSrtMicroSecondsInASecond = KSrtMicroSecondsInAMilliSecond * 1000;

    const TInt64 KSrtMicroSecondsInAMinute = KSrtMicroSecondsInASecond * 60;

    const TInt64 KSrtMicroSecondsInAnHour = KSrtMicroSecondsInAMinute * 60;

    const TInt KSrtSetPosTestCount = 6;

    const TInt KSrtNumOfFrames = 10;

    TTimeIntervalMicroSeconds videoPos[KSrtSetPosTestCount] = 

        {

        0,

        KSrtMicroSecondsInAMinute,

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

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

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

        2 * KSrtMicroSecondsInAnHour

        };

    TInt expectedNumOfFrames[KSrtSetPosTestCount] = 

        {

        10,

        8,

        6,

        6,

        2,

        0

        };

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

    TInt requiredFontAvailable = IsFontAvailableL(KSrtTargetTypefaceName);

    if (!requiredFontAvailable)

        {

#ifdef MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA 

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

        User::Leave(KErrGeneral);

#else

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

#endif //MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA 

        }

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

		{

#ifdef __WINSCW__

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

#else

		TBool compareBitmap = EFalse;

#endif //__WINSCW__

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

        // verify the bitmaps

        if (compareBitmap)

            {

#ifndef MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA

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

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

            if (!compResult)

                {

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

                User::Leave(KErrGeneral);

                }

#endif //MMF_SUBTITLE_SUPPORT_TEST_SAVEDATA 

            }

        }

    }

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

    {

    TRect dirtyRegion;

    TTimeIntervalMicroSeconds displayTime = 0;

    TTimeIntervalMicroSeconds displayDuration = 0;

    TInt64 tDisplayTime = 0;

    TInt64 tDisplayDuration = 0;

    TSize bmpSize(600, 300);

    TInt numOfFrames = 0;

 	TInt err = KErrNone;

 	TBuf <KMaxFullName> bitmapFilename;

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

 	CleanupStack::PushL(sampleBitmap);

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

    iSrtDecoder->SetVideoPosition(aPosition);

    iSrtDecoder->Start();

    while (KErrNone == err)

        {

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

        if (KErrNone == err)

            {

            // show bitmap

            DrawBitmap(*sampleBitmap);

            // save bitmap for the possible comparison

            if (aSaveBitmap)

                {

                bitmapFilename.Format(KSubtitleCurrentBitmapFilePathSpec, numOfFrames);

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

                }

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

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

                {

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

                User::Leave(KErrGeneral);

                }

            tDisplayTime = displayTime.Int64()/1000;

            tDisplayDuration = displayDuration.Int64()/1000;

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

                numOfFrames, 

                I64LOW(tDisplayTime), 

                I64LOW(tDisplayDuration));

            numOfFrames++;

            }

        }

    CleanupStack::PopAndDestroy(sampleBitmap);

    iSrtDecoder->Stop();

    if (KErrEof != err)

        {

        User::Leave(err);

        }

    if (aExpectedNumOfFrames != numOfFrames)

        {

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

        User::Leave(KErrGeneral);

        }

    }

// Implementation of RTestSrtDecoderStep0101

RTestSrtDecoderStep0101::RTestSrtDecoderStep0101()

	{

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

	}

TVerdict RTestSrtDecoderStep0101::DoTestStepPreambleL()

    {

    InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath2);

    return EPass;

    }

TVerdict RTestSrtDecoderStep0101::DoTestStepPostambleL()

    {

    UnInitializeTestStep();

    return EPass;

    }

TVerdict RTestSrtDecoderStep0101::DoTestStepL()

	{

	INFO_PRINTF1(_L("Enter DoTestStepL"));

	TVerdict result = EPass;

    TRAPD(err, TestGetNextFrameL());

    if (KErrNone != err)

        {

        result = EFail;

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

        INFO_PRINTF1(_L("Exit CSrtDecoder"));

	    return result;

        }

    INFO_PRINTF1(_L("Exit DoTestStepL"));

	return result;

	}

void RTestSrtDecoderStep0101::TestGetNextFrameL()

    {

    TInt numOfValidFrame = 0;

    const TInt KSrtCase0101ExpectedValidFrame = 6;

    TRect dirtyRegion;

    TTimeIntervalMicroSeconds displayTime = 0;

    TTimeIntervalMicroSeconds displayDuration = 0;

    TSize bmpSize(320, 120);

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

 	CleanupStack::PushL(sampleBitmap);

 	TInt err = sampleBitmap->Create(

		bmpSize,

        EColor16MA

        );

    User::LeaveIfError(err);

    iSrtDecoder->SetVideoPosition(0);

    iSrtDecoder->Start();

    while (KErrNone == err)

        {

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

        if (KErrNone == err)

            {

            numOfValidFrame++;

            }

        else if (KErrArgument == err)

            {

            err = KErrNone;

            }

        }

    CleanupStack::PopAndDestroy(sampleBitmap);

    iSrtDecoder->Stop();

    if (err != KErrEof)

        {

        User::Leave(err);

        }

    if (KSrtCase0101ExpectedValidFrame != numOfValidFrame)

        {

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

        User::Leave(KErrGeneral);

        }

    }

// Implementation of RTestSrtDecoderStep0103

RTestSrtDecoderStep0103::RTestSrtDecoderStep0103()

	{

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

	}

TVerdict RTestSrtDecoderStep0103::DoTestStepPreambleL()

    {

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

    return EPass;

    }

TVerdict RTestSrtDecoderStep0103::DoTestStepPostambleL()

    {

    RFbsSession::Disconnect();

    return EPass;

    }

TVerdict RTestSrtDecoderStep0103::DoTestStepL()

	{

	INFO_PRINTF1(_L("Enter DoTestStepL"));

	TVerdict result = EFail;

	TSize bmpSize(120, 320);

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

 	CleanupStack::PushL(sampleBitmap);

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

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

        {

        __UHEAP_SETFAIL(RHeap::EFailNext, failRate);

    	__UHEAP_MARK;

    	TRAPD(error, TestGetNextFrameL(*sampleBitmap));

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

        __UHEAP_MARKEND;

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

    	    {

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

    		break;

    	    }    	

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

    	User::Free(pointer);

    	if (!pointer)

    		{

    		result = EPass;

    		break;

    		}

        }

    __UHEAP_RESET; 

    CleanupStack::PopAndDestroy(sampleBitmap);

    INFO_PRINTF1(_L("Exit DoTestStepL"));

	return result;

	}

void RTestSrtDecoderStep0103::TestGetNextFrameL(CFbsBitmap& aBitmap)

    {

    TRect dirtyRegion;

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

    CleanupStack::PushL(srtReader);

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

    CleanupStack::PushL(srtDecoder);

    TInt err = KErrNone;

    TTimeIntervalMicroSeconds displayTime = 0;

    TTimeIntervalMicroSeconds displayDuration = 0;

 	srtDecoder->SetVideoPosition(0);

    srtDecoder->Start();

    while (KErrNone == err)

        {

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

        }

    if (err != KErrEof)

        {

        User::LeaveIfError(err);

        }

    srtDecoder->Stop();

    CleanupStack::PopAndDestroy(srtDecoder);

    CleanupStack::PopAndDestroy(srtReader);

    }

RTestSrtDecoderStep0105::RTestSrtDecoderStep0105()

	{

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

	}

TVerdict RTestSrtDecoderStep0105::DoTestStepL()

	{

	iSrtDecoder->Start();

	iSrtDecoder->Start();

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

	return EFail;

	}

TVerdict RTestSrtDecoderStep0105::DoTestStepPreambleL()

	{

	InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath1);

	return EPass;

	}

TVerdict RTestSrtDecoderStep0105::DoTestStepPostambleL()

	{

	UnInitializeTestStep();

	return EPass;

	}