MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/tsrc/mmfunittest/srtdecoder/src/testsrtdecoderregionfuncs.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     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 //

    15 

    16 #include "srtdecoder.h"

    17 #include "srtreader.h"

    18 #include "testsrtdecoderregionfuncs.h"

    19 

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

    21 

    22 // Implementation of RTestSrtDecoderStep0001

    23 

    24 RTestSrtDecoderStep0001::RTestSrtDecoderStep0001()

    25 	{

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

    27 	}

    28 	

    29 TVerdict RTestSrtDecoderStep0001::DoTestStepPreambleL()

    30     {

    31     InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath1);

    32     

    33     return EPass;

    34     }

    35 	

    36 TVerdict RTestSrtDecoderStep0001::DoTestStepPostambleL()

    37     {

    38     UnInitializeTestStep();

    39     

    40     return EPass;

    41     }

    42 	

    43 TVerdict RTestSrtDecoderStep0001::DoTestStepL()

    44 	{

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

    46 	TVerdict result = TestCalculateSubtitleRegion();

    47     if (EPass != result)

    48         {

    49         ERR_PRINTF1(_L("Error - RTestSrtDecoderStep0001::TestCalculateSubtitleRegion failed. "));

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

    51 	    return result;

    52         }

    53         

    54     result = TestSetVideoPosition();

    55     if (EPass != result)

    56         {

    57         ERR_PRINTF1(_L("Error - RTestSrtDecoderStep0001::TestSetVideoPosition failed. "));

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

    59 	    return result;

    60         }

    61         

    62     result = TestStartStop();

    63     if (EPass != result)

    64         {

    65         ERR_PRINTF1(_L("Error - RTestSrtDecoderStep0001::TestStartStop failed. "));

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

    67 	    return result;

    68         }

    69      

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

    71 	return result;

    72 	}

    73 

    74 

    75 TVerdict RTestSrtDecoderStep0001::TestCalculateSubtitleRegion()

    76     {

    77     TVerdict result = EPass;

    78     const TInt KSrtSubtitleRegionYFactor = 33;

    79     TRect inputRegion;

    80     inputRegion.iTl.iX = 1;

    81     inputRegion.iTl.iY = 1;

    82     inputRegion.iBr.iX = 240;

    83     inputRegion.iBr.iY = 160;

    84     TInt deltaValue = 24;

    85     

    86     TRect outputRegion;

    87     TRect expectedRegion;

    88     

    89     while((inputRegion.iBr.iX > inputRegion.iTl.iX) && (inputRegion.iBr.iY > inputRegion.iTl.iY))

    90         {

    91         TInt error = iSrtDecoder->CalculateSubtitleRegion(inputRegion, outputRegion);

    92         if (KErrNone != error)

    93             {

    94             return EFail;

    95             }

    96     

    97         expectedRegion.SetRect(

    98             inputRegion.iTl.iX, 

    99             inputRegion.iTl.iY + inputRegion.Height() * (100 - KSrtSubtitleRegionYFactor) / 100,

   100             inputRegion.iBr.iX,

   101             inputRegion.iBr.iY);

   102         

   103         if (expectedRegion != outputRegion)

   104             {

   105             ERR_PRINTF5(_L("Error - MSubtitleDecoder::CalculateSubtitleRegion failed to handle rect(%d, %d, %d, %d). "), 

   106                 inputRegion.iTl.iX, inputRegion.iTl.iY, inputRegion.iBr.iX, inputRegion.iBr.iY);

   107             return EFail;

   108             }

   109         

   110         inputRegion.iTl.iX += deltaValue;

   111         inputRegion.iTl.iY += deltaValue;

   112         inputRegion.iBr.iX -= deltaValue;

   113         inputRegion.iBr.iY -= deltaValue;

   114         }

   115     

   116     return result;

   117     }

   118 

   119 TVerdict RTestSrtDecoderStep0001::TestSetVideoPosition()

   120     {

   121     TVerdict result = EPass;

   122     

   123     TInt64 val = 0;

   124     

   125     for (TInt i = 0; i < 20; i++)

   126         {

   127         val += 10000000;

   128         iSrtDecoder->SetVideoPosition(val);

   129         }

   130      

   131     return result;

   132     }

   133     

   134 TVerdict RTestSrtDecoderStep0001::TestStartStop()

   135     {

   136     TVerdict result = EPass;

   137     

   138     for (TInt i = 0; i < 10; i++)

   139         {

   140         iSrtDecoder->Start();

   141         iSrtDecoder->Stop();

   142         }

   143     

   144     return result;

   145     }

   146     

   147 // Implementation of RTestSrtDecoderStep0102

   148 	

   149 RTestSrtDecoderStep0102::RTestSrtDecoderStep0102()

   150 	{

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

   152 	}

   153 

   154 TVerdict RTestSrtDecoderStep0102::DoTestStepPreambleL()

   155     {

   156     InitializeTestStepL(EFalse, KSampleSubtitleSRTFilepath1);

   157     

   158     return EPass;

   159     }

   160 	

   161 TVerdict RTestSrtDecoderStep0102::DoTestStepPostambleL()

   162     {

   163     UnInitializeTestStep();

   164     

   165     return EPass;

   166     }

   167     

   168 TVerdict RTestSrtDecoderStep0102::DoTestStepL()

   169 	{

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

   171 	TVerdict result = EPass;

   172 	

   173     result = TestCalculateSubtitleRegion();

   174     if (EPass != result)

   175         {

   176         ERR_PRINTF1(_L("Error - RTestSrtDecoderStep0102::TestCalculateSubtitleRegion failed. "));

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

   178 	    return result;

   179         }

   180         

   181     result = TestStartStop();

   182     if (EPass != result)

   183         {

   184         ERR_PRINTF1(_L("Error - RTestSrtDecoderStep0102::TestStartStop failed. "));

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

   186 	    return result;

   187         }

   188      

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

   190 	return result;

   191 	}

   192 

   193 TVerdict RTestSrtDecoderStep0102::TestCalculateSubtitleRegion()

   194     {

   195     TInt error = KErrNone;

   196     TInt expectedErr = KErrArgument;

   197     TRect inputRegion;

   198     TRect outputRegion;

   199     const TInt KTestSubtitleRegionValueNum = 4;

   200     const TInt KTestSubtitleInvalidRegionTypeNum = 5;

   201     const TInt KTestSubtitleRegionValues[KTestSubtitleRegionValueNum] = {10, 20, 20, 200};

   202     TInt testSubtitleRegionFactors[KTestSubtitleRegionValueNum] = {0, 0, 0, 0};

   203     const TInt KTestSubtitleRegionFactorIndex[KTestSubtitleInvalidRegionTypeNum][KTestSubtitleRegionValueNum] = 

   204         {

   205             // test inverted rect

   206             {2, 3, 0, 1},

   207             // test inverted rect

   208             {2, 3, 1, 0},

   209             // test a vertical line

   210             {1, 0, 2, 3},

   211             // test a horizontal line

   212             {0, 1, 3, 2},

   213             // test a point 

   214             {0, 0, 0, 0}

   215         };

   216     TInt i = 0;

   217     

   218     // test 0 values

   219     for (i = 0; i < KTestSubtitleRegionValueNum; i++)

   220         {

   221         inputRegion.SetRect(

   222             KTestSubtitleRegionValues[0] * testSubtitleRegionFactors[0], 

   223             KTestSubtitleRegionValues[1] * testSubtitleRegionFactors[1], 

   224             KTestSubtitleRegionValues[2] * testSubtitleRegionFactors[2], 

   225             KTestSubtitleRegionValues[3] * testSubtitleRegionFactors[3]);

   226         error = iSrtDecoder->CalculateSubtitleRegion(inputRegion, outputRegion);

   227         

   228         if (expectedErr != error)

   229             {

   230             ERR_PRINTF5(_L("Error - MSubtitleDecoder::CalculateSubtitleRegion failed to handle invalid rect(%d, %d, %d, %d). "), 

   231                 inputRegion.iTl.iX, inputRegion.iTl.iY, inputRegion.iBr.iX, inputRegion.iBr.iY);

   232             return EFail;

   233             }

   234             

   235         // initialize factors

   236         testSubtitleRegionFactors[i] = 1;

   237         }

   238         

   239     // test minus values

   240     for (i = 0; i < KTestSubtitleRegionValueNum; i++)

   241         {

   242         // in each loop, the factors will have different number of minus value.

   243         testSubtitleRegionFactors[i] = -1;

   244         inputRegion.SetRect(

   245             KTestSubtitleRegionValues[0] * testSubtitleRegionFactors[0], 

   246             KTestSubtitleRegionValues[1] * testSubtitleRegionFactors[1], 

   247             KTestSubtitleRegionValues[2] * testSubtitleRegionFactors[2], 

   248             KTestSubtitleRegionValues[3] * testSubtitleRegionFactors[3]);

   249         error = iSrtDecoder->CalculateSubtitleRegion(inputRegion, outputRegion);

   250         

   251         if (expectedErr != error)

   252             {

   253             ERR_PRINTF5(_L("Error - MSubtitleDecoder::CalculateSubtitleRegion failed to handle invalid rect(%d, %d, %d, %d). "), 

   254                 inputRegion.iTl.iX, inputRegion.iTl.iY, inputRegion.iBr.iX, inputRegion.iBr.iY);

   255             return EFail;

   256             }

   257         }

   258     

   259     // Test various invalid rectangles

   260     for (i = 0; i < KTestSubtitleInvalidRegionTypeNum; i++)

   261         {

   262         inputRegion.SetRect(

   263             KTestSubtitleRegionValues[KTestSubtitleRegionFactorIndex[i][0]], 

   264             KTestSubtitleRegionValues[KTestSubtitleRegionFactorIndex[i][1]], 

   265             KTestSubtitleRegionValues[KTestSubtitleRegionFactorIndex[i][2]], 

   266             KTestSubtitleRegionValues[KTestSubtitleRegionFactorIndex[i][3]]);

   267         error = iSrtDecoder->CalculateSubtitleRegion(inputRegion, outputRegion);

   268         if (expectedErr != error)

   269             {

   270             ERR_PRINTF5(_L("Error - MSubtitleDecoder::CalculateSubtitleRegion failed to handle invalid rect(%d, %d, %d, %d). "), 

   271                 inputRegion.iTl.iX, inputRegion.iTl.iY, inputRegion.iBr.iX, inputRegion.iBr.iY);

   272             return EFail;

   273             }

   274         }

   275         

   276     return EPass;

   277     }

   278     

   279 TVerdict RTestSrtDecoderStep0102::TestStartStop()

   280     {

   281     TVerdict result = EPass;

   282     

   283     // Do not call Start before Stop because it will panic

   284     // Call Stop() multiple times with and without calling Start() first

   285     for (TInt i = 0; i < 10; i++)

   286         {

   287         if ((0 == i) || (i % 4))

   288             {

   289             iSrtDecoder->Stop();

   290             }

   291         else

   292             {

   293             iSrtDecoder->Start();

   294             }

   295         }

   296         

   297     return result;

   298     }

   299 

   300 

   301 

   302 // Implementation of RTestSrtDecoderStep0104

   303 	

   304 RTestSrtDecoderStep0104::RTestSrtDecoderStep0104()

   305 	{

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

   307 	}

   308 

   309 TVerdict RTestSrtDecoderStep0104::DoTestStepL()

   310 	{

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

   312 	TVerdict result = EPass;

   313 	

   314 	iSrtReader = CSrtReader::NewL(KSampleSubtitleSRTFilepath1);

   315     

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

   317     CleanupStack::PushL(&iRbsSession);

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

   319 	

   320     iSrtDecoder->SetVideoPosition(-100);

   321      

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

   323 	return result;

   324 	}

   325 

   326 

   327 

   328 

   329 

   330 

   331 

   332
Symaptic