Symaptic: os/mm/mmplugins/lib3gpunittest/src/tsu_3gplibrary_parse_and

     1 // Copyright (c) 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 "tsu_3gplibrary_parse_and_check.h"

    18 _LIT( KAvcBaseline, "Baseline" );

    19 _LIT( KAvcMain, "Main" );

    20 _LIT( KAvcExtended, "Extended" );

    21 _LIT( KAvcHigh, "High" );

    23 const static TDesC* KAvcProfileNames[] = {

    24         &KAvcBaseline,

    25         &KAvcMain,

    26         &KAvcExtended,

    27         &KAvcHigh

    28     };

    30 const TUint16 KAudioModeSet = 0x81ff;

    32 C3GPLibParseAndCheckTypes::C3GPLibParseAndCheckTypes()

    33     {

    34     }

    36 TVerdict C3GPLibParseAndCheckTypes::doTestStepPreambleL()

    37     {

    38     // ensure test always starts with clean results

    39     SetTestStepResult(EPass);

    40     SetTestStepError(KErrNone);

    42     #ifdef __WINSCW__

    43     _LIT(KTestFileName, "filepath");

    44     #else

    45     _LIT(KTestFileName, "filepathHw");

    46     #endif

    48     TPtrC inputFilePath;

    49     if (!GetStringFromConfig(ConfigSection(), KTestFileName, inputFilePath))

    50         {

    51         ERR_PRINTF1(_L("Error to read data from ini file."));

    52         SetTestStepResult(ETestSuiteError);

    53         return TestStepResult();

    54         }

    56     if (inputFilePath.Length() == 0)

    57         {

    58         ERR_PRINTF1(_L("Error to read input file path from ini file."));

    59         SetTestStepResult(ETestSuiteError);

    60         return TestStepResult();

    61         }

    63     TInt temp;

    64     if (!GetIntFromConfig(ConfigSection(), _L("audioType"), temp))

    65         {

    66         ERR_PRINTF1(_L("expected audio type not specified"));

    67         SetTestStepResult(ETestSuiteError);

    68         return TestStepResult();

    69         }

    70     else

    71         {

    72         iExpectedAudioType = (T3GPAudioType)temp;

    73         }

    75     if (!GetIntFromConfig(ConfigSection(), _L("videoType"), temp))

    76         {

    77         ERR_PRINTF1(_L("expected video type not specified"));

    78         SetTestStepResult(ETestSuiteError);

    79         return TestStepResult();

    80         }

    81     else

    82         {

    83         iExpectedVideoType = (T3GPVideoType)temp;

    84         }

    87     iInputFilePath.CreateL(inputFilePath);

    89     iParser = C3GPParse::NewL();

    91     return TestStepResult();

    92     }

    94 TVerdict C3GPLibParseAndCheckTypes::doTestStepL()

    95     {

    96     // ensure test always starts with clean results

    97     SetTestStepResult(EPass);

    98     SetTestStepError(KErrNone);

   100     INFO_PRINTF2(_L("ParseFileL: file=%S"), &iInputFilePath);

   101     TRAPD(err, ParseAndCheckFileL(iInputFilePath));

   102     INFO_PRINTF2(_L("ParseFileL returns: err = %d"), err);

   103     if( err != KErrNone )

   104         {

   105         SetTestStepError( err );

   106         SetTestStepResult( EFail );

   107         iParser->Complete();

   108         }

   112     return TestStepResult();

   113     }

   115 TVerdict C3GPLibParseAndCheckTypes::doTestStepPostambleL()

   116     {

   117     iInputFilePath.Close();

   119     delete iParser;

   121     return TestStepResult();

   122     }

   124 void C3GPLibParseAndCheckTypes::ParseAndCheckFileL(const TDesC& aInputFile)

   125     {

   126     INFO_PRINTF1(_L("C3GPLibParseFileMainHigh::ParseFileL START"));

   127     ASSERT(iParser);

   128     TInt err = 0;

   130     err = iParser->Open(aInputFile);

   132     if (err != KErrNone)

   133         {

   134         ERR_PRINTF2(_L("C3GPParse::Open() returns %d"), err);

   135         User::Leave(err);

   136         }

   138     //

   139     // Retrieve Video Properties

   140     //

   141     T3GPVideoPropertiesBase* videoProperties = NULL;

   142     CleanupStack::PushL(videoProperties);

   144     RBuf8 videoDecoderSpecificInfo;

   145     CleanupClosePushL(videoDecoderSpecificInfo);

   147     TUint videoLengthInMs = 0;

   149     err = ParseVideoProperties(*iParser, videoDecoderSpecificInfo, videoProperties, videoLengthInMs);

   150     if ( err != KErrNone )

   151         {

   152         ERR_PRINTF2(_L("ParseVideoProperties failed: err = %d"), err);

   153         User::Leave(err);

   154         }

   156     //

   157     // Retrieve Audio Properties

   158     //

   159     T3GPAudioPropertiesBase* audioProperties = NULL;

   160     CleanupStack::PushL(audioProperties);

   162     RBuf8 audioDecoderSpecificInfo;

   163     CleanupClosePushL(audioDecoderSpecificInfo);

   165     TUint audioLengthInMs = 0;

   166     err = ParseAudioProperties(*iParser, audioDecoderSpecificInfo, audioProperties, audioLengthInMs);

   167     if( err != KErrNone )

   168         {

   169         ERR_PRINTF2(_L("ParseAudioProperties failed: err = %d"), err);

   170         User::Leave(err);

   171         }

   173     if (!videoProperties && !audioProperties)

   174         {

   175         ERR_PRINTF1(_L("File contains neither video nor audio data"));

   176         User::Leave(KErrNotFound);

   177         }

   179     //

   180     // Check that types were as expected

   181     //

   182     if( audioProperties->iType != iExpectedAudioType )

   183         {

   184         INFO_PRINTF3(_L("Audio type check failed (expected %d, got %d)"), iExpectedAudioType, audioProperties->iType );

   185         SetTestStepResult( EFail );

   186         }

   188     if( videoProperties->iType != iExpectedVideoType )

   189         {

   190         INFO_PRINTF3(_L("Video type check failed (expected %d, got %d)"), iExpectedVideoType, videoProperties->iType );

   191         SetTestStepResult( EFail );

   192         }

   195     //

   196     // Clean up

   197     //

   198     CleanupStack::PopAndDestroy(4);

   199                                     // audioDecoderSpecificInfo

   200                                     // audioProperties

   201                                     // videoDecoderSpecificInfo

   202                                     // videoProperties

   204     err = iParser->Complete();

   205     if (err != KErrNone)

   206         {

   207         ERR_PRINTF1(_L("aParser->Complete() failed"));

   208         User::Leave(err);

   209         }

   211     INFO_PRINTF1(_L("C3GPLibParseFileMainHigh::ParseFileL END"));

   212     }

   214 TInt C3GPLibParseAndCheckTypes::ParseVideoProperties(C3GPParse& aParser,

   215                               RBuf8& aDecoderSpecificInfo,

   216                               T3GPVideoPropertiesBase*& aProperties,

   217                               TUint& aLengthInMs)

   218     {

   219     ASSERT(iParser);

   221     T3GPVideoType type;

   222     TReal frameRate;

   223     TUint avgBitRate;

   224     TSize size;

   225     TUint timeScale;

   227     TInt err = aParser.GetVideoProperties(type, aLengthInMs, frameRate, avgBitRate, size, timeScale);

   228     if ( err != KErrNone )

   229         {

   230         ERR_PRINTF2(_L("aParser->GetVideoProperties failed: %d"), err);

   231         return err;

   232         }

   234     switch(type)

   235         {

   236         case E3GPMpeg4Video:

   237             {

   238             INFO_PRINTF1(_L("Video Type: Mpeg4"));

   239             err = GetVideoDecoderSpecificInfo(aDecoderSpecificInfo);

   240             if (err == KErrNone)

   241                 {

   242                 aProperties = new T3GPVideoPropertiesMpeg4Video(timeScale, size,

   243                         64000, avgBitRate, aDecoderSpecificInfo);

   244                 if (!aProperties)

   245                     {

   246                     ERR_PRINTF1(_L("T3GPVideoPropertiesMpeg4Video allocation failed"));

   247                     err = KErrNoMemory;

   248                     }

   249                 }

   250             break;

   251             }

   253         case E3GPH263Profile0:

   254         case E3GPH263Profile3:

   255             {

   256             INFO_PRINTF1(_L("Video Type: H263"));

   257             T3GPVideoPropertiesH263::TProfile profile = T3GPVideoPropertiesH263::EProfile0;

   258             if (type == E3GPH263Profile3)

   259                 {

   260                 profile = T3GPVideoPropertiesH263::EProfile3;

   261                 }

   263             TInt videoLevel;

   264             err = iParser->GetH263VideoLevel(videoLevel);

   265             if( err != KErrNone )

   266                 {

   267                 ERR_PRINTF1(_L("aParser->GetH263VideoLevel() failed"));

   268                 }

   269             else

   270                 {

   271                 aProperties = new T3GPVideoPropertiesH263(timeScale, size, videoLevel, profile);

   272                 if( !aProperties )

   273                     {

   274                     ERR_PRINTF1(_L("T3GPVideoPropertiesH263 allocation failed"));

   275                     err = KErrNoMemory;

   276                     }

   277                 }

   278             break;

   279             }

   282         case E3GPAvcProfileBaseline:

   283         case E3GPAvcProfileMain:

   284         case E3GPAvcProfileExtended:

   285         case E3GPAvcProfileHigh:

   286             {

   287             err = GetVideoDecoderSpecificInfo(aDecoderSpecificInfo);

   288             if (err == KErrNone)

   289                 {

   290                 INFO_PRINTF2(_L("Video Type: Avc Profile %S"), KAvcProfileNames[type-E3GPAvcProfileBaseline] );

   291                 aProperties = new T3GPVideoPropertiesAvc(timeScale, size, aDecoderSpecificInfo);

   292                 if (!aProperties)

   293                     {

   294                     ERR_PRINTF1(_L("T3GPVideoPropertiesAvc allocation failed"));

   295                     err = KErrNoMemory;

   296                     }

   297                 else

   298                     {

   299                     // T3GPVideoPropertiesAvc defaults the video type to AVC baseline profile.

   300                     // Need to override that here because we want to check for the specific

   301                     // profile in this test.

   302                     aProperties->iType = type;

   303                     }

   304                 }

   305             break;

   306             }

   308         case E3GPNoVideo:

   309             INFO_PRINTF1(_L("Video Type: None"));

   310             break;

   312         default:

   313             err = KErrNotSupported;

   314             break;

   315         }

   317     if( err == KErrNone )

   318         {

   319         INFO_PRINTF1(_L("**********"));

   320         INFO_PRINTF2(_L("Length In Miliseconds = %d"), aLengthInMs);

   321         INFO_PRINTF2(_L("Frame Rate = %f"), frameRate);

   322         INFO_PRINTF2(_L("Average Bit Rate = %d"), avgBitRate);

   323         INFO_PRINTF2(_L("Frame Width = %d"), size.iWidth);

   324         INFO_PRINTF2(_L("Frame Height = %d"), size.iHeight);

   325         INFO_PRINTF2(_L("Time Scale = %d"), timeScale);

   326         INFO_PRINTF1(_L("**********"));

   327         }

   328     return err;

   329     }

   331 TInt C3GPLibParseAndCheckTypes::ParseAudioProperties(C3GPParse& aParser,

   332                                                    RBuf8& aAudioDecoderSpecificInfo,

   333                                                    T3GPAudioPropertiesBase*& aAudioProperties,

   334                                                    TUint& aLength)

   335     {

   336     ASSERT(iParser);

   338     T3GPAudioType type;

   339     TInt audioFPS;

   340     TUint audioAvgBitRate;

   341     TUint timeScale;

   343     TInt err = aParser.GetAudioProperties(type, aLength, audioFPS, audioAvgBitRate, timeScale);

   344     if( err != KErrNone )

   345         {

   346         ERR_PRINTF2(_L("GetAudioProperties() failed: %d"), err);

   347         return err;

   348         }

   350     switch(type)

   351         {

   352         case E3GPMpeg4Audio:

   353             {

   354             INFO_PRINTF1(_L("Audio Type: Mpeg4"));

   355             err = GetAudioDecoderSpecificInfo(aAudioDecoderSpecificInfo);

   356             if (err == KErrNone)

   357                 {

   358                 aAudioProperties = new T3GPAudioPropertiesMpeg4Audio(timeScale, aAudioDecoderSpecificInfo);

   359                 if( !aAudioProperties )

   360                     {

   361                     ERR_PRINTF1(_L("T3GPAudioPropertiesMpeg4Audio allocation failed"));

   362                     err = KErrNoMemory;

   363                     }

   364                 }

   365             break;

   366             }

   368         case E3GPQcelp13K:

   369             {

   370             INFO_PRINTF1(_L("Audio Type: Qcelp13K"));

   371             T3GPQcelpStorageMode mode;

   372             err = iParser->GetQcelpStorageMode(mode);

   373             if (err != KErrNone)

   374                 {

   375                 ERR_PRINTF1(_L("GetQcelpStorageMode failed"));

   376                 }

   377             else

   378                 {

   379                 if( mode == E3GPMP4AudioDescriptionBox)

   380                     {

   381                     err = GetAudioDecoderSpecificInfo(aAudioDecoderSpecificInfo);

   382                     aAudioProperties = new T3GPAudioPropertiesQcelp(timeScale, audioFPS, aAudioDecoderSpecificInfo);

   383                     }

   384                 else

   385                     {

   386                     aAudioProperties = new T3GPAudioPropertiesQcelp(timeScale, audioFPS);

   387                     }

   389                 if( !aAudioProperties )

   390                     {

   391                     ERR_PRINTF1(_L("T3GPAudioPropertiesQcelp allocation failed"));

   392                     err = KErrNoMemory;

   393                     }

   394                 }

   395             break;

   396             }

   398         case E3GPAmrNB:

   399             {

   400             INFO_PRINTF1(_L("Audio Type: AMR NB"));

   401             aAudioProperties = new T3GPAudioPropertiesAmr(timeScale, audioFPS, KAudioModeSet, T3GPAudioPropertiesAmr::EAmrNB);

   402             if( !aAudioProperties )

   403                 {

   404                 ERR_PRINTF1(_L("T3GPAudioPropertiesAmr allocation failed"));

   405                 err = KErrNoMemory;

   406                 }

   407             break;

   408             }

   410         case E3GPAmrWB:

   411             {

   412             INFO_PRINTF1(_L("Audio Type: AMR WB"));

   413             aAudioProperties = new T3GPAudioPropertiesAmr(timeScale, audioFPS, KAudioModeSet, T3GPAudioPropertiesAmr::EAmrWB);

   414             if( !aAudioProperties )

   415                 {

   416                 ERR_PRINTF1(_L("T3GPAudioPropertiesAmr allocation failed"));

   417                 err = KErrNoMemory;

   418                 }

   419             break;

   420             }

   422         case E3GPNoAudio:

   423             INFO_PRINTF1(_L("Audio Type: None"));

   424             break;

   426         default:

   427             INFO_PRINTF1(_L("Audio Type: Unrecognized!"));

   428             err = KErrNotSupported;

   429             break;

   430         }

   432     return err;

   433     }

   435 TInt C3GPLibParseAndCheckTypes::GetAudioDecoderSpecificInfo(RBuf8& aBuffer)

   436     {

   437     ASSERT(iParser);

   439     TInt size;

   440     TInt err = iParser->GetAudioDecoderSpecificInfoSize(size);

   441     if( err != KErrNone )

   442         {

   443         ERR_PRINTF2(_L("GetAudioDecoderSpecificInfoSize() failed: %d"), err);

   444         return err;

   445         }

   447     err = aBuffer.Create(size);

   448     if( err != KErrNone )

   449         {

   450         ERR_PRINTF1(_L("Create buffer failed"));

   451         return err;

   452         }

   454     err = iParser->GetAudioDecoderSpecificInfo(aBuffer);

   455     if( err != KErrNone )

   456         {

   457         ERR_PRINTF2(_L("GetAudioDecoderSpecificInfo() failed: %d"), err);

   458         }

   460     return err;

   461     }

   463 TInt C3GPLibParseAndCheckTypes::GetVideoDecoderSpecificInfo(RBuf8& aBuffer)

   464     {

   465     TInt size;

   466     TInt err = iParser->GetVideoDecoderSpecificInfoSize(size);

   467     if (err != KErrNone)

   468         {

   469         ERR_PRINTF1(_L("GetVideoDecoderSpecificInfoSize() failed"));

   470         return err;

   471         }

   473     err = aBuffer.Create(size);

   474     if (err != KErrNone)

   475         {

   476         ERR_PRINTF1(_L("Create buffer failed"));

   477         return err;

   478         }

   480     err = iParser->GetVideoDecoderSpecificInfo(aBuffer);

   481     if( err != KErrNone )

   482         {

   483         ERR_PRINTF1(_L("GetVideoDecoderSpecificInfo() failed"));

   484         }

   486     return err;

   487     }

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