Home | History | Annotate | Download | only in src 
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 #include "test_engine.h"
     19 
     20 #include "alloc_dealloc_test.h"
     21 #include "init_test.h"
     22 #include "init_cancel_test.h"
     23 #ifndef NO_2WAY_324
     24 #include "video_only_test.h"
     25 #include "av_test.h"
     26 #include "user_input_test.h"
     27 #include "connect_test.h"
     28 #include "connect_cancel_test.h"
     29 #include "audio_only_test.h"
     30 #include "av_duplicate_test.h"
     31 #include "pvmf_fileoutput_factory.h"
     32 #endif
     33 
     34 #include "oscl_string_utils.h"
     35 #include "oscl_mem_audit.h"
     36 
     37 
     38 #include "tsc_h324m_config_interface.h"
     39 
     40 #define AUDIO_FIRST 0
     41 #define VIDEO_FIRST 1
     42 
     43 #define MAX_SIP_TEST 27
     44 #define MAX_324_TEST 25
     45 #define SIP_TEST_OFFSET 200
     46 #define SIP_TEST_MAP(x) (x+SIP_TEST_OFFSET)
     47 #define NUM_SIP_ARGS 10
     48 
     49 
     50 int start_test();
     51 
     52 FILE* fileoutput;
     53 cmd_line *global_cmd_line;
     54 
     55 //Find test range args:
     56 //To run a range of tests by enum ID:
     57 //  -test 17 29
     58 
     59 char engine_test::iProfileName[32] = "";
     60 uint32 engine_test::iMediaPorts[2] = { 0, 0 };
     61 char engine_test::iPeerAddress[64] = "";
     62 
     63 
     64 void FindTestRange(cmd_line* command_line,
     65                    int32& iFirstTest,
     66                    int32 &iLastTest,
     67                    FILE* aFile)
     68 {
     69     //default is to run all tests.
     70     iFirstTest = 0;
     71     iLastTest = MAX_324_TEST;
     72 
     73     int iTestArgument = 0;
     74     char *iTestArgStr1 = NULL;
     75     char *iTestArgStr2 = NULL;
     76     bool cmdline_iswchar = command_line->is_wchar();
     77 
     78     int count = command_line->get_count();
     79 
     80     // Search for the "-test" argument
     81     char *iSourceFind = NULL;
     82     if (cmdline_iswchar)
     83     {
     84         iSourceFind = new char[256];
     85     }
     86 
     87     int iTestSearch = 0;
     88     while (iTestSearch < count)
     89     {
     90         bool iTestFound = false;
     91         // Go through each argument
     92         for (; iTestSearch < count; iTestSearch++)
     93         {
     94             // Convert to UTF8 if necessary
     95             if (cmdline_iswchar)
     96             {
     97                 OSCL_TCHAR* cmd = NULL;
     98                 command_line->get_arg(iTestSearch, cmd);
     99                 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
    100             }
    101             else
    102             {
    103                 iSourceFind = NULL;
    104                 command_line->get_arg(iTestSearch, iSourceFind);
    105             }
    106 
    107             // Do the string compare
    108             if (oscl_strcmp(iSourceFind, "-help") == 0)
    109             {
    110                 fprintf(aFile, "Test cases to run option. Default is ALL:\n");
    111                 fprintf(aFile, "  -test x y\n");
    112                 fprintf(aFile, "   Specify a range of test cases to run. To run one test case, use the\n");
    113                 fprintf(aFile, "   same index for x and y.\n");
    114 
    115                 fprintf(aFile, "  -test G\n");
    116                 fprintf(aFile, "   Run 324M test cases only.\n");
    117 
    118                 exit(0);
    119             }
    120             else if (oscl_strcmp(iSourceFind, "-test") == 0)
    121             {
    122                 iTestFound = true;
    123                 iTestArgument = ++iTestSearch;
    124                 break;
    125             }
    126         }
    127 
    128         if (cmdline_iswchar)
    129         {
    130             delete[] iSourceFind;
    131             iSourceFind = NULL;
    132         }
    133 
    134         if (iTestFound)
    135         {
    136             // Convert to UTF8 if necessary
    137             if (cmdline_iswchar)
    138             {
    139                 iTestArgStr1 = new char[256];
    140                 OSCL_TCHAR* cmd;
    141                 command_line->get_arg(iTestArgument, cmd);
    142                 if (cmd)
    143                 {
    144                     oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iTestArgStr1, 256);
    145                 }
    146 
    147                 iTestArgStr2 = new char[256];
    148                 command_line->get_arg(iTestArgument + 1, cmd);
    149                 if (cmd)
    150                 {
    151                     oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iTestArgStr2, 256);
    152                 }
    153             }
    154             else
    155             {
    156                 command_line->get_arg(iTestArgument, iTestArgStr1);
    157                 command_line->get_arg(iTestArgument + 1, iTestArgStr2);
    158             }
    159 
    160             //Pull out 2 integers...
    161             if (iTestArgStr1
    162                     && '0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9'
    163                     && iTestArgStr2
    164                     && '0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
    165             {
    166                 int len = oscl_strlen(iTestArgStr1);
    167                 switch (len)
    168                 {
    169                     case 3:
    170                         iFirstTest = 0;
    171                         if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
    172                         {
    173                             iFirstTest = iFirstTest + 100 * (iTestArgStr1[0] - '0');
    174                         }
    175 
    176                         if ('0' <= iTestArgStr1[1] && iTestArgStr1[1] <= '9')
    177                         {
    178                             iFirstTest = iFirstTest + 10 * (iTestArgStr1[1] - '0');
    179                         }
    180 
    181                         if ('0' <= iTestArgStr1[2] && iTestArgStr1[2] <= '9')
    182                         {
    183                             iFirstTest = iFirstTest + 1 * (iTestArgStr1[2] - '0');
    184                         }
    185                         break;
    186 
    187                     case 2:
    188                         iFirstTest = 0;
    189                         if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
    190                         {
    191                             iFirstTest = iFirstTest + 10 * (iTestArgStr1[0] - '0');
    192                         }
    193 
    194                         if ('0' <= iTestArgStr1[1] && iTestArgStr1[1] <= '9')
    195                         {
    196                             iFirstTest = iFirstTest + 1 * (iTestArgStr1[1] - '0');
    197                         }
    198                         break;
    199 
    200                     case 1:
    201                         iFirstTest = 0;
    202                         if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
    203                         {
    204                             iFirstTest = iFirstTest + 1 * (iTestArgStr1[0] - '0');
    205                         }
    206                         break;
    207 
    208                     default:
    209                         break;
    210                 }
    211 
    212                 len = oscl_strlen(iTestArgStr2);
    213                 switch (len)
    214                 {
    215                     case 3:
    216                         iLastTest = 0;
    217                         if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
    218                         {
    219                             iLastTest = iLastTest + 100 * (iTestArgStr2[0] - '0');
    220                         }
    221 
    222                         if ('0' <= iTestArgStr2[1] && iTestArgStr2[1] <= '9')
    223                         {
    224                             iLastTest = iLastTest + 10 * (iTestArgStr2[1] - '0');
    225                         }
    226 
    227                         if ('0' <= iTestArgStr2[2] && iTestArgStr2[2] <= '9')
    228                         {
    229                             iLastTest = iLastTest + 1 * (iTestArgStr2[2] - '0');
    230                         }
    231                         break;
    232 
    233                     case 2:
    234                         iLastTest = 0;
    235                         if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
    236                         {
    237                             iLastTest = iLastTest + 10 * (iTestArgStr2[0] - '0');
    238                         }
    239 
    240                         if ('0' <= iTestArgStr2[1] && iTestArgStr2[1] <= '9')
    241                         {
    242                             iLastTest = iLastTest + 1 * (iTestArgStr2[1] - '0');
    243                         }
    244                         break;
    245 
    246                     case 1:
    247                         iLastTest = 0;
    248                         if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
    249                         {
    250                             iLastTest = iLastTest + 1 * (iTestArgStr2[0] - '0');
    251                         }
    252                         break;
    253 
    254                     default:
    255                         break;
    256                 }
    257             }
    258 
    259 #ifndef NO_2WAY_324
    260             else if (iTestArgStr1
    261                      && iTestArgStr1[0] == 'G')
    262             {
    263                 //download tests
    264                 iFirstTest = 0;
    265                 iLastTest = MAX_324_TEST;
    266             }
    267 #endif
    268         }
    269 
    270         if (cmdline_iswchar)
    271         {
    272             if (iTestArgStr1)
    273             {
    274                 delete[] iTestArgStr1;
    275                 iTestArgStr1 = NULL;
    276             }
    277 
    278             if (iTestArgStr2)
    279             {
    280                 delete[] iTestArgStr2;
    281                 iTestArgStr2 = NULL;
    282             }
    283 
    284             if (iSourceFind)
    285             {
    286                 delete[] iSourceFind;
    287                 iSourceFind = NULL;
    288             }
    289         }
    290         iTestSearch += 2;
    291     }
    292 }
    293 
    294 
    295 engine_test_suite::engine_test_suite() : test_case()
    296 {
    297     // setting iProxy
    298     //proxy_tests(false);
    299 
    300     proxy_tests(true);
    301 }
    302 
    303 
    304 void engine_test_suite::proxy_tests(const bool aProxy)
    305 {
    306     //Basic 2way tests
    307     fprintf(fileoutput, "Basic engine tests.\n");
    308 
    309     int32 firstTest = 0;
    310     int32 lastTest = MAX_324_TEST;
    311     FindTestRange(global_cmd_line, firstTest, lastTest, fileoutput);
    312 #ifndef NO_2WAY_324
    313     if (firstTest == 0)
    314         adopt_test_case(new alloc_dealloc_test(aProxy));
    315     if (firstTest <= 2 && lastTest >= 2)
    316         adopt_test_case(new init_test(aProxy, 1));
    317     if (firstTest <= 3 && lastTest >= 3)
    318         adopt_test_case(new init_test(aProxy, 2));
    319 
    320     if (firstTest <= 4 && lastTest >= 4)
    321         adopt_test_case(new init_cancel_test(aProxy));
    322 
    323     if (firstTest <= 5 && lastTest >= 5)
    324         adopt_test_case(new connect_test(aProxy, 1));
    325 
    326     if (firstTest <= 6 && lastTest >= 6)
    327         adopt_test_case(new connect_cancel_test(aProxy));
    328 
    329     if (firstTest <= 7 && lastTest >= 7)
    330     {
    331         adopt_test_case(new audio_only_test(aProxy, PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2));
    332     }
    333     if (firstTest <= 8 && lastTest >= 8)
    334     {
    335         adopt_test_case(new audio_only_test(aProxy, PVMF_MIME_PCM16, PVMF_MIME_AMR_IF2));
    336     }
    337     if (firstTest <= 9 && lastTest >= 9)
    338     {
    339         adopt_test_case(new audio_only_test(aProxy, PVMF_MIME_AMR_IF2, PVMF_MIME_PCM16));
    340     }
    341 
    342     if (firstTest <= 10 && lastTest >= 10)
    343     {
    344         adopt_test_case(new audio_only_test(aProxy, PVMF_MIME_PCM16, PVMF_MIME_PCM16));
    345     }
    346 
    347     if (firstTest <= 11 && lastTest >= 11)
    348     {
    349         adopt_test_case(new video_only_test(PVMF_MIME_YUV420, PVMF_MIME_YUV420, aProxy));
    350     }
    351     if (firstTest <= 12 && lastTest >= 12)
    352     {
    353         adopt_test_case(new video_only_test(PVMF_MIME_YUV420, PVMF_MIME_H2632000, aProxy));
    354     }
    355     if (firstTest <= 13 && lastTest >= 13)
    356     {
    357         adopt_test_case(new video_only_test(PVMF_MIME_H2632000, PVMF_MIME_YUV420, aProxy));
    358     }
    359     if (firstTest <= 14 && lastTest >= 14)
    360     {
    361         adopt_test_case(new video_only_test(PVMF_MIME_M4V, PVMF_MIME_YUV420, aProxy));
    362     }
    363     if (firstTest <= 15 && lastTest >= 15)
    364     {
    365         adopt_test_case(new video_only_test(PVMF_MIME_YUV420, PVMF_MIME_M4V, aProxy));
    366     }
    367 
    368     if (firstTest <= 16 && lastTest >= 16)
    369     {
    370         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_YUV420, PVMF_MIME_YUV420, aProxy));
    371     }
    372 
    373     if (firstTest <= 17 && lastTest >= 17)
    374     {
    375         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_PCM16, PVMF_MIME_YUV420, PVMF_MIME_YUV420, aProxy));
    376     }
    377     if (firstTest <= 18 && lastTest >= 18)
    378     {
    379         adopt_test_case(new av_test(PVMF_MIME_PCM16, PVMF_MIME_AMR_IF2, PVMF_MIME_YUV420, PVMF_MIME_YUV420, aProxy));
    380 
    381     }
    382     if (firstTest <= 19 && lastTest >= 19)
    383     {
    384         adopt_test_case(new av_test(PVMF_MIME_PCM16, PVMF_MIME_PCM16, PVMF_MIME_YUV420, PVMF_MIME_YUV420, aProxy));
    385     }
    386 
    387     if (firstTest <= 20 && lastTest >= 20)
    388     {
    389         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_YUV420, PVMF_MIME_H2632000, aProxy));
    390     }
    391     if (firstTest <= 21 && lastTest >= 21)
    392     {
    393         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_H2632000, PVMF_MIME_YUV420, aProxy));
    394     }
    395     if (firstTest <= 22 && lastTest >= 22)
    396     {
    397         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_H2632000, PVMF_MIME_H2632000, aProxy));
    398     }
    399 
    400     if (firstTest <= 23 && lastTest >= 23)
    401     {
    402         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_YUV420, PVMF_MIME_M4V, aProxy));
    403     }
    404     if (firstTest <= 24 && lastTest >= 24)
    405     {
    406         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_M4V, PVMF_MIME_YUV420, aProxy));
    407     }
    408     if (firstTest <= 25 && lastTest >= 25)
    409     {
    410         adopt_test_case(new av_test(PVMF_MIME_AMR_IF2, PVMF_MIME_AMR_IF2, PVMF_MIME_M4V, PVMF_MIME_M4V, aProxy));
    411     }
    412 
    413     if (firstTest <= 26 && lastTest >= 26)
    414     {
    415         adopt_test_case(new connect_test(aProxy, 1, true));
    416     }
    417 
    418 
    419 #endif
    420 
    421 
    422 }
    423 
    424 void engine_test::create_sink_source()
    425 {
    426 #ifndef NO_2WAY_324
    427     iCommSettings.iMediaFormat = PVMF_MIME_H223;
    428     iCommSettings.iTestObserver = NULL;
    429     iCommServerIOControl = PvmiMIOCommLoopbackFactory::Create(iCommSettings);
    430     bool enableBitstreamLogging = true;
    431     iCommServer = PVCommsIONodeFactory::Create(iCommServerIOControl, enableBitstreamLogging);
    432 #endif
    433 
    434     // create the audio source
    435     iAudioSourceFileSettings.iMediaFormat = PVMF_MIME_AMR_IF2;
    436     iAudioSourceFileSettings.iLoopInputFile = true;
    437     iAudioSourceFileSettings.iFileName = AUDIO_SOURCE_FILENAME;
    438     iAudioSourceFileSettings.iSamplingFrequency = 8000;
    439     iAudioSourceFileSettings.iNumChannels = 1;
    440     iAudioSourceIOControl = PvmiMIOFileInputFactory::Create(iAudioSourceFileSettings);
    441     iAudioSource = PvmfMediaInputNodeFactory::Create(iAudioSourceIOControl);
    442 
    443     iAudioSourceRawFileSettings.iMediaFormat = PVMF_MIME_PCM16;
    444     iAudioSourceRawFileSettings.iLoopInputFile = true;
    445     iAudioSourceRawFileSettings.iFileName = AUDIO_SOURCE_RAW_FILENAME;
    446     iAudioSourceRawFileSettings.iSamplingFrequency = 8000;
    447     iAudioSourceRawFileSettings.iNumChannels = 1;
    448     iAudioSourceRawIOControl = PvmiMIOFileInputFactory::Create(iAudioSourceRawFileSettings);
    449     iAudioSourceRaw = PvmfMediaInputNodeFactory::Create(iAudioSourceRawIOControl);
    450 
    451     iAudioSource2FileSettings.iMediaFormat = PVMF_MIME_AMR_IF2;
    452     iAudioSource2FileSettings.iLoopInputFile = true;
    453     iAudioSource2FileSettings.iFileName = AUDIO_SOURCE_FILENAME;
    454     iAudioSource2FileSettings.iSamplingFrequency = 8000;
    455     iAudioSource2FileSettings.iNumChannels = 1;
    456     iAudioSource2IOControl = PvmiMIOFileInputFactory::Create(iAudioSource2FileSettings);
    457     iAudioSource2 = PvmfMediaInputNodeFactory::Create(iAudioSource2IOControl);
    458 
    459     iAudioSource3FileSettings.iMediaFormat = PVMF_MIME_AMR_IETF;
    460     iAudioSource3FileSettings.iLoopInputFile = true;
    461     iAudioSource3FileSettings.iFileName = AUDIO_SOURCE3_FILENAME;
    462     iAudioSource3FileSettings.iSamplingFrequency = 8000;
    463     iAudioSource3FileSettings.iNum20msFramesPerChunk = 1;
    464     iAudioSource3FileSettings.iNumChannels = 1;
    465     iAudioSource3IOControl = PvmiMIOFileInputFactory::Create(iAudioSource3FileSettings);
    466     iAudioSource3 = PvmfMediaInputNodeFactory::Create(iAudioSource3IOControl);
    467 
    468     // create the audio sinks
    469 
    470     iAudioSinkFileName = AUDIO_SINK_FILENAME;
    471     iAudioSinkIOControl = new PVRefFileOutput(iAudioSinkFileName, MEDIATYPE_AUDIO, true);
    472     iAudioSink = PVMediaOutputNodeFactory::CreateMediaOutputNode(iAudioSinkIOControl);
    473 
    474     iAudioSinkRawFileName = AUDIO_SINK_RAW_FILENAME;
    475     iAudioSinkRawIOControl = new PVRefFileOutput(iAudioSinkRawFileName, MEDIATYPE_AUDIO, false);
    476     iAudioSinkRaw = PVMediaOutputNodeFactory::CreateMediaOutputNode(iAudioSinkRawIOControl);
    477 
    478     iAudioSink2FileName = AUDIO_SINK2_FILENAME;
    479     iAudioSink2IOControl = new PVRefFileOutput(iAudioSink2FileName, MEDIATYPE_AUDIO, true);
    480     iAudioSink2 = PVMediaOutputNodeFactory::CreateMediaOutputNode(iAudioSink2IOControl);
    481 
    482     // create the video sources
    483     iVideoSourceYUVFileSettings.iMediaFormat = PVMF_MIME_YUV420;
    484     iVideoSourceYUVFileSettings.iLoopInputFile = true;
    485     iVideoSourceYUVFileSettings.iFileName = VIDEO_SOURCE_YUV_FILENAME;
    486     iVideoSourceYUVFileSettings.iTimescale = 1000;
    487     iVideoSourceYUVFileSettings.iFrameHeight = 144;
    488     iVideoSourceYUVFileSettings.iFrameWidth = 176;
    489     iVideoSourceYUVFileSettings.iFrameRate = 5;
    490     iVideoSourceYUVIOControl = PvmiMIOFileInputFactory::Create(iVideoSourceYUVFileSettings);
    491     iVideoSourceYUV = PvmfMediaInputNodeFactory::Create(iVideoSourceYUVIOControl);
    492 
    493 
    494     iVideoSourceH263FileSettings.iMediaFormat = PVMF_MIME_H2632000;
    495     iVideoSourceH263FileSettings.iLoopInputFile = true;
    496     iVideoSourceH263FileSettings.iFileName = VIDEO_SOURCE_H263_FILENAME;
    497     iVideoSourceH263FileSettings.iTimescale = 1000;
    498     iVideoSourceH263FileSettings.iFrameHeight = 144;
    499     iVideoSourceH263FileSettings.iFrameWidth = 176;
    500     iVideoSourceH263FileSettings.iFrameRate = 5;
    501 
    502 
    503     iVideoSourceH263IOControl = PvmiMIOFileInputFactory::Create(iVideoSourceH263FileSettings);
    504     iVideoSourceH263 = PvmfMediaInputNodeFactory::Create(iVideoSourceH263IOControl);
    505 
    506     // create another video source
    507     iVideoSourceM4VFileSettings.iMediaFormat = PVMF_MIME_M4V;
    508     iVideoSourceM4VFileSettings.iLoopInputFile = true;
    509     iVideoSourceM4VFileSettings.iFileName = VIDEO_SOURCE_M4V_FILENAME;
    510     iVideoSourceM4VFileSettings.iTimescale = 1000;
    511     iVideoSourceM4VFileSettings.iFrameHeight = 144;
    512     iVideoSourceM4VFileSettings.iFrameWidth = 176;
    513     iVideoSourceM4VFileSettings.iFrameRate = 5;
    514 
    515     iVideoSourceM4VIOControl = PvmiMIOFileInputFactory::Create(iVideoSourceM4VFileSettings);
    516     iVideoSourceM4V = PvmfMediaInputNodeFactory::Create(iVideoSourceM4VIOControl);
    517 
    518     // create the video sinks
    519     iVideoSinkYUVFileName = VIDEO_SINK_YUV_FILENAME;
    520     iVideoSinkYUVIOControl = new PVRefFileOutput(iVideoSinkYUVFileName, MEDIATYPE_VIDEO, false);
    521 
    522     iVideoSinkYUV = PVMediaOutputNodeFactory::CreateMediaOutputNode(iVideoSinkYUVIOControl);
    523 
    524     iVideoSinkH263FileName = VIDEO_SINK_H263_FILENAME;
    525     iVideoSinkH263IOControl = new PVRefFileOutput(iVideoSinkH263FileName, MEDIATYPE_VIDEO, true);
    526     iVideoSinkH263 = PVMediaOutputNodeFactory::CreateMediaOutputNode(iVideoSinkH263IOControl);
    527 
    528 
    529     iVideoSinkM4VFileName = VIDEO_SINK_M4V_FILENAME;
    530     iVideoSinkM4VIOControl = new PVRefFileOutput(iVideoSinkM4VFileName, MEDIATYPE_VIDEO, true);
    531     iVideoSinkM4V = PVMediaOutputNodeFactory::CreateMediaOutputNode(iVideoSinkM4VIOControl);
    532 
    533 }
    534 
    535 void engine_test::destroy_sink_source()
    536 {
    537 #ifndef NO_2WAY_324
    538     if (iCommServer)
    539     {
    540         PVCommsIONodeFactory::Delete(iCommServer);
    541         iCommServer = NULL;
    542     }
    543 
    544     if (iCommServerIOControl)
    545     {
    546         PvmiMIOCommLoopbackFactory::Delete(iCommServerIOControl);
    547         iCommServerIOControl = NULL;
    548     }
    549 #endif
    550     if (iAudioSource)
    551     {
    552         PvmfMediaInputNodeFactory::Delete(iAudioSource);
    553         iAudioSource = NULL;
    554     }
    555 
    556     if (iAudioSourceRaw)
    557     {
    558         PvmfMediaInputNodeFactory::Delete(iAudioSourceRaw);
    559         iAudioSourceRaw = NULL;
    560     }
    561 
    562     if (iAudioSource2)
    563     {
    564         PvmfMediaInputNodeFactory::Delete(iAudioSource2);
    565         iAudioSource2 = NULL;
    566     }
    567 
    568     if (iAudioSource3)
    569     {
    570         PvmfMediaInputNodeFactory::Delete(iAudioSource3);
    571         iAudioSource3 = NULL;
    572     }
    573 
    574     if (iAudioSourceIOControl)
    575     {
    576         PvmiMIOFileInputFactory::Delete(iAudioSourceIOControl);
    577         iAudioSourceIOControl = NULL;
    578     }
    579 
    580     if (iAudioSourceRawIOControl)
    581     {
    582         PvmiMIOFileInputFactory::Delete(iAudioSourceRawIOControl);
    583         iAudioSourceRawIOControl = NULL;
    584     }
    585 
    586     if (iAudioSource2IOControl)
    587     {
    588         PvmiMIOFileInputFactory::Delete(iAudioSource2IOControl);
    589         iAudioSource2IOControl = NULL;
    590     }
    591 
    592     if (iAudioSource3IOControl)
    593     {
    594         PvmiMIOFileInputFactory::Delete(iAudioSource3IOControl);
    595         iAudioSource3IOControl = NULL;
    596     }
    597 
    598     if (iVideoSourceYUV)
    599     {
    600         PvmfMediaInputNodeFactory::Delete(iVideoSourceYUV);
    601         iVideoSourceYUV = NULL;
    602     }
    603 
    604     if (iVideoSourceH263)
    605     {
    606         PvmfMediaInputNodeFactory::Delete(iVideoSourceH263);
    607         iVideoSourceH263 = NULL;
    608     }
    609 
    610     if (iVideoSourceM4V)
    611     {
    612         PvmfMediaInputNodeFactory::Delete(iVideoSourceM4V);
    613         iVideoSourceM4V = NULL;
    614     }
    615 
    616     if (iVideoSourceYUVIOControl)
    617     {
    618         PvmiMIOFileInputFactory::Delete(iVideoSourceYUVIOControl);
    619         iVideoSourceYUVIOControl = NULL;
    620     }
    621 
    622     if (iVideoSourceM4VIOControl)
    623     {
    624         PvmiMIOFileInputFactory::Delete(iVideoSourceM4VIOControl);
    625         iVideoSourceM4VIOControl = NULL;
    626     }
    627 
    628     if (iVideoSourceH263IOControl)
    629     {
    630         PvmiMIOFileInputFactory::Delete(iVideoSourceH263IOControl);
    631         iVideoSourceH263IOControl = NULL;
    632     }
    633 
    634     if (iAudioSink)
    635     {
    636         PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioSink);
    637         iAudioSink = NULL;
    638     }
    639 
    640     if (iAudioSinkRaw)
    641     {
    642         PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioSinkRaw);
    643         iAudioSinkRaw = NULL;
    644     }
    645 
    646     if (iAudioSink2)
    647     {
    648         PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioSink2);
    649         iAudioSink2 = NULL;
    650     }
    651     if (iAudioSinkIOControl)
    652     {
    653         PvmiMIOFileInputFactory::Delete(iAudioSinkIOControl);
    654         iAudioSinkIOControl = NULL;
    655     }
    656 
    657     if (iAudioSinkRawIOControl)
    658     {
    659         PvmiMIOFileInputFactory::Delete(iAudioSinkRawIOControl);
    660         iAudioSinkRawIOControl = NULL;
    661     }
    662 
    663     if (iAudioSink2IOControl)
    664     {
    665         PvmiMIOFileInputFactory::Delete(iAudioSinkIOControl);
    666         iAudioSink2IOControl = NULL;
    667     }
    668     if (iVideoSinkYUV)
    669     {
    670         PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoSinkYUV);
    671         iVideoSinkYUV = NULL;
    672     }
    673 
    674     if (iVideoSinkH263)
    675     {
    676         PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoSinkH263);
    677         iVideoSinkH263 = NULL;
    678     }
    679 
    680     if (iVideoSinkM4V)
    681     {
    682         PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoSinkM4V);
    683         iVideoSinkM4V = NULL;
    684     }
    685 
    686     if (iVideoSinkYUVIOControl)
    687     {
    688         PvmiMIOFileInputFactory::Delete(iVideoSinkYUVIOControl);
    689         iVideoSinkYUVIOControl = NULL;
    690     }
    691 
    692     if (iVideoSinkM4VIOControl)
    693     {
    694         PvmiMIOFileInputFactory::Delete(iVideoSinkM4VIOControl);
    695         iVideoSinkM4VIOControl = NULL;
    696     }
    697 
    698     if (iVideoSinkH263IOControl)
    699     {
    700         PvmiMIOFileInputFactory::Delete(iVideoSinkH263IOControl);
    701         iVideoSinkH263IOControl = NULL;
    702     }
    703 
    704 }
    705 
    706 PVMFNodeInterface *engine_test::get_audio_source(PVMFFormatType format)
    707 {
    708     if (format == PVMF_MIME_AMR_IF2)
    709         return iAudioSource;
    710     else if (format ==  PVMF_MIME_PCM16)
    711         return iAudioSourceRaw;
    712     else
    713         return NULL;
    714 
    715 }
    716 
    717 PVMFNodeInterface *engine_test::get_audio_sink(PVMFFormatType format)
    718 {
    719     if (format == PVMF_MIME_AMR_IF2)
    720         return iAudioSink;
    721     if (format == PVMF_MIME_PCM16)
    722         return iAudioSinkRaw;
    723     else
    724         return NULL;
    725 }
    726 
    727 PVMFNodeInterface *engine_test::get_video_source(PVMFFormatType format)
    728 {
    729     if (format ==  PVMF_MIME_YUV420)
    730         return iVideoSourceYUV;
    731     else if (format ==  PVMF_MIME_M4V)
    732         return iVideoSourceM4V;
    733     else if (format ==  PVMF_MIME_H2632000)
    734         return iVideoSourceH263;
    735     else
    736         return NULL;
    737 }
    738 
    739 PVMFNodeInterface *engine_test::get_video_sink(PVMFFormatType format)
    740 {
    741     if (format == PVMF_MIME_YUV420)
    742         return iVideoSinkYUV;
    743     else if (format == PVMF_MIME_M4V)
    744         return iVideoSinkM4V;
    745     else if (format == PVMF_MIME_H2632000 || format == PVMF_MIME_H2631998)
    746         return iVideoSinkH263;
    747     else
    748         return NULL;
    749 }
    750 
    751 void engine_test::init_mime_strings()
    752 {
    753 }
    754 int test_wrapper()
    755 {
    756     int result;
    757 
    758     OsclErrorTrap::Init();
    759     OsclScheduler::Init("PV2WayEngineFactory");
    760 
    761     result = start_test();
    762 
    763     OsclScheduler::Cleanup();
    764     OsclErrorTrap::Cleanup();
    765 
    766     return result;
    767 }
    768 
    769 
    770 int local_main(FILE* filehandle, cmd_line *command_line)
    771 {
    772     OSCL_UNUSED_ARG(command_line);
    773     int result;
    774     global_cmd_line = command_line;
    775 
    776     fileoutput = filehandle;
    777     fprintf(fileoutput, "Test Program for PV Engine class.\n");
    778 
    779     CPV2WayEngineFactory::Init();
    780 #ifndef OSCL_BYPASS_MEMMGT
    781 #ifndef NDEBUG
    782 #ifdef MEM_AUDIT_2WAY
    783     OsclAuditCB auditCB;
    784     OsclMemInit(auditCB);
    785     auditCB.pAudit->MM_SetMode(auditCB.pAudit->MM_GetMode() |
    786                                MM_AUDIT_VALIDATE_ON_FREE_FLAG | MM_AUDIT_ALLOC_NODE_ENABLE_FLAG);
    787 #endif
    788 #endif
    789 #endif
    790     result = test_wrapper();
    791 
    792     PVLogger::Cleanup();
    793 #ifndef OSCL_BYPASS_MEMMGT
    794 #ifndef NDEBUG
    795 #ifdef MEM_AUDIT_2WAY
    796     //Check for memory leaks before cleaning up OsclMem.
    797 
    798     uint32 leaks = 0;
    799 
    800     if (auditCB.pAudit)
    801     {
    802         MM_Stats_t* stats = auditCB.pAudit->MM_GetStats("");
    803         if (stats)
    804         {
    805             fprintf(fileoutput, "Memory Stats:\n");
    806             fprintf(fileoutput, "  peakNumAllocs %d\n", stats->peakNumAllocs);
    807             fprintf(fileoutput, "  peakNumBytes %d\n", stats->peakNumBytes);
    808             fprintf(fileoutput, "  numAllocFails %d\n", stats->numAllocFails);
    809             if (stats->numAllocs)
    810             {
    811                 fprintf(fileoutput, "  ERROR: Memory Leaks! numAllocs %d, numBytes %d\n", stats->numAllocs, stats->numBytes);
    812             }
    813         }
    814         leaks = auditCB.pAudit->MM_GetNumAllocNodes();
    815         if (leaks != 0)
    816         {
    817             fprintf(fileoutput, "ERROR: %d Memory leaks detected!\n", leaks);
    818             MM_AllocQueryInfo*info = auditCB.pAudit->MM_CreateAllocNodeInfo(leaks);
    819             uint32 leakinfo = auditCB.pAudit->MM_GetAllocNodeInfo(info, leaks, 0);
    820             if (leakinfo != leaks)
    821             {
    822                 fprintf(fileoutput, "ERROR: Leak info is incomplete.\n");
    823             }
    824             for (uint32 i = 0; i < leakinfo; i++)
    825             {
    826                 fprintf(fileoutput, "Leak Info:\n");
    827                 fprintf(fileoutput, "  allocNum %d\n", info[i].allocNum);
    828                 fprintf(fileoutput, "  fileName %s\n", info[i].fileName);
    829                 fprintf(fileoutput, "  lineNo %d\n", info[i].lineNo);
    830                 fprintf(fileoutput, "  size %d\n", info[i].size);
    831                 fprintf(fileoutput, "  pMemBlock 0x%x\n", info[i].pMemBlock);
    832                 fprintf(fileoutput, "  tag %s\n", info[i].tag);
    833             }
    834             auditCB.pAudit->MM_ReleaseAllocNodeInfo(info);
    835         }
    836     }
    837 #endif
    838 #endif
    839 #endif
    840     PVLogger::Init();
    841     CPV2WayEngineFactory::Cleanup();
    842 
    843     return (result);
    844 }
    845 
    846 
    847 int start_test()
    848 {
    849     int32 leave;
    850     engine_test_suite engine_tests;
    851 
    852     OSCL_TRY(leave, engine_tests.run_test());
    853 
    854     if (leave != 0)
    855         fprintf(fileoutput, "Leave %d\n", leave);
    856 
    857     text_test_interpreter interp;
    858     _STRING rs = interp.interpretation(engine_tests.last_result());
    859     fprintf(fileoutput, rs.c_str());
    860     const test_result the_result = engine_tests.last_result();
    861 
    862     return(the_result.success_count() != the_result.total_test_count());
    863 }
    864 
    865 #if (LINUX_MAIN==1)
    866 
    867 int main(int argc, char *argv[])
    868 {
    869     local_main(stdout, NULL);
    870     return 0;
    871 }
    872 
    873 #endif
    874 
    875