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 #ifndef TEST_PV_PLAYER_ENGINE_H_INCLUDED
19 #include "test_pv_player_engine.h"
20 #endif
21
22 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET1_H_INCLUDED
23 #include "test_pv_player_engine_testset1.h"
24 #endif
25
26 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET7_H_INCLUDED
27 #include "test_pv_player_engine_testset7.h"
28 #endif
29
30 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET8_H_INCLUDED
31 #include "test_pv_player_engine_testset8.h"
32 #endif
33
34 #if (RUN_HTTPDOWNLOAD_TESTCASES || RUN_FASTTRACK_TESTCASES)
35 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET5_H_INCLUDED
36 #include "test_pv_player_engine_testset5.h"
37 #endif
38 #endif
39
40 #if RUN_STREAMING_TESTCASES
41 #if PVR_SUPPORT
42 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET3_H_INCLUDED
43 #include "test_pv_player_engine_testset3.h"
44 #endif
45 #endif
46 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET6_H_INCLUDED
47 #include "test_pv_player_engine_testset6.h"
48 #endif
49 #endif
50
51 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET9_H_INCLUDED
52 #include "test_pv_player_engine_testset9.h"
53 #endif
54
55 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET10_H_INCLUDED
56 #include "test_pv_player_engine_testset10.h"
57 #endif
58
59 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET11_H_INCLUDED
60 #include "test_pv_player_engine_testset11.h"
61 #endif
62 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET12_H_INCLUDED
63 #include "test_pv_player_engine_testset12.h"
64 #endif
65 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET13_H_INCLUDED
66 #include "test_pv_player_engine_testset13.h"
67 #endif
68
69 #if RUN_APP_TRACK_SELECTION_TESTCASES
70 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET_APPTRACKSELECTION_H_INCLUDED
71 #include "test_pv_player_engine_testset_apptrackselection.h"
72 #endif
73 #endif //RUN_APP_TRACK_SELECTION_TESTCASES
74
75 #if RUN_CPMJANUS_TESTCASES
76 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET_CPMJANUS_H_INCLUDED
77 #include "test_pv_player_engine_testset_cpmjanus.h"
78 #endif
79
80 #endif
81
82 #if RUN_CPMJUPITER_TESTCASES
83 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET_CPMJUPITER_H_INCLUDED
84 #include "test_pv_player_engine_testset_cpmjupiter.h"
85 #endif
86 #endif
87
88 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
89 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET_CPMDLAPASSTHRU_H_INCLUDED
90 #include "test_pv_player_engine_testset_cpmdlapassthru.h"
91 #endif
92 #endif
93
94 #if RUN_CPMACCESS_TESTCASES
95 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET_CPMACCESS_H_INCLUDED
96 #include "test_pv_player_engine_testset_cpmaccess.h"
97 #endif
98 #endif
99
100 #if ((RUN_CPMOMA1_DLAPASSTHRU_TESTCASES) && (RUN_CPMJANUS_TESTCASES))
101 #ifndef TEST_PV_PLAYER_ENGINE_TESTSET_MULTICPM_H_INCLUDED
102 #include "test_pv_player_engine_testset_multicpm.h"
103 #endif
104 #endif
105
106 #ifndef OSCL_MEM_H_INCLUDED
107 #include "oscl_mem.h"
108 #endif
109
110 #ifndef OSCL_MEM_AUDIT_H_INCLUDED
111 #include "oscl_mem_audit.h"
112 #endif
113
114 #ifndef OSCL_ERROR_H_INCLUDED
115 #include "oscl_error.h"
116 #endif
117
118 #ifndef OSCL_SCHEDULER_H_INCLUDED
119 #include "oscl_scheduler.h"
120 #endif
121
122 #ifndef PVLOGGER_H_INCLUDED
123 #include "pvlogger.h"
124 #endif
125
126 #ifndef PVLOGGER_FILE_APPENDER_H_INCLUDED
127 #include "pvlogger_file_appender.h"
128 #endif
129
130 #ifndef PVLOGGER_MEM_APPENDER_H_INCLUDED
131 #include "pvlogger_mem_appender.h"
132 #endif
133
134 #ifndef __UNIT_TEST_TEST_ARGS__
135 #include "unit_test_args.h"
136 #endif
137
138 #ifdef BUILD_N_ARM
139 #ifndef __OMF_MC_H__
140 #include "omf_mc.h"
141 #endif
142
143 #define CONFIG_FILE_NAME "/usr/lib/omf/omx_media_player.cfg"
144 #endif
145
146 #include "OMX_Core.h"
147 #include "pv_omxcore.h"
148
149 #ifndef OSCL_UTF8CONV_H
150 #include "oscl_utf8conv.h"
151 #endif
152
153 #ifndef DEFAULTSOURCEFILENAME
154 #error // The default source file needs to be defined in config file
155 #endif
156
157 #ifndef DEFAULTSOURCEFORMATTYPE
158 #error // The format type for default source file needs to be defined in config file
159 #endif
160
161 #ifndef OSCL_STRING_UTILS_H_INCLUDED
162 #include "oscl_string_utils.h"
163 #endif
164
165
166 FILE *file;
167
168 class PVLoggerConfigFile
169 {
170 /* To change the logging settings without the need to compile the test application
171 Let us read the logging settings from the file instead of hard coding them over here
172 The name of the config file is pvlogger.ini
173 The format of entries in it is like
174 First entry will decide if the file appender has to be used or error appender will be used.
175 0 -> ErrAppender will be used
176 1 -> File Appender will be used
177 2 -> Mem Appender will be used
178 Entries after this will decide the module whose logging has to be taken.For example, contents of one sample config file could be
179 1
180 1,PVPlayerEngine
181 8,PVSocketNode
182 (pls note that no space is allowed between loglevel and logger tag)
183 This means, we intend to have logging of level 1 for the module PVPlayerEngine
184 and of level 8 for the PVSocketNode on file.
185 */
186 public:
187
PVLoggerConfigFile()188 PVLoggerConfigFile(): iLogFileRead(false)
189 {
190 iFileServer.Connect();
191 // Full path of pvlogger.ini is: SOURCENAME_PREPEND_STRING + pvlogger.ini
192 oscl_strncpy(iLogFileName, SOURCENAME_PREPEND_STRING,
193 oscl_strlen(SOURCENAME_PREPEND_STRING) + 1);
194 oscl_strcat(iLogFileName, "pvlogger.ini");
195 oscl_memset(ibuffer, 0, sizeof(ibuffer));
196 iAppenderType = 0;
197
198 }
199
~PVLoggerConfigFile()200 ~PVLoggerConfigFile()
201 {
202 iFileServer.Close();
203 }
204
IsLoggerConfigFilePresent()205 bool IsLoggerConfigFilePresent()
206 {
207 if (-1 != ReadAndParseLoggerConfigFile())
208 return true;
209 return false;
210 }
211
212 //Read and parse the config file
213 //retval = -1 if the config file doesnt exist
ReadAndParseLoggerConfigFile()214 int8 ReadAndParseLoggerConfigFile()
215 {
216 int8 retval = 1;
217
218 if (0 != iLogFile.Open(iLogFileName, Oscl_File::MODE_READ, iFileServer))
219 {
220 retval = -1;
221 }
222 else
223 {
224 if (!iLogFileRead)
225 {
226 iLogFile.Read(ibuffer, 1, sizeof(ibuffer));
227 //Parse the buffer for \n chars
228 Oscl_Vector<char*, OsclMemAllocator> LogConfigStrings;
229
230 //Get the logger strings
231 const char* const lnFd = "\n";
232 const int8 lnFdLen = oscl_strlen(lnFd);
233 int16 offset = 0;
234 char* lastValidBffrAddr = ibuffer + oscl_strlen(ibuffer);
235 const char* lnFdIndx = oscl_strstr(ibuffer, lnFd);
236 while (lnFdIndx != NULL && lnFdIndx < lastValidBffrAddr)
237 {
238
239 // Remove the "\r" to avoid any windows formatting issues
240 if (*(lnFdIndx - 1) == '\r')
241 {
242 oscl_memset((char*)(lnFdIndx - 1), '\0', lnFdLen);
243 }
244 else
245 {
246 oscl_memset((char*)lnFdIndx, '\0', lnFdLen);
247 }
248
249 LogConfigStrings.push_back(ibuffer + offset);
250 offset = (lnFdIndx + lnFdLen) - ibuffer;
251 lnFdIndx = OSCL_CONST_CAST(char*, oscl_strstr(ibuffer + offset, lnFd));
252 }
253 if (NULL == lnFdIndx && ((ibuffer + offset) < lastValidBffrAddr)) //If \r\n is skipped after the last logging str in ini file
254 {
255 LogConfigStrings.push_back(ibuffer + offset);
256 }
257
258
259 //Populate the LoggerConfigElements vector
260 {
261 if (!LogConfigStrings.empty())
262 {
263 Oscl_Vector<char*, OsclMemAllocator>::iterator it;
264 it = LogConfigStrings.begin();
265 uint32 appenderType;
266 PV_atoi(*it, 'd', oscl_strlen(*it), appenderType);
267 iAppenderType = appenderType;
268 if (LogConfigStrings.size() > 1)
269 {
270 for (it = LogConfigStrings.begin() + 1; it != LogConfigStrings.end(); it++)
271 {
272 char* CommaIndex = OSCL_CONST_CAST(char*, oscl_strstr(*it, ","));
273 if (CommaIndex != NULL)
274 {
275 *CommaIndex = '\0';
276 LoggerConfigElement obj;
277 uint32 logLevel;
278 PV_atoi(*it, 'd', oscl_strlen(*it), logLevel);
279 obj.iLogLevel = logLevel;
280 obj.iLoggerString = CommaIndex + 1;
281 iLoggerConfigElements.push_back(obj);
282 }
283 }
284 }
285 else
286 {
287 //Add the config element for complete logging fo all the modules
288 LoggerConfigElement obj;
289 obj.iLoggerString = NULL;
290 obj.iLogLevel = 8;
291 iLoggerConfigElements.push_back(obj);
292 }
293 }
294 }
295 iLogFile.Close();
296 iLogFileRead = true;
297 }
298 }
299 return retval;
300 }
301
SetLoggerSettings()302 void SetLoggerSettings()
303 {
304 Oscl_Vector<LoggerConfigElement, OsclMemAllocator>::iterator it;
305
306 PVLoggerAppender *appender = NULL;
307 OsclRefCounter *refCounter = NULL;
308 if (iLoggerConfigElements.empty())
309 {
310 return;
311 }
312
313 if (iAppenderType == 0)
314 {
315 appender = new StdErrAppender<TimeAndIdLayout, 1024>();
316 OsclRefCounterSA<LogAppenderDestructDealloc<StdErrAppender<TimeAndIdLayout, 1024> > > *appenderRefCounter =
317 new OsclRefCounterSA<LogAppenderDestructDealloc<StdErrAppender<TimeAndIdLayout, 1024> > >(appender);
318 refCounter = appenderRefCounter;
319 }
320 else if (iAppenderType == 1)
321 {
322 OSCL_wHeapString<OsclMemAllocator> logfilename(OUTPUTNAME_PREPEND_WSTRING);
323 logfilename += _STRLIT_WCHAR("player.log");
324 appender = (PVLoggerAppender*)TextFileAppender<TimeAndIdLayout, 1024>::CreateAppender(logfilename.get_str());
325 OsclRefCounterSA<LogAppenderDestructDealloc<TextFileAppender<TimeAndIdLayout, 1024> > > *appenderRefCounter =
326 new OsclRefCounterSA<LogAppenderDestructDealloc<TextFileAppender<TimeAndIdLayout, 1024> > >(appender);
327 refCounter = appenderRefCounter;
328 }
329 else
330 {
331 OSCL_wHeapString<OsclMemAllocator> logfilename(OUTPUTNAME_PREPEND_WSTRING);
332 logfilename += _STRLIT_WCHAR("player.log");
333 appender = (PVLoggerAppender*)MemAppender<TimeAndIdLayout, 1024>::CreateAppender(logfilename.get_str());
334 OsclRefCounterSA<LogAppenderDestructDealloc<MemAppender<TimeAndIdLayout, 1024> > > *appenderRefCounter =
335 new OsclRefCounterSA<LogAppenderDestructDealloc<MemAppender<TimeAndIdLayout, 1024> > >(appender);
336 refCounter = appenderRefCounter;
337 }
338
339 OsclSharedPtr<PVLoggerAppender> appenderPtr(appender, refCounter);
340
341 for (it = iLoggerConfigElements.begin(); it != iLoggerConfigElements.end(); it++)
342 {
343 PVLogger *node = NULL;
344 node = PVLogger::GetLoggerObject(it->iLoggerString);
345 node->AddAppender(appenderPtr);
346 node->SetLogLevel(it->iLogLevel);
347 }
348 }
349
350 private:
351 class LoggerConfigElement
352 {
353 public:
LoggerConfigElement()354 LoggerConfigElement()
355 {
356 iLoggerString = NULL;
357 iLogLevel = 8;
358 }
359 char *iLoggerString;
360 int8 iLogLevel;
361 };
362 int8 iAppenderType; //Type of appender to be used for the logging 0-> Err Appender, 1-> File Appender
363 bool iLogFileRead;
364 Oscl_File iLogFile;
365 Oscl_FileServer iFileServer;
366 char iLogFileName[255];
367 char ibuffer[1024];
368 Oscl_Vector<LoggerConfigElement, OsclMemAllocator> iLoggerConfigElements;
369 };
370
371 template <typename T>
372 class CmdLinePopulator
373 {
374 public:
CmdLinePopulator()375 CmdLinePopulator()
376 {
377 iNumArgs = 0;
378 for (int ii = 0; ii < MAXNUMARGS; ii++)
379 {
380 iArgArr[ii] = NULL;
381 }
382 }
~CmdLinePopulator()383 ~CmdLinePopulator()
384 {
385 for (int ii = 0; ii < MAXNUMARGS ; ii++)
386 {
387 if (iArgArr[ii] != NULL)
388 {
389 delete iArgArr[ii];
390 iArgArr[ii] = NULL;
391 }
392 }
393
394 }
395
396
397 bool PopulateCmdLine(Oscl_File* apFile, cmd_line* apCommandLine);
398 bool PopulateCmdLine(oscl_wchar* apFileName, cmd_line* apCommandLine);
399
400 uint32 iNumArgs;
401 enum ArgListAttributes
402 {
403 MAXNUMARGS = 15,
404 MAXARGLEN = 256
405 };
406 T* iArgArr[MAXNUMARGS];
407 };
408
PopulateCmdLine(Oscl_File * apFile,cmd_line * apCommandLine)409 template <typename T> bool CmdLinePopulator<T>::PopulateCmdLine(Oscl_File* apFile, cmd_line* apCommandLine)
410 {
411
412 return false;
413 }
414
PopulateCmdLine(oscl_wchar * apFileName,cmd_line * apCommandLine)415 template <typename T> bool CmdLinePopulator<T>::PopulateCmdLine(oscl_wchar* apFileName, cmd_line* apCommandLine)
416 {
417 int32 err = 0;
418 bool retval = false;
419 Oscl_FileServer fileServer;
420 err = fileServer.Connect();
421 if (0 == err)
422 {
423 Oscl_File* pFilePtr = new Oscl_File;
424 if (pFilePtr != NULL)
425 {
426 err = pFilePtr->Open(apFileName, Oscl_File::MODE_READ, fileServer);
427 if (0 == err)
428 {
429 if (0 == pFilePtr->Seek(0, Oscl_File::SEEKSET))
430 {
431 //We require text in input file to be in ascii format
432 const uint32 maxExpectedFileSz = sizeof(char) * (MAXNUMARGS + 1) * MAXARGLEN;
433 char buffer[maxExpectedFileSz];
434 oscl_memset(buffer, 0, sizeof(buffer));
435
436 const uint32 elementSz = sizeof(buffer[0]);
437 const uint32 numOfElementsToRead = sizeof(buffer) / sizeof(buffer[0]);
438 const uint32 numOfElementsRead = pFilePtr->Read(buffer, elementSz, numOfElementsToRead);
439
440 //we expect file size to be less than maxExpectedFileSz, therefore
441 //numOfElementsRead should be less than numOfElementsToRead
442 if (numOfElementsRead == numOfElementsToRead)
443 {
444 //print config err
445 return false;
446 }
447
448 uint32 bufferIndexToParse = 0;
449 int32 numArgPushed = 0;
450 while (bufferIndexToParse < numOfElementsRead)
451 {
452 char* subBuffer = buffer + bufferIndexToParse;
453 uint32 subBufferLen = 0;
454 char* const terminal = oscl_strstr(subBuffer, "\"");
455 if (terminal)
456 {
457 subBufferLen = terminal - subBuffer;
458 }
459 else
460 {
461 subBufferLen = buffer + numOfElementsRead - subBuffer;
462 }
463 bufferIndexToParse += subBufferLen;
464
465 //preprocess the subbuffer
466 char* ptrIter = subBuffer;
467 const char* ptrEnd = subBuffer + subBufferLen;
468
469
470 while (ptrIter < ptrEnd)
471 {
472 if (('\r' == *ptrIter) || ('\n' == *ptrIter) || (' ' == *ptrIter) || ('\t' == *ptrIter))
473 {
474 *ptrIter = '\0';
475 }
476 ++ptrIter;
477 }
478
479 uint32 startingSubBufferIndexToParse = 0;
480 while (startingSubBufferIndexToParse < subBufferLen)
481 {
482 //eat any '\0' in the begin
483 while (subBuffer[startingSubBufferIndexToParse] == '\0')
484 {
485 startingSubBufferIndexToParse++;
486
487 }
488
489 if (startingSubBufferIndexToParse > subBufferLen)
490 {
491 break;
492 }
493
494 const uint32 argLen = oscl_strlen(subBuffer + startingSubBufferIndexToParse);
495 uint32 bufferLenToCopy = argLen < MAXARGLEN ? argLen : (MAXARGLEN - 1);
496 if (bufferLenToCopy > 0 && numArgPushed < MAXNUMARGS)
497 {
498 T* arg = new T[bufferLenToCopy + 1];
499 if (sizeof(T) != sizeof(char))
500 {//unicode
501 oscl_UTF8ToUnicode(subBuffer + startingSubBufferIndexToParse, bufferLenToCopy, OSCL_STATIC_CAST(oscl_wchar*, arg), bufferLenToCopy + 1);
502 }
503 else
504 {
505 oscl_strncpy(OSCL_STATIC_CAST(char*, arg), subBuffer + startingSubBufferIndexToParse, bufferLenToCopy);
506 arg[bufferLenToCopy] = '\0';
507 }
508 iArgArr[numArgPushed] = arg;
509 numArgPushed++;
510 }
511 startingSubBufferIndexToParse += (argLen + 1);//1 is added for the '\0' in the end of arg in subbuffer
512 }
513
514 //look for the ending terminal "\""
515 if (terminal)
516 {
517 //we need to look for ending terminal and accept the param within quotes as the arg
518 char* const argEnd = oscl_strstr(terminal + 1, "\"");
519 if (argEnd)
520 {
521 *terminal = *argEnd = '\0';
522 const uint32 argLen = oscl_strlen(terminal + 1);
523 uint32 bufferLenToCopy = argLen < MAXARGLEN ? argLen : (MAXARGLEN - 1);
524 if (bufferLenToCopy > 0 && numArgPushed < MAXNUMARGS)
525 {
526 T* arg = new T[bufferLenToCopy + 1];
527 if (sizeof(T) != sizeof(char))
528 {//unicode
529 oscl_UTF8ToUnicode((terminal + 1), bufferLenToCopy, OSCL_STATIC_CAST(oscl_wchar*, arg), bufferLenToCopy + 1);
530 }
531 else
532 {
533 oscl_strncpy(OSCL_STATIC_CAST(char*, arg), (terminal + 1), bufferLenToCopy);
534 arg[bufferLenToCopy] = '\0';
535 }
536 iArgArr[numArgPushed] = arg;
537 numArgPushed++;
538 }
539 bufferIndexToParse += (argLen + 1);
540 }
541 else
542 {
543 return false;
544 }
545 }
546 }
547 iNumArgs = numArgPushed;
548 apCommandLine->setup(iNumArgs, iArgArr);
549 retval = true;
550 }
551 pFilePtr->Close();
552 }
553 else
554 {
555 char filename[255] = {0};
556 oscl_UnicodeToUTF8(apFileName, oscl_strlen(apFileName), filename, 255);
557 fprintf(file, "Could not locate the file %s", filename);
558 }
559 OSCL_DELETE(pFilePtr);
560 }
561 fileServer.Close();
562 }
563 return retval;
564 }
565
566 /** Name: ConvertToLowerCase
567 * Description: Utility function to convert a string in lower case
568 * convert upper case ASCII String to lower case.
569 * behaviour of this function for non-ASCII characters
570 * is not defined.
571 *
572 * @param char input string.
573 * @return lower case String.
574 */
ConvertToLowerCase(char * aString)575 void ConvertToLowerCase(char *aString)
576 {
577 int32 counter = 0;
578 while (aString[counter])
579 {
580 // convert the input character to lower case
581 aString[counter] = oscl_tolower(aString[counter]);
582 counter++;
583 }
584
585 }
586
587 /*Structs n funcs for parsing the logger config file completes*/
588
589 // Parse source type from arguments
FindSourceType(cmd_line * command_line,OSCL_HeapString<OsclMemAllocator> & aFileNameInfo,PVMFFormatType & aInputFileFormatType,int32 & aTemp_Flag,FILE * aFile)590 void FindSourceType(cmd_line* command_line, OSCL_HeapString<OsclMemAllocator> &aFileNameInfo, PVMFFormatType &aInputFileFormatType, int32 &aTemp_Flag, FILE *aFile)
591 {
592 bool cmdline_iswchar = command_line->is_wchar();
593 int count = command_line->get_count(); //Getting number of arguments
594
595 // use mp4 as default test file
596 aFileNameInfo = SOURCENAME_PREPEND_STRING;
597 aFileNameInfo += DEFAULTSOURCEFILENAME;
598 aInputFileFormatType = DEFAULTSOURCEFORMATTYPE;
599
600
601 // Search for the "sourcetype(example --- mp3)" argument
602 // Go through each argument
603
604 for (int formatSearch = 0; formatSearch < count; formatSearch++)
605 {
606 char argstr[128];
607 // Convert to UTF8 if necessary
608 if (cmdline_iswchar)
609 {
610 oscl_wchar* argwstr = NULL;
611 command_line->get_arg(formatSearch, argwstr); //getting the value of argument at formatSearch position
612 oscl_UnicodeToUTF8(argwstr, oscl_strlen(argwstr), argstr, 128);
613 argstr[127] = '\0';
614 }
615 else
616 {
617 char* tmpstr = NULL;
618 command_line->get_arg(formatSearch, tmpstr);
619 int32 tmpstrlen = oscl_strlen(tmpstr) + 1;
620 if (tmpstrlen > 128)
621 {
622 tmpstrlen = 128;
623 }
624 oscl_strncpy(argstr, tmpstr, tmpstrlen);
625 argstr[tmpstrlen-1] = '\0';
626 }
627
628 ConvertToLowerCase(argstr); //Convert the string in lower case
629
630
631 // Do the string compare
632 if (oscl_strcmp(argstr, "-help") == 0)
633 {
634 fprintf(aFile, "Format type specification option. Default is 'mp4':\n");
635 fprintf(aFile, "Specify the format type name in upper case/lower case letter for test cases which\n");
636 fprintf(aFile, " allow user-specified format type.\n");
637 fprintf(aFile, "e.g. for executing MP4 specific tests: test_pv_player_engine.exe MP4)\n");
638 break;
639 }
640 else if (oscl_strcmp(argstr, "mp3") == 0)
641 {
642 aInputFileFormatType = LOCAL_TEST_FILE_MP3_FORMAT_TYPE;
643 aFileNameInfo = LOCAL_TEST_FILE_MP3_CBR;
644 aTemp_Flag = MP3_ENABLED;
645 break;
646
647 }
648 else if (oscl_strcmp(argstr, "aac") == 0)
649 {
650 aInputFileFormatType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
651 aFileNameInfo = LOCAL_TEST_FILE_AAC_ADTS;
652 aTemp_Flag = AAC_ENABLED;
653 break;
654
655 }
656 else if (oscl_strcmp(argstr, "amr") == 0)
657 {
658 aInputFileFormatType = LOCAL_TEST_FILE_AMR_FORMAT_TYPE;
659 aFileNameInfo = LOCAL_TEST_FILE_AMR_IETF;
660 aTemp_Flag = AMR_ENABLED;
661 break;
662
663 }
664 else if (oscl_strcmp(argstr, "mp4") == 0)
665 {
666 aInputFileFormatType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
667 aFileNameInfo = LOCAL_TEST_FILE_MP4_M4V_AMR;
668 aTemp_Flag = MP4_ENABLED;
669 break;
670
671 }
672 else if (oscl_strcmp(argstr, "3gp") == 0)
673 {
674 aInputFileFormatType = LOCAL_TEST_FILE_3GP_FORMAT_TYPE;
675 aFileNameInfo = LOCAL_TEST_FILE_3GP;
676 aTemp_Flag = THREE_GP_ENABLED;
677 break;
678
679 }
680 else if (oscl_strcmp(argstr, "asf") == 0)
681 {
682 aInputFileFormatType = LOCAL_TEST_FILE_ASF_FORMAT_TYPE ;
683 aFileNameInfo = LOCAL_TEST_FILE_ASF;
684 aTemp_Flag = ASF_ENABLED;
685 break;
686
687 }
688 else if (oscl_strcmp(argstr, "rm") == 0)
689 {
690 aInputFileFormatType = LOCAL_TEST_FILE_REALAUDIO_FORMAT_TYPE;
691 aFileNameInfo = LOCAL_TEST_FILE_REALAUDIO;
692 aTemp_Flag = RM_ENABLED;
693 break;
694
695 }
696 else if (oscl_strcmp(argstr, "wav") == 0)
697 {
698 aInputFileFormatType = LOCAL_TEST_FILE_WAV_FORMAT_TYPE;
699 aFileNameInfo = LOCAL_TEST_FILE_WAV;
700 aTemp_Flag = WAV_ENABLED;
701 break;
702 }
703 else if (oscl_strcmp(argstr, "wmv") == 0)
704 {
705 aInputFileFormatType = LOCAL_TEST_FILE_WMV_FORMAT_TYPE;
706 aFileNameInfo = LOCAL_TEST_FILE_WMV;
707 aTemp_Flag = WMV_ENABLED;
708 break;
709 }
710 else if (oscl_strcmp(argstr, "wma") == 0)
711 {
712 aInputFileFormatType = LOCAL_TEST_FILE_WMA_FORMAT_TYPE;
713 aFileNameInfo = LOCAL_TEST_FILE_WMA;
714 aTemp_Flag = WMA_ENABLED;
715 break;
716 }
717
718 }
719
720 }
721
722 // Pull out source file name from arguments
723 // -source sometestfile.mp4
724
FindSourceFile(cmd_line * command_line,OSCL_HeapString<OsclMemAllocator> & aFileNameInfo,PVMFFormatType & aInputFileFormatType,FILE * aFile)725 void FindSourceFile(cmd_line* command_line, OSCL_HeapString<OsclMemAllocator> &aFileNameInfo, PVMFFormatType &aInputFileFormatType, FILE *aFile)
726 {
727 int iFileArgument = 0;
728 bool iFileFound = false;
729 bool cmdline_iswchar = command_line->is_wchar();
730
731 int count = command_line->get_count();
732
733 // Search for the "-source" argument
734 // Go through each argument
735 for (int iFileSearch = 0; iFileSearch < count; iFileSearch++)
736 {
737 char argstr[128];
738 // Convert to UTF8 if necessary
739 if (cmdline_iswchar)
740 {
741 oscl_wchar* argwstr = NULL;
742 command_line->get_arg(iFileSearch, argwstr);
743 oscl_UnicodeToUTF8(argwstr, oscl_strlen(argwstr), argstr, 128);
744 argstr[127] = '\0';
745 }
746 else
747 {
748 char* tmpstr = NULL;
749 command_line->get_arg(iFileSearch, tmpstr);
750 int32 tmpstrlen = oscl_strlen(tmpstr) + 1;
751 if (tmpstrlen > 128)
752 {
753 tmpstrlen = 128;
754 }
755 oscl_strncpy(argstr, tmpstr, tmpstrlen);
756 argstr[tmpstrlen-1] = '\0';
757 }
758
759 // Do the string compare
760 if (oscl_strcmp(argstr, "-help") == 0)
761 {
762 fprintf(aFile, "Source specification option. Default is 'test.mp4':\n");
763 fprintf(aFile, " -source sourcename\n");
764 fprintf(aFile, " Specify the source filename or URL to use for test cases which\n");
765 fprintf(aFile, " allow user-specified source name. The unit test determines the\n");
766 fprintf(aFile, " source format type using extension or URL header.\n\n");
767 }
768 else if (oscl_strcmp(argstr, "-source") == 0)
769 {
770 iFileFound = true;
771 iFileArgument = ++iFileSearch;
772 break;
773 }
774 }
775
776 if (iFileFound)
777 {
778 // Convert to UTF8 if necessary
779 if (cmdline_iswchar)
780 {
781 oscl_wchar* cmd;
782 command_line->get_arg(iFileArgument, cmd);
783 char tmpstr[256];
784 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), tmpstr, 256);
785 tmpstr[255] = '\0';
786 aFileNameInfo = tmpstr;
787 }
788 else
789 {
790 char* cmdlinefilename = NULL;
791 command_line->get_arg(iFileArgument, cmdlinefilename);
792 aFileNameInfo = cmdlinefilename;
793 }
794
795 // Check the file extension to determine format type
796 // AAC file
797 if (oscl_strstr(aFileNameInfo.get_cstr(), ".aac") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".AAC") != NULL)
798 {
799 aInputFileFormatType = PVMF_MIME_AACFF;
800
801
802 }
803 // AMR file (IETF and IF2)
804 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".amr") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".AMR") != NULL ||
805 oscl_strstr(aFileNameInfo.get_cstr(), ".cod") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".COD") != NULL)
806 {
807 aInputFileFormatType = PVMF_MIME_AMRFF;
808 }
809 // RTSP URL
810 else if ((!oscl_strncmp("rtsp", aFileNameInfo.get_cstr(), 4)) ||
811 (!oscl_strncmp("RTSP", aFileNameInfo.get_cstr(), 4)))
812 {
813 aInputFileFormatType = PVMF_MIME_DATA_SOURCE_RTSP_URL;
814 }
815 // HTTP URL
816 else if (oscl_strstr(aFileNameInfo.get_cstr(), "http:") != NULL ||
817 oscl_strstr(aFileNameInfo.get_cstr(), "HTTP:") != NULL ||
818 oscl_strstr(aFileNameInfo.get_cstr(), "mms:") != NULL ||
819 oscl_strstr(aFileNameInfo.get_cstr(), "MMS:") != NULL)
820 {
821 aInputFileFormatType = PVMF_MIME_DATA_SOURCE_HTTP_URL;
822 }
823 // MP4/3GP file
824 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".mp4") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".MP4") != NULL ||
825 oscl_strstr(aFileNameInfo.get_cstr(), ".3gp") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".3GP") != NULL)
826 {
827 aInputFileFormatType = PVMF_MIME_MPEG4FF;
828 }
829 // ASF file
830 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".asf") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".ASF") != NULL ||
831 oscl_strstr(aFileNameInfo.get_cstr(), ".wma") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".WMA") != NULL ||
832 oscl_strstr(aFileNameInfo.get_cstr(), ".wmv") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".WMV") != NULL)
833 {
834 aInputFileFormatType = PVMF_MIME_ASFFF;
835 }
836 // MP3 file
837 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".mp3") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".MP3") != NULL)
838 {
839 aInputFileFormatType = PVMF_MIME_MP3FF;
840 }
841 // RM file
842 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".rm") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".RM") != NULL)
843 {
844 aInputFileFormatType = PVMF_MIME_RMFF;
845 }
846 // SDP file. also includes PVR files
847 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".sdp") != NULL ||
848 oscl_strstr(aFileNameInfo.get_cstr(), ".SDP") != NULL ||
849 oscl_strstr(aFileNameInfo.get_cstr(), ".pvr") != NULL ||
850 oscl_strstr(aFileNameInfo.get_cstr(), ".PVR") != NULL)
851 {
852 aInputFileFormatType = PVMF_MIME_DATA_SOURCE_SDP_FILE;
853 }
854 // PVX file
855 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".pvx") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".PVX") != NULL)
856 {
857 aInputFileFormatType = PVMF_MIME_DATA_SOURCE_PVX_FILE;
858 }
859 // WAV file
860 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".wav") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".WAV") != NULL)
861 {
862 aInputFileFormatType = PVMF_MIME_WAVFF;
863 }
864 // MIDI file
865 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".mid") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".MID") != NULL)
866 {
867 // aInputFileFormatType = PVMF_MIME_MIDIFF;
868 }
869 // unrecognized eny (Jupiter envelope) files go to the still image node
870 else if (oscl_strstr(aFileNameInfo.get_cstr(), ".eny") != NULL || oscl_strstr(aFileNameInfo.get_cstr(), ".ENY") != NULL)
871 {
872 aInputFileFormatType = PVMF_MIME_IMAGE_FORMAT;
873 }
874 // Unknown so set to unknown try to have the player engine recognize
875 else
876 {
877 fprintf(file, "Source type unknown so setting to unknown and have the player engine recognize it\n");
878 aInputFileFormatType = PVMF_MIME_FORMAT_UNKNOWN;
879 }
880 }
881 }
882
883 //Find test range args:
884 //To run a range of tests by enum ID:
885 // -test 17 29
886 //To run all Local play tests>
887 // -test L
888 //To run all Download tests
889 // -test D
890 //To run all Streaming tests:
891 // -test S
FindTestRange(cmd_line * command_line,int32 & iFirstTest,int32 & iLastTest,FILE * aFile)892 void FindTestRange(cmd_line *command_line, int32 &iFirstTest, int32 &iLastTest, FILE *aFile)
893 {
894 //default is to run all tests.
895 iFirstTest = 0;
896 iLastTest = 9999;
897
898 int iTestArgument = 0;
899 char *iTestArgStr1 = NULL;
900 char *iTestArgStr2 = NULL;
901 bool iTestFound = false;
902 bool cmdline_iswchar = command_line->is_wchar();
903
904 int count = command_line->get_count();
905
906 // Search for the "-test" argument
907 char *iSourceFind = NULL;
908 if (cmdline_iswchar)
909 {
910 iSourceFind = new char[256];
911 }
912
913 // Go through each argument
914 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
915 {
916 // Convert to UTF8 if necessary
917 if (cmdline_iswchar)
918 {
919 OSCL_TCHAR* cmd = NULL;
920 command_line->get_arg(iTestSearch, cmd);
921 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
922 }
923 else
924 {
925 iSourceFind = NULL;
926 command_line->get_arg(iTestSearch, iSourceFind);
927 }
928
929 // Do the string compare
930 if (oscl_strcmp(iSourceFind, "-help") == 0)
931 {
932 fprintf(aFile, "Test cases to run option. Default is ALL:\n");
933 fprintf(aFile, " -test x y\n");
934 fprintf(aFile, " Specify a range of test cases to run. To run one test case, use the\n");
935 fprintf(aFile, " same index for x and y.\n");
936 fprintf(aFile, " -test L\n");
937 fprintf(aFile, " Run local playback test cases only.\n");
938 fprintf(aFile, " -test D\n");
939 fprintf(aFile, " Run download playback test cases only.\n");
940 fprintf(aFile, " -test S\n");
941 fprintf(aFile, " Run streaming playback test cases only.\n\n");
942 }
943 else if (oscl_strcmp(iSourceFind, "-test") == 0)
944 {
945 iTestFound = true;
946 iTestArgument = ++iTestSearch;
947 break;
948 }
949 else
950 {
951 ConvertToLowerCase(iSourceFind);
952 if (oscl_strcmp(iSourceFind, "aac") == 0 || oscl_strcmp(iSourceFind, "amr") == 0 || //When argument is supplied as test.exe mp3/amr,then local playback range has to be set
953 oscl_strcmp(iSourceFind, "mp4") == 0 || oscl_strcmp(iSourceFind, "3gp") == 0 ||
954 oscl_strcmp(iSourceFind, "mp3") == 0 || oscl_strcmp(iSourceFind, "wav") == 0 ||
955 oscl_strcmp(iSourceFind, "wmv") == 0 || oscl_strcmp(iSourceFind, "wma") == 0 ||
956 oscl_strcmp(iSourceFind, "asf") == 0 || oscl_strcmp(iSourceFind, "rm") == 0)
957 {
958 iFirstTest = FIRST_LOCAL_PLAYBACK;
959 iLastTest = LAST_LOCAL_PLAYBACK;
960 }
961 }
962
963 }
964
965 if (cmdline_iswchar)
966 {
967 delete[] iSourceFind;
968 iSourceFind = NULL;
969 }
970
971 if (iTestFound)
972 {
973 // Convert to UTF8 if necessary
974 if (cmdline_iswchar)
975 {
976 iTestArgStr1 = new char[256];
977 OSCL_TCHAR* cmd;
978 command_line->get_arg(iTestArgument, cmd);
979 if (cmd)
980 {
981 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iTestArgStr1, 256);
982 }
983
984 iTestArgStr2 = new char[256];
985 command_line->get_arg(iTestArgument + 1, cmd);
986 if (cmd)
987 {
988 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iTestArgStr2, 256);
989 }
990 }
991 else
992 {
993 command_line->get_arg(iTestArgument, iTestArgStr1);
994 command_line->get_arg(iTestArgument + 1, iTestArgStr2);
995 }
996
997 //Pull out 2 integers...
998 if (iTestArgStr1 && '0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9' && iTestArgStr2 && '0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
999 {
1000 int len = oscl_strlen(iTestArgStr1);
1001 switch (len)
1002 {
1003 case 4:
1004 iFirstTest = 0;
1005 if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
1006 {
1007 iFirstTest = iFirstTest + 1000 * (iTestArgStr1[0] - '0');
1008 }
1009
1010 if ('0' <= iTestArgStr1[1] && iTestArgStr1[1] <= '9')
1011 {
1012 iFirstTest = iFirstTest + 100 * (iTestArgStr1[1] - '0');
1013 }
1014
1015 if ('0' <= iTestArgStr1[2] && iTestArgStr1[2] <= '9')
1016 {
1017 iFirstTest = iFirstTest + 10 * (iTestArgStr1[2] - '0');
1018 }
1019
1020 if ('0' <= iTestArgStr1[3] && iTestArgStr1[3] <= '9')
1021 {
1022 iFirstTest = iFirstTest + 1 * (iTestArgStr1[3] - '0');
1023 }
1024 break;
1025
1026 case 3:
1027 iFirstTest = 0;
1028 if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
1029 {
1030 iFirstTest = iFirstTest + 100 * (iTestArgStr1[0] - '0');
1031 }
1032
1033 if ('0' <= iTestArgStr1[1] && iTestArgStr1[1] <= '9')
1034 {
1035 iFirstTest = iFirstTest + 10 * (iTestArgStr1[1] - '0');
1036 }
1037
1038 if ('0' <= iTestArgStr1[2] && iTestArgStr1[2] <= '9')
1039 {
1040 iFirstTest = iFirstTest + 1 * (iTestArgStr1[2] - '0');
1041 }
1042 break;
1043
1044 case 2:
1045 iFirstTest = 0;
1046 if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
1047 {
1048 iFirstTest = iFirstTest + 10 * (iTestArgStr1[0] - '0');
1049 }
1050
1051 if ('0' <= iTestArgStr1[1] && iTestArgStr1[1] <= '9')
1052 {
1053 iFirstTest = iFirstTest + 1 * (iTestArgStr1[1] - '0');
1054 }
1055 break;
1056
1057 case 1:
1058 iFirstTest = 0;
1059 if ('0' <= iTestArgStr1[0] && iTestArgStr1[0] <= '9')
1060 {
1061 iFirstTest = iFirstTest + 1 * (iTestArgStr1[0] - '0');
1062 }
1063 break;
1064
1065 default:
1066 break;
1067 }
1068
1069 len = oscl_strlen(iTestArgStr2);
1070 switch (len)
1071 {
1072 case 4:
1073 iLastTest = 0;
1074 if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
1075 {
1076 iLastTest = iLastTest + 1000 * (iTestArgStr2[0] - '0');
1077 }
1078
1079 if ('0' <= iTestArgStr2[1] && iTestArgStr2[1] <= '9')
1080 {
1081 iLastTest = iLastTest + 100 * (iTestArgStr2[1] - '0');
1082 }
1083
1084 if ('0' <= iTestArgStr2[2] && iTestArgStr2[2] <= '9')
1085 {
1086 iLastTest = iLastTest + 10 * (iTestArgStr2[2] - '0');
1087 }
1088
1089 if ('0' <= iTestArgStr2[3] && iTestArgStr2[3] <= '9')
1090 {
1091 iLastTest = iLastTest + 1 * (iTestArgStr2[3] - '0');
1092 }
1093 break;
1094 case 3:
1095 iLastTest = 0;
1096 if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
1097 {
1098 iLastTest = iLastTest + 100 * (iTestArgStr2[0] - '0');
1099 }
1100
1101 if ('0' <= iTestArgStr2[1] && iTestArgStr2[1] <= '9')
1102 {
1103 iLastTest = iLastTest + 10 * (iTestArgStr2[1] - '0');
1104 }
1105
1106 if ('0' <= iTestArgStr2[2] && iTestArgStr2[2] <= '9')
1107 {
1108 iLastTest = iLastTest + 1 * (iTestArgStr2[2] - '0');
1109 }
1110 break;
1111
1112 case 2:
1113 iLastTest = 0;
1114 if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
1115 {
1116 iLastTest = iLastTest + 10 * (iTestArgStr2[0] - '0');
1117 }
1118
1119 if ('0' <= iTestArgStr2[1] && iTestArgStr2[1] <= '9')
1120 {
1121 iLastTest = iLastTest + 1 * (iTestArgStr2[1] - '0');
1122 }
1123 break;
1124
1125 case 1:
1126 iLastTest = 0;
1127 if ('0' <= iTestArgStr2[0] && iTestArgStr2[0] <= '9')
1128 {
1129 iLastTest = iLastTest + 1 * (iTestArgStr2[0] - '0');
1130 }
1131 break;
1132
1133 default:
1134 break;
1135 }
1136 }
1137 //look for "D", "L" or "S"
1138 else if (iTestArgStr1
1139 && iTestArgStr1[0] == 'L')
1140 {
1141 //local playback tests.
1142 iFirstTest = 0;
1143 iLastTest = 99;
1144 }
1145 else if (iTestArgStr1
1146 && iTestArgStr1[0] == 'D')
1147 {
1148 //download tests
1149 iFirstTest = 100;
1150 iLastTest = 199;
1151 }
1152 else if (iTestArgStr1
1153 && iTestArgStr1[0] == 'S')
1154 {
1155 //streaming tests
1156 iFirstTest = 200;
1157 iLastTest = 299;
1158 }
1159 }
1160
1161 if (cmdline_iswchar)
1162 {
1163 if (iTestArgStr1)
1164 {
1165 delete[] iTestArgStr1;
1166 iTestArgStr1 = NULL;
1167 }
1168
1169 if (iTestArgStr2)
1170 {
1171 delete[] iTestArgStr2;
1172 iTestArgStr2 = NULL;
1173 }
1174
1175 if (iSourceFind)
1176 {
1177 delete[] iSourceFind;
1178 iSourceFind = NULL;
1179 }
1180 }
1181 }
1182
FindCompressed(cmd_line * command_line,bool & aCompV,bool & aCompA,FILE * aFile)1183 void FindCompressed(cmd_line* command_line, bool& aCompV, bool& aCompA, FILE* aFile)
1184 {
1185 //default is uncompressed
1186 aCompV = false;
1187 aCompA = false;
1188
1189 bool cmdline_iswchar = command_line->is_wchar();
1190
1191 int count = command_line->get_count();
1192
1193 // Search for the "-compressed" argument
1194 char *iSourceFind = NULL;
1195 if (cmdline_iswchar)
1196 {
1197 iSourceFind = new char[256];
1198 }
1199
1200 // Go through each argument
1201 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1202 {
1203 // Convert to UTF8 if necessary
1204 if (cmdline_iswchar)
1205 {
1206 OSCL_TCHAR* cmd = NULL;
1207 command_line->get_arg(iTestSearch, cmd);
1208 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1209 }
1210 else
1211 {
1212 iSourceFind = NULL;
1213 command_line->get_arg(iTestSearch, iSourceFind);
1214 }
1215
1216 // Do the string compare
1217 if (oscl_strcmp(iSourceFind, "-help") == 0)
1218 {
1219 fprintf(aFile, "Compressed video and audio output option. Default is OFF for both:\n");
1220 fprintf(aFile, " -compV AND/OR -compA\n");
1221 fprintf(aFile, " For test cases and sinks that support compressed media output (media\n");
1222 fprintf(aFile, " I/O node test cases), the output data files would have compressed\n");
1223 fprintf(aFile, " bitstreams. This also means the player engine would not use a decoder\n");
1224 fprintf(aFile, " node to decode the bitstream from the source node.\n\n");
1225 }
1226 else if (oscl_strcmp(iSourceFind, "-compV") == 0)
1227 {
1228 aCompV = true;
1229 }
1230 else if (oscl_strcmp(iSourceFind, "-compA") == 0)
1231 {
1232 aCompA = true;
1233 }
1234 }
1235
1236 if (cmdline_iswchar)
1237 {
1238 delete[] iSourceFind;
1239 iSourceFind = NULL;
1240 }
1241 }
1242
FindPacketSource(cmd_line * command_line,bool & aFileInput,bool & aBCS,FILE * aFile)1243 void FindPacketSource(cmd_line* command_line, bool& aFileInput, bool& aBCS, FILE* aFile)
1244 {
1245 aFileInput = false;
1246 aBCS = false;
1247
1248 bool cmdline_iswchar = command_line->is_wchar();
1249
1250 int count = command_line->get_count();
1251
1252 char *iSourceFind = NULL;
1253 if (cmdline_iswchar)
1254 {
1255 iSourceFind = new char[256];
1256 }
1257
1258 // Go through each argument
1259 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1260 {
1261 // Convert to UTF8 if necessary
1262 if (cmdline_iswchar)
1263 {
1264 OSCL_TCHAR* cmd = NULL;
1265 command_line->get_arg(iTestSearch, cmd);
1266 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1267 }
1268 else
1269 {
1270 iSourceFind = NULL;
1271 command_line->get_arg(iTestSearch, iSourceFind);
1272 }
1273
1274 // Do the string compare
1275 if (oscl_strcmp(iSourceFind, "-help") == 0)
1276 {
1277 fprintf(aFile, "Packet Source plug-in option. Default is OFF for both:\n");
1278 fprintf(aFile, " -fi\n");
1279 fprintf(aFile, " For file input\n");
1280 fprintf(aFile, " -bcs\n");
1281 fprintf(aFile, " For broadcast socket\n\n");
1282 }
1283 else if (oscl_strcmp(iSourceFind, "-fi") == 0)
1284 {
1285 aFileInput = true;
1286 }
1287 else if (oscl_strcmp(iSourceFind, "-bcs") == 0)
1288 {
1289 aBCS = true;
1290 }
1291 }
1292
1293 if (cmdline_iswchar)
1294 {
1295 delete[] iSourceFind;
1296 iSourceFind = NULL;
1297 }
1298 }
1299
FindMemMgmtRelatedCmdLineParams(cmd_line * command_line,bool & aPrintDetailedMemLeakInfo,FILE * aFile)1300 void FindMemMgmtRelatedCmdLineParams(cmd_line* command_line, bool& aPrintDetailedMemLeakInfo, FILE* aFile)
1301 {
1302 aPrintDetailedMemLeakInfo = false;
1303
1304 bool cmdline_iswchar = command_line->is_wchar();
1305
1306 int count = command_line->get_count();
1307
1308 // Search for the "-logerr"/"-logwarn" argument
1309 char *iSourceFind = NULL;
1310 if (cmdline_iswchar)
1311 {
1312 iSourceFind = new char[256];
1313 }
1314
1315 // Go through each argument
1316 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1317 {
1318 // Convert to UTF8 if necessary
1319 if (cmdline_iswchar)
1320 {
1321 OSCL_TCHAR* cmd = NULL;
1322 command_line->get_arg(iTestSearch, cmd);
1323 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1324 }
1325 else
1326 {
1327 iSourceFind = NULL;
1328 command_line->get_arg(iTestSearch, iSourceFind);
1329 }
1330
1331 // Do the string compare
1332 if (oscl_strcmp(iSourceFind, "-help") == 0)
1333 {
1334 fprintf(aFile, "Printing leak info option. Default is OFF:\n");
1335 fprintf(aFile, " -leakinfo\n");
1336 fprintf(aFile, " If there is a memory leak, prints out the memory leak information\n");
1337 fprintf(aFile, " after all specified test cases have finished running.\n\n");
1338 }
1339 else if (oscl_strcmp(iSourceFind, "-leakinfo") == 0)
1340 {
1341 aPrintDetailedMemLeakInfo = true;
1342 }
1343 }
1344
1345 if (cmdline_iswchar)
1346 {
1347 delete[] iSourceFind;
1348 iSourceFind = NULL;
1349 }
1350 }
1351
FindLoggerNode(cmd_line * command_line,int32 & lognode,FILE * aFile)1352 void FindLoggerNode(cmd_line* command_line, int32& lognode, FILE* aFile)
1353 {
1354 //default is log player engine.
1355 lognode = 0;
1356
1357 bool cmdline_iswchar = command_line->is_wchar();
1358
1359 int count = command_line->get_count();
1360
1361 // Search for the "-logerr"/"-logwarn" argument
1362 char *iSourceFind = NULL;
1363 if (cmdline_iswchar)
1364 {
1365 iSourceFind = new char[256];
1366 }
1367
1368 // Go through each argument
1369 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1370 {
1371 // Convert to UTF8 if necessary
1372 if (cmdline_iswchar)
1373 {
1374 OSCL_TCHAR* cmd = NULL;
1375 command_line->get_arg(iTestSearch, cmd);
1376 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1377 }
1378 else
1379 {
1380 iSourceFind = NULL;
1381 command_line->get_arg(iTestSearch, iSourceFind);
1382 }
1383
1384 // Do the string compare
1385 if (oscl_strcmp(iSourceFind, "-help") == 0)
1386 {
1387 fprintf(aFile, "Log node options. Default is player engine only:\n");
1388 fprintf(aFile, " -logall\n");
1389 fprintf(aFile, " Log everything (log appender at root node)\n");
1390 fprintf(aFile, " -logdatapath\n");
1391 fprintf(aFile, " Log datapath only\n");
1392 fprintf(aFile, " -logclock\n");
1393 fprintf(aFile, " Log clock only\n");
1394 fprintf(aFile, " -logoscl\n");
1395 fprintf(aFile, " Log OSCL only\n");
1396 fprintf(aFile, " -logperf\n");
1397 fprintf(aFile, " Log scheduler performance\n");
1398 fprintf(aFile, " -logperfmin\n");
1399 fprintf(aFile, " Log scheduler performance (minimal)\n");
1400 fprintf(aFile, " -logdatapathsrc\n");
1401 fprintf(aFile, " Log source node datapath only\n\n");
1402 fprintf(aFile, " -logdatapathdec\n");
1403 fprintf(aFile, " Log decoder node datapath only\n\n");
1404 }
1405 else if (oscl_strcmp(iSourceFind, "-logall") == 0)
1406 {
1407 lognode = 1; //log everything
1408 }
1409 else if (oscl_strcmp(iSourceFind, "-logdatapath") == 0)
1410 {
1411 lognode = 2; //datapath only
1412 }
1413 else if (oscl_strcmp(iSourceFind, "-logclock") == 0)
1414 {
1415 lognode = 3; //clock only
1416 }
1417 else if (oscl_strcmp(iSourceFind, "-logoscl") == 0)
1418 {
1419 lognode = 4; //oscl only
1420 }
1421 else if (oscl_strcmp(iSourceFind, "-logperf") == 0)
1422 {
1423 lognode = 5; //scheduler perf logging
1424 }
1425 else if (oscl_strcmp(iSourceFind, "-logdatapathsrc") == 0)
1426 {
1427 lognode = 6; //source node data path only
1428 }
1429 else if (oscl_strcmp(iSourceFind, "-logdatapathdec") == 0)
1430 {
1431 lognode = 7; //source node data path only
1432 }
1433 else if (oscl_strcmp(iSourceFind, "-logsync") == 0)
1434 {
1435 lognode = 8; //media output node datapath only
1436 }
1437 else if (oscl_strcmp(iSourceFind, "-logdiagnostics") == 0)
1438 {
1439 lognode = 9; //diagnostics log only
1440 }
1441 else if (oscl_strcmp(iSourceFind, "-logosclfileio") == 0)
1442 {
1443 lognode = 10; //hds access log only
1444 }
1445 else if (oscl_strcmp(iSourceFind, "-loghds") == 0)
1446 {
1447 lognode = 11; //oscl file-io access log only
1448 }
1449 else if (oscl_strcmp(iSourceFind, "-loghdsandosclfileio") == 0)
1450 {
1451 lognode = 12; //file-io and hds access log only
1452 }
1453 else if (oscl_strcmp(iSourceFind, "-logjupiter") == 0)
1454 {
1455 lognode = 13; //jupiter DRM only
1456 }
1457 else if (oscl_strcmp(iSourceFind, "-logjanus") == 0)
1458 {
1459 lognode = 14; //janus DRM only
1460 }
1461 else if (oscl_strcmp(iSourceFind, "-logperfmin") == 0)
1462 {
1463 lognode = 15; //scheduler perf logging
1464 }
1465 else if (oscl_strcmp(iSourceFind, "-logppb") == 0)
1466 {
1467 lognode = 16; //progressive playback log only
1468 }
1469 else if (oscl_strcmp(iSourceFind, "-logrepos") == 0)
1470 {
1471 lognode = 17; //repos related
1472 }
1473 else if (oscl_strcmp(iSourceFind, "-logsnode") == 0)
1474 {
1475 lognode = 18; //socket node related
1476 }
1477 else if (oscl_strcmp(iSourceFind, "-logshout") == 0)
1478 {
1479 lognode = 19; //shoutcast playback log only
1480 }
1481 }
1482
1483 if (cmdline_iswchar)
1484 {
1485 delete[] iSourceFind;
1486 iSourceFind = NULL;
1487 }
1488 }
1489
FindLogLevel(cmd_line * command_line,int32 & loglevel,FILE * aFile)1490 void FindLogLevel(cmd_line* command_line, int32& loglevel, FILE* aFile)
1491 {
1492 //default is verbose
1493 loglevel = PVLOGMSG_DEBUG;
1494
1495 bool cmdline_iswchar = command_line->is_wchar();
1496
1497 int count = command_line->get_count();
1498
1499 // Search for the "-logerr"/"-logwarn" argument
1500 char *iSourceFind = NULL;
1501 if (cmdline_iswchar)
1502 {
1503 iSourceFind = new char[256];
1504 }
1505
1506 // Go through each argument
1507 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1508 {
1509 // Convert to UTF8 if necessary
1510 if (cmdline_iswchar)
1511 {
1512 OSCL_TCHAR* cmd = NULL;
1513 command_line->get_arg(iTestSearch, cmd);
1514 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1515 }
1516 else
1517 {
1518 iSourceFind = NULL;
1519 command_line->get_arg(iTestSearch, iSourceFind);
1520 }
1521
1522 // Do the string compare
1523 if (oscl_strcmp(iSourceFind, "-help") == 0)
1524 {
1525 fprintf(aFile, "Log level options. Default is debug level:\n");
1526 fprintf(aFile, " -logerr\n");
1527 fprintf(aFile, " Log at error level\n");
1528 fprintf(aFile, " -logwarn\n");
1529 fprintf(aFile, " Log at warning level\n\n");
1530 }
1531 else if (oscl_strcmp(iSourceFind, "-logerr") == 0)
1532 {
1533 loglevel = PVLOGMSG_ERR;
1534 }
1535 else if (oscl_strcmp(iSourceFind, "-logwarn") == 0)
1536 {
1537 loglevel = PVLOGMSG_WARNING;
1538 }
1539 }
1540
1541 if (cmdline_iswchar)
1542 {
1543 delete[] iSourceFind;
1544 iSourceFind = NULL;
1545 }
1546 }
1547
FindLogText(cmd_line * command_line,int32 & logtext,FILE * aFile)1548 void FindLogText(cmd_line* command_line, int32& logtext, FILE* aFile)
1549 {
1550 OSCL_UNUSED_ARG(aFile);
1551 logtext = false;
1552
1553 bool cmdline_iswchar = command_line->is_wchar();
1554
1555 int count = command_line->get_count();
1556
1557 char *iSourceFind = NULL;
1558 if (cmdline_iswchar)
1559 {
1560 iSourceFind = new char[256];
1561 }
1562
1563 // Go through each argument
1564 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1565 {
1566 // Convert to UTF8 if necessary
1567 if (cmdline_iswchar)
1568 {
1569 OSCL_TCHAR* cmd = NULL;
1570 command_line->get_arg(iTestSearch, cmd);
1571 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1572 }
1573 else
1574 {
1575 iSourceFind = NULL;
1576 command_line->get_arg(iTestSearch, iSourceFind);
1577 }
1578
1579 // Do the string compare
1580 if (oscl_strcmp(iSourceFind, "-logfile") == 0)
1581 {
1582 logtext = 1;
1583 }
1584 }
1585
1586 if (cmdline_iswchar)
1587 {
1588 delete[] iSourceFind;
1589 iSourceFind = NULL;
1590 }
1591 }
1592
FindLogMem(cmd_line * command_line,int32 & logmem,FILE * aFile)1593 void FindLogMem(cmd_line* command_line, int32& logmem, FILE* aFile)
1594 {
1595 OSCL_UNUSED_ARG(aFile);
1596 logmem = false;
1597
1598 bool cmdline_iswchar = command_line->is_wchar();
1599
1600 int count = command_line->get_count();
1601
1602 char *iSourceFind = NULL;
1603 if (cmdline_iswchar)
1604 {
1605 iSourceFind = new char[256];
1606 }
1607
1608 // Go through each argument
1609 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1610 {
1611 // Convert to UTF8 if necessary
1612 if (cmdline_iswchar)
1613 {
1614 OSCL_TCHAR* cmd = NULL;
1615 command_line->get_arg(iTestSearch, cmd);
1616 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1617 }
1618 else
1619 {
1620 iSourceFind = NULL;
1621 command_line->get_arg(iTestSearch, iSourceFind);
1622 }
1623
1624 // Do the string compare
1625 if (oscl_strcmp(iSourceFind, "-logmem") == 0)
1626 {
1627 logmem = 1;
1628 }
1629 }
1630
1631 if (cmdline_iswchar)
1632 {
1633 delete[] iSourceFind;
1634 iSourceFind = NULL;
1635 }
1636 }
1637
1638 //Find if -proxy present in cmd line params
FindProxyEnabled(cmd_line * command_line,bool & aProxyEnabled,FILE * aFile)1639 void FindProxyEnabled(cmd_line* command_line, bool& aProxyEnabled, FILE *aFile)
1640 {
1641 //default is not enabled
1642 aProxyEnabled = false;
1643
1644 bool cmdline_iswchar = command_line->is_wchar();
1645
1646 int count = command_line->get_count();
1647
1648 // Search for the "-proxy" argument
1649 char *iSourceFind = NULL;
1650 if (cmdline_iswchar)
1651 {
1652 iSourceFind = new char[256];
1653 }
1654
1655 // Go through each argument
1656 for (int iTestSearch = 0; iTestSearch < count; iTestSearch++)
1657 {
1658 // Convert to UTF8 if necessary
1659 if (cmdline_iswchar)
1660 {
1661 OSCL_TCHAR* cmd = NULL;
1662 command_line->get_arg(iTestSearch, cmd);
1663 oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256);
1664 }
1665 else
1666 {
1667 iSourceFind = NULL;
1668 command_line->get_arg(iTestSearch, iSourceFind);
1669 }
1670
1671 // Do the string compare
1672 if (oscl_strcmp(iSourceFind, "-help") == 0)
1673 {
1674 fprintf(aFile, " proxy enabled ON or OFF, default is OFF\n");
1675 fprintf(aFile, " -proxy\n");
1676 fprintf(aFile, " For test cases where proxy support is reqd\n");
1677 }
1678 else if (oscl_strcmp(iSourceFind, "-proxy") == 0)
1679 {
1680 aProxyEnabled = true;
1681 }
1682 }
1683
1684 if (cmdline_iswchar)
1685 {
1686 delete[] iSourceFind;
1687 iSourceFind = NULL;
1688 }
1689 }
1690 int _local_main(FILE *filehandle, cmd_line* command_line, bool&);
1691
1692
1693 // Entry point for the unit test program
local_main(FILE * filehandle,cmd_line * command_line)1694 int local_main(FILE *filehandle, cmd_line* command_line)
1695 {
1696 //Init Oscl
1697 OsclBase::Init();
1698 OsclErrorTrap::Init();
1699 OsclMem::Init();
1700 OMX_MasterInit();
1701
1702
1703 {
1704 PVSDKInfo aSdkInfo;
1705 PVPlayerInterface::GetSDKInfo(aSdkInfo);
1706 fprintf(filehandle, "SDK Labeled: %s built on %x\n\n", // display SDK info
1707 aSdkInfo.iLabel.get_cstr(), aSdkInfo.iDate);
1708 fprintf(filehandle, "Test Program for pvPlayer engine class.\n");
1709 }
1710
1711
1712 bool oPrintDetailedMemLeakInfo = false;
1713
1714 //Run the test under a trap
1715 int result = 0;
1716 int32 err = 0;
1717
1718 OSCL_TRY(err, result = _local_main(filehandle, command_line, oPrintDetailedMemLeakInfo););
1719
1720 //Show any exception.
1721 if (err != 0)
1722 {
1723 fprintf(file, "Error! Leave %d\n", err);
1724 }
1725 //Cleanup
1726 OMX_MasterDeinit();
1727
1728 #if !(OSCL_BYPASS_MEMMGT)
1729 //Check for memory leaks before cleaning up OsclMem.
1730 OsclAuditCB auditCB;
1731 OsclMemInit(auditCB);
1732 if (auditCB.pAudit)
1733 {
1734 MM_Stats_t *stats = auditCB.pAudit->MM_GetStats("");
1735 if (stats)
1736 {
1737 fprintf(file, "\nMemory Stats:\n");
1738 fprintf(file, " peakNumAllocs %d\n", stats->peakNumAllocs);
1739 fprintf(file, " peakNumBytes %d\n", stats->peakNumBytes);
1740 fprintf(file, " totalNumAllocs %d\n", stats->totalNumAllocs);
1741 fprintf(file, " totalNumBytes %d\n", stats->totalNumBytes);
1742 fprintf(file, " numAllocFails %d\n", stats->numAllocFails);
1743 if (stats->numAllocs)
1744 {
1745 fprintf(file, " ERROR: Memory Leaks! numAllocs %d, numBytes %d\n", stats->numAllocs, stats->numBytes);
1746 }
1747 }
1748 uint32 leaks = auditCB.pAudit->MM_GetNumAllocNodes();
1749 if (leaks != 0)
1750 {
1751 if (oPrintDetailedMemLeakInfo)
1752 {
1753 fprintf(file, "ERROR: %d Memory leaks detected!\n", leaks);
1754 MM_AllocQueryInfo*info = auditCB.pAudit->MM_CreateAllocNodeInfo(leaks);
1755 uint32 leakinfo = auditCB.pAudit->MM_GetAllocNodeInfo(info, leaks, 0);
1756 if (leakinfo != leaks)
1757 {
1758 fprintf(file, "ERROR: Leak info is incomplete.\n");
1759 }
1760 for (uint32 i = 0; i < leakinfo; i++)
1761 {
1762 fprintf(file, "Leak Info:\n");
1763 fprintf(file, " allocNum %d\n", info[i].allocNum);
1764 fprintf(file, " fileName %s\n", info[i].fileName);
1765 fprintf(file, " lineNo %d\n", info[i].lineNo);
1766 fprintf(file, " size %d\n", info[i].size);
1767 uint32 ptrAddr = (uint32)info[i].pMemBlock;
1768 fprintf(file, " pMemBlock 0x%x\n", ptrAddr);
1769 fprintf(file, " tag %s\n", info[i].tag);
1770 }
1771 auditCB.pAudit->MM_ReleaseAllocNodeInfo(info);
1772 }
1773 }
1774 }
1775 #endif
1776 OsclMem::Cleanup();
1777 OsclErrorTrap::Cleanup();
1778 OsclBase::Cleanup();
1779
1780
1781 return result;
1782 }
1783
_local_main(FILE * filehandle,cmd_line * command_line,bool & aPrintDetailedMemLeakInfo)1784 int _local_main(FILE *filehandle, cmd_line *command_line, bool& aPrintDetailedMemLeakInfo)
1785 {
1786 file = filehandle;
1787
1788 CmdLinePopulator<char> *asciiCmdLinePopulator = NULL;
1789 CmdLinePopulator<oscl_wchar> *wcharCmdLinePopulator = NULL;
1790 // Print out the extension for help if no argument
1791 if (command_line->get_count() == 0)
1792 {
1793 fprintf(file, " No command line options available.. goin to read the cmdlineparamsconfigfile.txt(if exists) file to get input \n\n");
1794 //Check if theres input file available to get the params...
1795 oscl_wchar cmdLineParamsConfigFile[255] = {0};
1796 oscl_strncpy(cmdLineParamsConfigFile, SOURCENAME_PREPEND_WSTRING, oscl_strlen(SOURCENAME_PREPEND_WSTRING));
1797 cmdLineParamsConfigFile[oscl_strlen(SOURCENAME_PREPEND_WSTRING)] = '\0';
1798 oscl_strcat(cmdLineParamsConfigFile, _STRLIT("cmdlineparamsconfigfile.txt"));
1799
1800 if (command_line->is_wchar())
1801 {
1802 wcharCmdLinePopulator = new CmdLinePopulator<oscl_wchar>();
1803 wcharCmdLinePopulator->PopulateCmdLine(cmdLineParamsConfigFile, command_line);
1804 }
1805 else
1806 {
1807 asciiCmdLinePopulator = new CmdLinePopulator<char>();
1808 asciiCmdLinePopulator->PopulateCmdLine(cmdLineParamsConfigFile, command_line);
1809 }
1810
1811 if (command_line->get_count() == 0)
1812 {
1813 fprintf(file, " Specify '-help' first to get help information on options\n\n");
1814 }
1815 }
1816
1817 OSCL_HeapString<OsclMemAllocator> filenameinfo;
1818 PVMFFormatType inputformattype ;
1819 int32 iFileFormatType = -1; // unknown file format type
1820
1821 FindMemMgmtRelatedCmdLineParams(command_line, aPrintDetailedMemLeakInfo, filehandle);
1822 FindSourceType(command_line, filenameinfo, inputformattype, iFileFormatType, file); //Added with an additional argument
1823 FindSourceFile(command_line, filenameinfo, inputformattype, file);
1824
1825 int32 firsttest, lasttest;
1826 FindTestRange(command_line, firsttest, lasttest, file);
1827
1828 bool compV;
1829 bool compA;
1830 FindCompressed(command_line, compV, compA, file);
1831
1832 bool fileinput;
1833 bool bcs;
1834 FindPacketSource(command_line, fileinput, bcs, file);
1835
1836 int32 loglevel;
1837 FindLogLevel(command_line, loglevel, file);
1838
1839 int32 lognode;
1840 FindLoggerNode(command_line, lognode, file);
1841
1842 int32 logtext;
1843 FindLogText(command_line, logtext, file);
1844
1845 int32 logmem;
1846 FindLogMem(command_line, logmem, file);
1847
1848 bool proxyenabled;
1849 FindProxyEnabled(command_line, proxyenabled, file);
1850 fprintf(file, " Input file name '%s'\n", filenameinfo.get_cstr());
1851 fprintf(file, " Test case range %d to %d\n", firsttest, lasttest);
1852 fprintf(file, " Compressed output ");
1853 if (compV)
1854 {
1855 fprintf(file, "Video(Yes) ");
1856 }
1857 else
1858 {
1859 fprintf(file, "Video(No) ");
1860 }
1861 if (compA)
1862 {
1863 fprintf(file, "Audio(Yes)\n");
1864 }
1865 else
1866 {
1867 fprintf(file, "Audio(No)\n");
1868 }
1869 fprintf(file, " Log level %d; Log node %d Log Text %d Log Mem %d\n", loglevel, lognode, logtext, logmem);
1870
1871 pvplayer_engine_test_suite *engine_tests = NULL;
1872 engine_tests = new pvplayer_engine_test_suite(filenameinfo.get_str(), inputformattype, firsttest, lasttest, compV, compA, fileinput, bcs, loglevel, lognode, logtext, logmem, iFileFormatType , proxyenabled);
1873 if (engine_tests)
1874 {
1875
1876 //Set the Initial timer
1877
1878 uint32 starttick = OsclTickCount::TickCount();
1879 // Run the engine test
1880 engine_tests->run_test();
1881 uint32 endtick = OsclTickCount::TickCount();
1882
1883 double t1 = OsclTickCount::TicksToMsec(starttick);
1884 double t2 = OsclTickCount::TicksToMsec(endtick);
1885 fprintf(file, "Total Execution time for file %s is : %f seconds", filenameinfo.get_cstr(), (t2 - t1) / 1000);
1886
1887 // Print out the results
1888 text_test_interpreter interp;
1889 _STRING rs = interp.interpretation(engine_tests->last_result());
1890 fprintf(file, rs.c_str());
1891
1892 const test_result the_result = engine_tests->last_result();
1893 delete engine_tests;
1894 engine_tests = NULL;
1895 if (asciiCmdLinePopulator)
1896 {
1897 delete asciiCmdLinePopulator;
1898 asciiCmdLinePopulator = NULL;
1899 }
1900
1901 if (wcharCmdLinePopulator)
1902 {
1903 delete wcharCmdLinePopulator;
1904 wcharCmdLinePopulator = NULL;
1905 }
1906 return (the_result.success_count() != the_result.total_test_count());
1907 }
1908 else
1909 {
1910 if (asciiCmdLinePopulator)
1911 {
1912 delete asciiCmdLinePopulator;
1913 asciiCmdLinePopulator = NULL;
1914 }
1915
1916 if (wcharCmdLinePopulator)
1917 {
1918 delete wcharCmdLinePopulator;
1919 wcharCmdLinePopulator = NULL;
1920 }
1921 fprintf(file, "ERROR! pvplayer_engine_test_suite could not be instantiated.\n");
1922 return 1;
1923 }
1924 }
1925
1926
pvplayer_engine_test_suite(char * aFileName,PVMFFormatType aFileType,int32 aFirstTest,int32 aLastTest,bool aCompV,bool aCompA,bool aFileInput,bool aBCS,int32 aLogLevel,int32 aLogNode,int32 aLogText,int32 aLogMem,int32 aFileFormatType,bool aProxyEnabled)1927 pvplayer_engine_test_suite::pvplayer_engine_test_suite(char *aFileName, PVMFFormatType aFileType, int32 aFirstTest, int32 aLastTest, bool aCompV, bool aCompA, bool aFileInput, bool aBCS, int32 aLogLevel, int32 aLogNode, int32 aLogText, int32 aLogMem, int32 aFileFormatType, bool aProxyEnabled): test_case()
1928 {
1929 adopt_test_case(new pvplayer_engine_test(aFileName, aFileType, aFirstTest, aLastTest, aCompV, aCompA, aFileInput, aBCS, aLogLevel, aLogNode, aLogText, aLogMem, aFileFormatType, aProxyEnabled));
1930 }
1931
1932
1933
pvplayer_engine_test(char * aFileName,PVMFFormatType aFileType,int32 aFirstTest,int32 aLastTest,bool aCompV,bool aCompA,bool aFileInput,bool aBCS,int32 aLogLevel,int32 aLogNode,int32 aLogFile,int32 aLogMem,int32 aFileFormatType,bool aProxyEnabled)1934 pvplayer_engine_test::pvplayer_engine_test(char *aFileName, PVMFFormatType aFileType, int32 aFirstTest, int32 aLastTest,
1935 bool aCompV, bool aCompA, bool aFileInput, bool aBCS, int32 aLogLevel, int32 aLogNode, int32 aLogFile, int32 aLogMem, int32 aFileFormatType, bool aProxyEnabled)
1936 {
1937 iFileName = aFileName;
1938 iFileType = aFileType;
1939 iCurrentTestNumber = 0;
1940 iCurrentTest = NULL;
1941 iFirstTest = aFirstTest;
1942 iLastTest = aLastTest;
1943 iCompressedVideoOutput = aCompV;
1944 iCompressedAudioOutput = aCompA;
1945 iFileInput = aFileInput;
1946 iBCS = aBCS;
1947 iLogLevel = aLogLevel;
1948 iLogNode = aLogNode;
1949 iLogFile = aLogFile;
1950 iLogMem = aLogMem;
1951 iTotalAlloc = 0;
1952 iTotalBytes = 0;
1953 iAllocFails = 0;
1954 iNumAllocs = 0;
1955 iProxyEnabled = aProxyEnabled;
1956 iFileFormatType = aFileFormatType;
1957
1958 #ifdef BUILD_N_ARM
1959 OMX_Init(CONFIG_FILE_NAME);
1960 #endif
1961 }
1962
1963
~pvplayer_engine_test()1964 pvplayer_engine_test::~pvplayer_engine_test()
1965 {
1966 #ifdef BUILD_N_ARM
1967 OMX_Deinit();
1968 #endif
1969 }
1970
1971 //Function to determine invalid test case
ValidateTestCase(int & aCurrentTestCaseNumber)1972 bool pvplayer_engine_test::ValidateTestCase(int& aCurrentTestCaseNumber)
1973 {
1974 int testCaseNumber = 0;
1975 if (iFileFormatType == MP3_ENABLED) //For MP3
1976 {
1977 for (testCaseNumber = 0; testCaseNumber < NO_OF_MP3_INVALID_TESTCASES ; testCaseNumber++)
1978 {
1979 if (aCurrentTestCaseNumber < MP3_INVALID_TEST_ARRAY[testCaseNumber])
1980 return true;//aCurrentTestCaseNumber;
1981 else if (aCurrentTestCaseNumber == MP3_INVALID_TEST_ARRAY[testCaseNumber])
1982 {
1983 if (iLastTest > aCurrentTestCaseNumber)
1984 aCurrentTestCaseNumber++;
1985 else
1986 return false;
1987 }
1988 }
1989 if (aCurrentTestCaseNumber > MP3_INVALID_TEST_ARRAY[NO_OF_MP3_INVALID_TESTCASES -1])
1990 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
1991 }
1992 else if (iFileFormatType == AMR_ENABLED) //For AMR
1993 {
1994 for (testCaseNumber = 0; testCaseNumber < NO_OF_AMR_INVALID_TESTCASES; testCaseNumber++)
1995 {
1996 if (aCurrentTestCaseNumber < AMR_INVALID_TEST_ARRAY[testCaseNumber])
1997 return true; //aCurrentTestCaseNumber;
1998 else if (aCurrentTestCaseNumber == AMR_INVALID_TEST_ARRAY[testCaseNumber])
1999 {
2000 if (iLastTest > aCurrentTestCaseNumber)
2001 aCurrentTestCaseNumber++;
2002 else
2003 return false;
2004 }
2005 }
2006 if (aCurrentTestCaseNumber > AMR_INVALID_TEST_ARRAY[NO_OF_AMR_INVALID_TESTCASES -1])
2007 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
2008 }
2009 else if (iFileFormatType == MP4_ENABLED) // MP4 Enabled
2010 {
2011 for (testCaseNumber = 0; testCaseNumber < NO_OF_3GP_OR_MP4_INVALID_TESTCASES; testCaseNumber++)
2012 {
2013 if (aCurrentTestCaseNumber < FILE_3GP_OR_MP4_INVALID_TEST_ARRAY[testCaseNumber])
2014 return true; //aCurrentTestCaseNumber;
2015 else if (aCurrentTestCaseNumber == FILE_3GP_OR_MP4_INVALID_TEST_ARRAY[testCaseNumber])
2016 {
2017 if (iLastTest > aCurrentTestCaseNumber)
2018 aCurrentTestCaseNumber++;
2019 else
2020 return false;
2021 }
2022 }
2023 if (aCurrentTestCaseNumber > FILE_3GP_OR_MP4_INVALID_TEST_ARRAY[NO_OF_3GP_OR_MP4_INVALID_TESTCASES -1])
2024 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
2025 }
2026 else if (iFileFormatType == THREE_GP_ENABLED)// 3GP Enabled
2027 {
2028 for (testCaseNumber = 0; testCaseNumber < NO_OF_3GP_OR_MP4_INVALID_TESTCASES; testCaseNumber++)
2029 {
2030 if (aCurrentTestCaseNumber < FILE_3GP_OR_MP4_INVALID_TEST_ARRAY[testCaseNumber])
2031 return true;//aCurrentTestCaseNumber;
2032 else if (aCurrentTestCaseNumber == FILE_3GP_OR_MP4_INVALID_TEST_ARRAY[testCaseNumber])
2033 {
2034 if (iLastTest > aCurrentTestCaseNumber)
2035 aCurrentTestCaseNumber++;
2036 else
2037 return false;
2038 }
2039 }
2040 if (aCurrentTestCaseNumber > FILE_3GP_OR_MP4_INVALID_TEST_ARRAY[NO_OF_3GP_OR_MP4_INVALID_TESTCASES -1])
2041 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
2042 }
2043 else if (iFileFormatType == ASF_ENABLED) //ASF Enabled
2044 {
2045 for (testCaseNumber = 0; testCaseNumber < NO_OF_ASF_INVALID_TESTCASES ; testCaseNumber++)
2046 {
2047 if (aCurrentTestCaseNumber < ASF_INVALID_TEST_ARRAY[testCaseNumber])
2048 return true; //aCurrentTestCaseNumber;
2049 else if (aCurrentTestCaseNumber == ASF_INVALID_TEST_ARRAY[testCaseNumber])
2050 {
2051 if (iLastTest > aCurrentTestCaseNumber)
2052 aCurrentTestCaseNumber++;
2053 else
2054 {
2055 return false;
2056 }
2057 }
2058 }
2059 if (aCurrentTestCaseNumber > ASF_INVALID_TEST_ARRAY[NO_OF_ASF_INVALID_TESTCASES -1])
2060 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
2061 }
2062 else if (iFileFormatType == WMV_ENABLED) //WMV Enabled
2063 {
2064 for (testCaseNumber = 0; testCaseNumber < NO_OF_WMV_INVALID_TESTCASES; testCaseNumber++)
2065 {
2066 if (aCurrentTestCaseNumber < WMV_INVALID_TEST_ARRAY[testCaseNumber])
2067 return true; //aCurrentTestCaseNumber;
2068 else if (aCurrentTestCaseNumber == WMV_INVALID_TEST_ARRAY[testCaseNumber])
2069 {
2070 if (iLastTest > aCurrentTestCaseNumber)
2071 aCurrentTestCaseNumber++;
2072 else
2073 return false;
2074 }
2075 }
2076 if (aCurrentTestCaseNumber > WMV_INVALID_TEST_ARRAY[NO_OF_WMV_INVALID_TESTCASES-1])
2077 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
2078 }
2079 else if (iFileFormatType == WMA_ENABLED) //WMA Enabled
2080 {
2081 for (testCaseNumber = 0; testCaseNumber < NO_OF_WMA_INVALID_TESTCASES ; testCaseNumber++)
2082 {
2083 if (aCurrentTestCaseNumber < WMA_INVALID_TEST_ARRAY[testCaseNumber])
2084 return true; //aCurrentTestCaseNumber;
2085 else if (aCurrentTestCaseNumber == WMA_INVALID_TEST_ARRAY[testCaseNumber])
2086 {
2087 if (iLastTest > aCurrentTestCaseNumber)
2088 aCurrentTestCaseNumber++;
2089 else
2090 return false;
2091 }
2092 }
2093 if (aCurrentTestCaseNumber > WMA_INVALID_TEST_ARRAY[NO_OF_WMA_INVALID_TESTCASES -1])
2094 return true; //aCurrentTestCaseNumber ; //Sending when CurrentCount is more than all the element of array
2095 }
2096 else if (iFileFormatType == WAV_ENABLED) //WAV Enabled
2097 {
2098 for (testCaseNumber = 0; testCaseNumber < NO_OF_WAV_INVALID_TESTCASES ; testCaseNumber++)
2099 {
2100 if (aCurrentTestCaseNumber < WAV_INVALID_TEST_ARRAY[testCaseNumber])
2101 return true; //aCurrentTestCaseNumber;
2102 else if (aCurrentTestCaseNumber == WAV_INVALID_TEST_ARRAY[testCaseNumber])
2103 {
2104 if (iLastTest > aCurrentTestCaseNumber)
2105 aCurrentTestCaseNumber++;
2106 else
2107 return false;
2108 }
2109 }
2110 if (aCurrentTestCaseNumber > WAV_INVALID_TEST_ARRAY[NO_OF_WAV_INVALID_TESTCASES -1])
2111 return true;//Sending when CurrentCount is more than all the element of array
2112 }
2113 else if (iFileFormatType == RM_ENABLED) //RM Enabled
2114 {
2115 for (testCaseNumber = 0; testCaseNumber < NO_OF_REAL_INVALID_TESTCASES ; testCaseNumber++)
2116 {
2117 if (aCurrentTestCaseNumber < REAL_INVALID_TEST_ARRAY[testCaseNumber])
2118 return true; //aCurrentTestCaseNumber;
2119 else if (aCurrentTestCaseNumber == REAL_INVALID_TEST_ARRAY[testCaseNumber])
2120 {
2121 if (iLastTest > aCurrentTestCaseNumber)
2122 aCurrentTestCaseNumber++;
2123 else
2124 return false;
2125 }
2126 }
2127 if (aCurrentTestCaseNumber > REAL_INVALID_TEST_ARRAY[NO_OF_REAL_INVALID_TESTCASES -1])
2128 return true;//Sending when CurrentCount is more than all the element of array
2129 }
2130 else if (iFileFormatType == AAC_ENABLED) //For AAC
2131 {
2132 for (testCaseNumber = 0; testCaseNumber < NO_OF_AAC_INVALID_TESTCASES; testCaseNumber++)
2133 {
2134 if (aCurrentTestCaseNumber < AAC_INVALID_TEST_ARRAY[testCaseNumber])
2135 return true; //aCurrentTestCaseNumber;
2136 else if (aCurrentTestCaseNumber == AAC_INVALID_TEST_ARRAY[testCaseNumber])
2137 {
2138 if (iLastTest > aCurrentTestCaseNumber)
2139 aCurrentTestCaseNumber++;
2140 else
2141 return false;
2142 }
2143 }
2144 if (aCurrentTestCaseNumber > AAC_INVALID_TEST_ARRAY[NO_OF_AAC_INVALID_TESTCASES-1])
2145 return true;//Sending when CurrentCount is more than all the element of array
2146 }
2147 else
2148 {
2149 return true;//aCurrentTestCaseNumber;
2150 }
2151
2152 return false;
2153 }
2154
TestCompleted(test_case & tc)2155 void pvplayer_engine_test::TestCompleted(test_case &tc)
2156 {
2157 // Print out the result for this test case
2158 const test_result the_result = tc.last_result();
2159 fprintf(file, "Results for Test Case %d:\n", iCurrentTestNumber);
2160 fprintf(file, " Successes %d, Failures %d\n"
2161 , the_result.success_count() - iTotalSuccess, the_result.failures().size() - iTotalFail);
2162 fflush(file);
2163 iTotalSuccess = the_result.success_count();
2164 iTotalFail = the_result.failures().size();
2165 iTotalError = the_result.errors().size();
2166
2167 // Go to next test
2168 ++iCurrentTestNumber;
2169 /*Skipping the test cases based on File type */
2170
2171 if (!ValidateTestCase(iCurrentTestNumber))
2172 {
2173 if (iLastTest == iCurrentTestNumber) //Dealing with when -test a b ,b is invalid test case
2174 {
2175 iCurrentTestNumber = BeyondLastTest;
2176 }
2177 }
2178 // Stop the scheduler
2179 OsclExecScheduler *sched = OsclExecScheduler::Current();
2180 if (sched)
2181 {
2182 sched->StopScheduler();
2183 }
2184 }
2185
2186
test()2187 void pvplayer_engine_test::test()
2188 {
2189 bool AtleastOneExecuted = false;
2190 // Specify the starting test case
2191 iCurrentTestNumber = iFirstTest;
2192 iTotalSuccess = iTotalFail = iTotalError = 0;
2193 if (!ValidateTestCase(iCurrentTestNumber))
2194 { //Dealing with when -test a b ,a is invalid test case and a==b
2195 if (iLastTest <= iCurrentTestNumber)
2196 {
2197 iCurrentTestNumber = BeyondLastTest;
2198 }
2199 }
2200 else //Atleast one test case is executed
2201 {
2202 AtleastOneExecuted = true;
2203 }
2204
2205 while (iCurrentTestNumber <= iLastTest || iCurrentTestNumber < BeyondLastTest || AtleastOneExecuted)
2206 {
2207 if (iCurrentTest)
2208 {
2209 delete iCurrentTest;
2210 iCurrentTest = NULL;
2211
2212 // Shutdown PVLogger and scheduler before checking mem stats
2213 OsclScheduler::Cleanup();
2214 PVLogger::Cleanup();
2215 #if !(OSCL_BYPASS_MEMMGT)
2216 // Print out the memory usage results for this test case
2217 OsclAuditCB auditCB;
2218 OsclMemInit(auditCB);
2219 if (auditCB.pAudit)
2220 {
2221 MM_Stats_t* stats = auditCB.pAudit->MM_GetStats("");
2222 if (stats)
2223 {
2224 fprintf(file, " Mem stats: TotalAllocs(%d), TotalBytes(%d),\n AllocFailures(%d), AllocLeak(%d)\n",
2225 stats->totalNumAllocs - iTotalAlloc, stats->totalNumBytes - iTotalBytes, stats->numAllocFails - iAllocFails, stats->numAllocs - iNumAllocs);
2226 }
2227 else
2228 {
2229 fprintf(file, "Retrieving memory statistics after running test case failed! Memory statistics result is not available.\n");
2230 }
2231 }
2232 else
2233 {
2234 fprintf(file, "Memory audit not available! Memory statistics result is not available.\n");
2235 }
2236 #endif
2237 }
2238
2239 #if !(OSCL_BYPASS_MEMMGT)
2240 // Obtain the current mem stats before running the test case
2241 OsclAuditCB auditCB;
2242 OsclMemInit(auditCB);
2243 if (auditCB.pAudit)
2244 {
2245 MM_Stats_t* stats = auditCB.pAudit->MM_GetStats("");
2246 if (stats)
2247 {
2248 iTotalAlloc = stats->totalNumAllocs;
2249 iTotalBytes = stats->totalNumBytes;
2250 iAllocFails = stats->numAllocFails;
2251 iNumAllocs = stats->numAllocs;
2252 }
2253 else
2254 {
2255 fprintf(file, "Retrieving memory statistics before running test case failed! Memory statistics result would be invalid.\n");
2256 }
2257 }
2258 else
2259 {
2260 fprintf(file, "Memory audit not available! Memory statistics result would be invalid.\n");
2261 }
2262 #endif
2263
2264 bool setupLoggerScheduler = false;
2265
2266 // skip IF2 tests which are no longer supported
2267 if (iCurrentTestNumber == AMRIF2FileOpenPlayStopTest)
2268 {
2269 iCurrentTestNumber++;
2270 }
2271 if (iCurrentTestNumber == AMRIF2FilePlayStopPlayStopTest)
2272 {
2273 iCurrentTestNumber++;
2274 }
2275 //skip the placeholders and empty ranges.
2276 if (iCurrentTestNumber == LastLocalTest)
2277 {
2278 iCurrentTestNumber = FirstDownloadTest;
2279 }
2280 if (iCurrentTestNumber == FirstDownloadTest)
2281 {
2282 iCurrentTestNumber++;
2283 }
2284 if (iCurrentTestNumber == LastDownloadTest)
2285 {
2286 iCurrentTestNumber = FirstStreamingTest;
2287 }
2288 if (iCurrentTestNumber == FirstStreamingTest)
2289 {
2290 iCurrentTestNumber++;
2291 }
2292 if (iCurrentTestNumber == LastStreamingTest)
2293 {
2294 iCurrentTestNumber = BeyondLastTest;
2295 }
2296
2297 //stop at last test of selected range.
2298 if (iCurrentTestNumber > iLastTest)
2299 {
2300 iCurrentTestNumber = BeyondLastTest;
2301 }
2302 else
2303 {
2304 fprintf(file, "\nStarting Test %d: ", iCurrentTestNumber);
2305 fflush(file);
2306 SetupLoggerScheduler();
2307 setupLoggerScheduler = true;
2308 }
2309
2310 // Setup the standard test case parameters based on current unit test settings
2311 PVPlayerAsyncTestParam testparam;
2312 testparam.iObserver = this;
2313 testparam.iTestCase = this;
2314 testparam.iTestMsgOutputFile = file;
2315 testparam.iFileName = iFileName;
2316 testparam.iFileType = iFileType;
2317 testparam.iCompressedVideo = iCompressedVideoOutput;
2318 testparam.iCompressedAudio = iCompressedAudioOutput;
2319 testparam.iFileInput = iFileInput;
2320 testparam.iBCS = iBCS;
2321 testparam.iCurrentTestNumber = iCurrentTestNumber;
2322 testparam.iProxyEnabled = iProxyEnabled;
2323
2324 switch (iCurrentTestNumber)
2325 {
2326 case NewDeleteTest:
2327 iCurrentTest = new pvplayer_async_test_newdelete(testparam);
2328 break;
2329
2330 case OpenPlayStopResetTest:
2331 iCurrentTest = new pvplayer_async_test_openplaystopreset(testparam);
2332 break;
2333
2334 case OpenPlayStopResetCPMTest:
2335 iCurrentTest = new pvplayer_async_test_cpmopenplaystopreset(testparam);
2336 break;
2337
2338 case OpenPlayStopResetCPMRecognizeTest:
2339 iCurrentTest = new pvplayer_async_test_cpmopenplaystopreset(testparam, true);
2340 break;
2341
2342 case CPM_DLA_OMA1PASSTRHU_OpenFailAuthPlayStopResetTest:
2343 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
2344 iCurrentTest = new pvplayer_async_test_cpmdlapassthru(testparam,
2345 PVMF_MIME_YUV420,
2346 PVMF_MIME_PCM16,
2347 iCurrentTestNumber,
2348 false,
2349 false,
2350 true,
2351 OMA1_DLA_FAIL,
2352 false);
2353 ((pvplayer_async_test_cpmdlapassthru*)iCurrentTest)->setProtocolRollOverMode();
2354 #else
2355 fprintf(file, "CPM OMA1 DLA PassThru tests not enabled\n");
2356 #endif
2357 break;
2358
2359 case CPM_DLA_OMA1PASSTRHU_OpenPlayStopResetTest:
2360 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
2361 iCurrentTest = new pvplayer_async_test_cpmdlapassthru(testparam,
2362 PVMF_MIME_YUV420,
2363 PVMF_MIME_PCM16,
2364 iCurrentTestNumber,
2365 false,
2366 false,
2367 true,
2368 OMA1_DLA_NORMAL,
2369 false);
2370 ((pvplayer_async_test_cpmdlapassthru*)iCurrentTest)->setProtocolRollOverMode();
2371 #else
2372 fprintf(file, "CPM OMA1 DLA PassThru tests not enabled\n");
2373 #endif
2374 break;
2375
2376 case CPM_DLA_OMA1PASSTRHU_UnknownContentOpenPlayStopResetTest:
2377 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
2378 iCurrentTest = new pvplayer_async_test_cpmdlapassthru(testparam,
2379 PVMF_MIME_YUV420,
2380 PVMF_MIME_PCM16,
2381 iCurrentTestNumber,
2382 false,
2383 false,
2384 true,
2385 OMA1_DLA_UNKNOWN_CPM_CONTENTTYPE,
2386 false);
2387 ((pvplayer_async_test_cpmdlapassthru*)iCurrentTest)->setProtocolRollOverMode();
2388 #else
2389 fprintf(file, "CPM OMA1 DLA PassThru tests not enabled\n");
2390 #endif
2391 break;
2392
2393 case CPM_DLA_OMA1PASSTRHU_CancelAcquireLicenseTooLate_CancelFails:
2394 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
2395 iCurrentTest = new pvplayer_async_test_cpmdlapassthru(testparam,
2396 PVMF_MIME_YUV420,
2397 PVMF_MIME_PCM16,
2398 iCurrentTestNumber,
2399 false,
2400 false,
2401 true,
2402 OMA1_DLA_CANCEL_ACQUIRE_LICENSE_FAILS,
2403 true);
2404 ((pvplayer_async_test_cpmdlapassthru*)iCurrentTest)->setProtocolRollOverMode();
2405 #else
2406 fprintf(file, "CPM OMA1 DLA PassThru tests not enabled\n");
2407 #endif
2408 break;
2409
2410 case CPM_DLA_OMA1PASSTRHU_CancelAcquireLicense_CancelSucceeds:
2411 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
2412 iCurrentTest = new pvplayer_async_test_cpmdlapassthru(testparam,
2413 PVMF_MIME_YUV420,
2414 PVMF_MIME_PCM16,
2415 iCurrentTestNumber,
2416 false,
2417 false,
2418 true,
2419 OMA1_DLA_CANCEL_ACQUIRE_LICENSE_SUCCEEDS,
2420 true);
2421 ((pvplayer_async_test_cpmdlapassthru*)iCurrentTest)->setProtocolRollOverMode();
2422 #else
2423 fprintf(file, "CPM OMA1 DLA PassThru tests not enabled\n");
2424 #endif
2425 break;
2426
2427 case CPM_DLA_OMA1PASSTRHU_ContentNotSupported:
2428 #if RUN_CPMOMA1_DLAPASSTHRU_TESTCASES
2429 iCurrentTest = new pvplayer_async_test_cpmdlapassthru(testparam,
2430 PVMF_MIME_YUV420,
2431 PVMF_MIME_PCM16,
2432 iCurrentTestNumber,
2433 false,
2434 false,
2435 true,
2436 OMA1_DLA_CONTENT_NOTSUPPORTED,
2437 false);
2438 ((pvplayer_async_test_cpmdlapassthru*)iCurrentTest)->setProtocolRollOverMode();
2439 #else
2440 fprintf(file, "CPM OMA1 DLA PassThru tests not enabled\n");
2441 #endif
2442 break;
2443
2444
2445 case MetaDataTest:
2446 iCurrentTest = new pvplayer_async_test_metadata(testparam);
2447 break;
2448
2449 case TimingTest:
2450 iCurrentTest = new pvplayer_async_test_timing(testparam);
2451 break;
2452
2453 case InvalidStateTest:
2454 iCurrentTest = new pvplayer_async_test_invalidstate(testparam);
2455 break;
2456
2457 case PreparedStopTest:
2458 iCurrentTest = new pvplayer_async_test_preparedstop(testparam);
2459 break;
2460
2461 case VideoOnlyPlay7Seconds:
2462 iCurrentTest = new pvplayer_async_test_videoonlyplay7seconds(testparam);
2463 break;
2464
2465 case Play5StopPlay10StopReset:
2466 iCurrentTest = new pvplayer_async_test_play5stopplay10stopreset(testparam);
2467 break;
2468
2469 case PauseResume:
2470 iCurrentTest = new pvplayer_async_test_pauseresume(testparam);
2471 break;
2472
2473 case PlayPauseStop:
2474 iCurrentTest = new pvplayer_async_test_playpausestop(testparam);
2475 break;
2476
2477 case OutsideNodeForVideoSink:
2478 iCurrentTest = new pvplayer_async_test_outsidenodeforvideosink(testparam);
2479 break;
2480
2481 case GetPlayerState:
2482 iCurrentTest = new pvplayer_async_test_getplayerstate(testparam);
2483 break;
2484
2485 case GetCurrentPosition:
2486 iCurrentTest = new pvplayer_async_test_getcurrentposition(testparam);
2487 break;
2488
2489 case PlaySetStopPosition:
2490 iCurrentTest = new pvplayer_async_test_playsetstopposition(testparam);
2491 break;
2492
2493 case PlaySetStopPositionVidFrameNum:
2494 iCurrentTest = new pvplayer_async_test_playsetstoppositionvidframenum(testparam);
2495 break;
2496
2497 case SetStartPositionPlayStop:
2498 {
2499 iCurrentTest = new pvplayer_async_test_setstartpositionplaystop(testparam);
2500 ((pvplayer_async_test_setstartpositionplaystop*)iCurrentTest)->setMultipleSeekMode(1);
2501 break;
2502 }
2503
2504 case SetPlayRangePlay:
2505 iCurrentTest = new pvplayer_async_test_setplayrangeplay(testparam);
2506 break;
2507
2508 case SetPlayRangeVidFrameNumPlay:
2509 iCurrentTest = new pvplayer_async_test_setplayrangevidframenumplay(testparam);
2510 break;
2511
2512 case PlaySetPlayRangeStop:
2513 iCurrentTest = new pvplayer_async_test_playsetplayrangestop(testparam);
2514 break;
2515
2516 case PlaySetPlayRangeVidFrameNumStop:
2517 iCurrentTest = new pvplayer_async_test_playsetplayrangevidframenumstop(testparam);
2518 break;
2519
2520 case TrackLevelInfoTest:
2521 iCurrentTest = new pvplayer_async_test_tracklevelinfo(testparam);
2522 break;
2523
2524 case SetPlaybackRate2X:
2525 iCurrentTest = new pvplayer_async_test_setplaybackrate2X(testparam);
2526 break;
2527
2528 case SetPlaybackRateFifth:
2529 iCurrentTest = new pvplayer_async_test_setplaybackratefifth(testparam);
2530 break;
2531
2532 case CapConfigInterfaceTest:
2533 iCurrentTest = new pvplayer_async_test_capconfigiftest(testparam);
2534 break;
2535
2536 case QueuedCommandsTest:
2537 iCurrentTest = new pvplayer_async_test_queuedcommands(testparam);
2538 break;
2539
2540 case LoopingTest:
2541 iCurrentTest = new pvplayer_async_test_looping(testparam);
2542 break;
2543
2544 case WaitForEOSTest:
2545 iCurrentTest = new pvplayer_async_test_waitforeos(testparam);
2546 break;
2547
2548 case MultiplePauseResumeTest:
2549 iCurrentTest = new pvplayer_async_test_multipauseresume(testparam);
2550 break;
2551
2552 case MultipleRepositionTest:
2553 iCurrentTest = new pvplayer_async_test_multireposition(testparam);
2554 break;
2555
2556 case MultiplePauseSeekResumeTest:
2557 {
2558 iCurrentTest = new pvplayer_async_test_multipauseseekresume(testparam);
2559 ((pvplayer_async_test_multipauseseekresume*)iCurrentTest)->setMultiplePauseMode(2);
2560 break;
2561 }
2562
2563 case MultipleSetStartPositionPlayStopTest:
2564 {
2565 iCurrentTest = new pvplayer_async_test_setstartpositionplaystop(testparam);
2566 ((pvplayer_async_test_setstartpositionplaystop*)iCurrentTest)->setMultipleSeekMode(2);
2567 break;
2568 }
2569
2570 case MediaIONodeOpenPlayStopTest:
2571 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2572 break;
2573
2574 case MediaIONodePlayStopPlayTest:
2575 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2576 break;
2577
2578 case MediaIONodePauseResumeTest:
2579 iCurrentTest = new pvplayer_async_test_mediaionode_pauseresume(testparam);
2580 break;
2581
2582 case MediaIONodePlaySetPlaybackRangeTest:
2583 iCurrentTest = new pvplayer_async_test_mediaionode_playsetplaybackrange(testparam);
2584 break;
2585
2586 case MediaIONodeSetPlaybackRate3XTest:
2587 iCurrentTest = new pvplayer_async_test_mediaionode_3Xplayrate(testparam);
2588 break;
2589
2590 case MediaIONodeSetPlaybackRateHalfTest:
2591 iCurrentTest = new pvplayer_async_test_mediaionode_halfplayrate(testparam);
2592 break;
2593
2594 case MediaIONodeLoopingTest:
2595 iCurrentTest = new pvplayer_async_test_mediaionode_looping(testparam);
2596 break;
2597
2598 case MediaIONodeWaitForEOSTest:
2599 iCurrentTest = new pvplayer_async_test_mediaionode_waitforeos(testparam);
2600 break;
2601
2602 case MediaIOMultiplePauseResumeTest:
2603 iCurrentTest = new pvplayer_async_test_mediaionode_multipauseresume(testparam);
2604 break;
2605
2606 case MediaIOMultipleRepositionTest:
2607 iCurrentTest = new pvplayer_async_test_mediaionode_multireposition(testparam);
2608 break;
2609
2610 case MediaIORepositionConfigTest:
2611 iCurrentTest = new pvplayer_async_test_mediaionode_repositionconfig(testparam);
2612 break;
2613
2614 case MediaIONodeEOSLoopingTest:
2615 iCurrentTest = new pvplayer_async_test_mediaionode_eoslooping(testparam);
2616 break;
2617
2618 case MediaIONodeRepositionDuringPreparedTest:
2619 iCurrentTest = new pvplayer_async_test_mediaionode_repositionduringprepared(testparam);
2620 break;
2621
2622 case MediaIONodePlaySetPlaybackRangeStopPlayTest:
2623 iCurrentTest = new pvplayer_async_test_mediaionode_playsetplaybackrangestopplay(testparam);
2624 break;
2625
2626 case MediaIONodePlayStopSetPlaybackRangePlayStopTest:
2627 iCurrentTest = new pvplayer_async_test_mediaionode_playstopsetplaybackrangeplaystop(testparam);
2628 break;
2629
2630 case MediaIONodeSetPlaybackRangeNearEndStartTest:
2631 iCurrentTest = new pvplayer_async_test_mediaionode_setplaybackrangenearendplay(testparam);
2632 break;
2633
2634 case MediaIONodePlayRepositionNearEndOfClipTest:
2635 iCurrentTest = new pvplayer_async_test_mediaionode_playrepositionnearendofclip(testparam);
2636 break;
2637
2638 case MediaIONodeForwardStepTest:
2639 iCurrentTest = new pvplayer_async_test_mediaionode_forwardstep(testparam, false);
2640 break;
2641
2642 case MediaIONodeForwardStepActiveAudioTest:
2643 iCurrentTest = new pvplayer_async_test_mediaionode_forwardstep(testparam, true);
2644 break;
2645
2646 case MediaIONodeForwardStepToEOSTest:
2647 iCurrentTest = new pvplayer_async_test_mediaionode_forwardsteptoeos(testparam);
2648 break;
2649
2650 case MediaIONodeBackwardTest:
2651 #ifndef ONLY_3GPP_STREAMING_FORMAT
2652 iCurrentTest = new pvplayer_async_test_mediaionode_backwardplayback(testparam);
2653 #else
2654 fprintf(file, "Backward playback tests not enabled\n");
2655 #endif
2656 break;
2657
2658 case MediaIONodeBackwardForwardTest:
2659 #ifndef ONLY_3GPP_STREAMING_FORMAT
2660 iCurrentTest = new pvplayer_async_test_mediaionode_backwardforwardplayback(testparam);
2661 #else
2662 fprintf(file, "Backward/Forward playback tests not enabled\n");
2663 #endif
2664 break;
2665
2666 case MediaIONodePauseNearEOSBackwardResumeTest:
2667 #ifndef ONLY_3GPP_STREAMING_FORMAT
2668 iCurrentTest = new pvplayer_async_test_mediaionode_pauseneareosbackwardresume(testparam);
2669 #else
2670 fprintf(file, "Backward/Forward playback tests not enabled\n");
2671 #endif
2672 break;
2673
2674 case MediaIONodeMultiplePauseSetPlaybackRateResumeTest:
2675 #ifndef ONLY_3GPP_STREAMING_FORMAT
2676 iCurrentTest = new pvplayer_async_test_mediaionode_multiplepausesetplaybackrateresume(testparam);
2677 #else
2678 fprintf(file, "Backward/Forward playback tests not enabled\n");
2679 #endif
2680 break;
2681
2682 case MediaIONodeBackwardNearEOSForwardNearStartTest:
2683 #ifndef ONLY_3GPP_STREAMING_FORMAT
2684 iCurrentTest = new pvplayer_async_test_mediaionode_backwardneareosforwardnearbos(testparam);
2685 #else
2686 fprintf(file, "Backward/Forward playback tests not enabled\n");
2687 #endif
2688 break;
2689
2690 case MP4M4VAMRFileOpenPlayStopTest:
2691 #if RUN_MP4FILE_TESTCASES
2692 testparam.iFileName = LOCAL_TEST_FILE_MP4_M4V_AMR;
2693 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2694 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2695 fprintf(file, "MP4 M4v/AMR ");
2696 #else
2697 fprintf(file, "MP4 file tests not enabled\n");
2698 #endif
2699 break;
2700
2701 case MP4M4VAMRFilePlayStopPlayStopTest:
2702 #if RUN_MP4FILE_TESTCASES
2703 testparam.iFileName = LOCAL_TEST_FILE_MP4_M4V_AMR;
2704 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2705 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2706 fprintf(file, "MP4 M4v/AMR ");
2707 #else
2708 fprintf(file, "MP4 file tests not enabled\n");
2709 #endif
2710 break;
2711
2712 case MP4H263AMRFileOpenPlayStopTest:
2713 #if RUN_MP4FILE_TESTCASES
2714 testparam.iFileName = LOCAL_TEST_FILE_MP4_H263_AMR;
2715 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2716 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2717 fprintf(file, "MP4 H.263/AMR ");
2718 #else
2719 fprintf(file, "MP4 file tests not enabled\n");
2720 #endif
2721 break;
2722
2723 case MP4H263AMRFilePlayStopPlayStopTest:
2724 #if RUN_MP4FILE_TESTCASES
2725 testparam.iFileName = LOCAL_TEST_FILE_MP4_H263_AMR;
2726 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2727 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2728 fprintf(file, "MP4 H.263/AMR ");
2729 #else
2730 fprintf(file, "MP4 file tests not enabled\n");
2731 #endif
2732 break;
2733
2734 case MP4AVCAMRFileOpenPlayStopTest:
2735 #if RUN_MP4FILE_TESTCASES
2736 testparam.iFileName = LOCAL_TEST_FILE_MP4_AVC_AMR;
2737 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2738 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2739 fprintf(file, "MP4 AVC/AMR ");
2740 #else
2741 fprintf(file, "MP4 file tests not enabled\n");
2742 #endif
2743 break;
2744
2745 case MP4AVCAMRFilePlayStopPlayStopTest:
2746 #if RUN_MP4FILE_TESTCASES
2747 testparam.iFileName = LOCAL_TEST_FILE_MP4_AVC_AMR;
2748 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2749 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2750 fprintf(file, "MP4 AVC/AMR ");
2751 #else
2752 fprintf(file, "MP4 file tests not enabled\n");
2753 #endif
2754 break;
2755
2756 case MP4AMRFileOpenPlayStopTest:
2757 #if RUN_MP4FILE_TESTCASES
2758 testparam.iFileName = LOCAL_TEST_FILE_MP4_AMR;
2759 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2760 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2761 fprintf(file, "MP4 AMR-only ");
2762 #else
2763 fprintf(file, "MP4 file tests not enabled\n");
2764 #endif
2765 break;
2766
2767 case MP4AMRFilePlayStopPlayStopTest:
2768 #if RUN_MP4FILE_TESTCASES
2769 testparam.iFileName = LOCAL_TEST_FILE_MP4_AMR;
2770 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2771 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2772 fprintf(file, "MP4 AMR-only ");
2773 #else
2774 fprintf(file, "MP4 file tests not enabled\n");
2775 #endif
2776 break;
2777
2778 case MP4AACFileOpenPlayStopTest:
2779 #if RUN_MP4FILE_TESTCASES
2780 testparam.iFileName = LOCAL_TEST_FILE_MP4_AAC;
2781 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2782 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2783 fprintf(file, "MP4 AAC-only ");
2784 #else
2785 fprintf(file, "MP4 file tests not enabled\n");
2786 #endif
2787 break;
2788
2789 case MP4AACFilePlayStopPlayStopTest:
2790 #if RUN_MP4FILE_TESTCASES
2791 testparam.iFileName = LOCAL_TEST_FILE_MP4_AAC;
2792 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2793 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2794 fprintf(file, "MP4 AAC-only ");
2795 #else
2796 fprintf(file, "MP4 file tests not enabled\n");
2797 #endif
2798 break;
2799
2800 case MP4M4VAMRTextFileOpenPlayStopTest:
2801 #if RUN_MP4FILE_TESTCASES
2802 testparam.iFileName = LOCAL_TEST_FILE_MP4_M4V_AMR_TEXT;
2803 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2804 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2805 fprintf(file, "MP4 M4v/AMR/Text ");
2806 #else
2807 fprintf(file, "MP4 file tests not enabled\n");
2808 #endif
2809 break;
2810
2811 case MP4M4VAMRTextFilePlayStopPlayStopTest:
2812 #if RUN_MP4FILE_TESTCASES
2813 testparam.iFileName = LOCAL_TEST_FILE_MP4_M4V_AMR_TEXT;
2814 testparam.iFileType = LOCAL_TEST_FILE_MP4_FORMAT_TYPE;
2815 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2816 fprintf(file, "MP4 M4v/AMR/Text ");
2817 #else
2818 fprintf(file, "MP4 file tests not enabled\n");
2819 #endif
2820 break;
2821
2822 case AMRIETFFileOpenPlayStopTest:
2823 #if RUN_AMRFILE_TESTCASES
2824 testparam.iFileName = LOCAL_TEST_FILE_AMR_IETF;
2825 testparam.iFileType = LOCAL_TEST_FILE_AMR_FORMAT_TYPE;
2826 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2827 fprintf(file, "AMR IETF ");
2828 #else
2829 fprintf(file, "AMR file tests not enabled\n");
2830 #endif
2831 break;
2832
2833 case AMRIETFFilePlayStopPlayStopTest:
2834 #if RUN_AMRFILE_TESTCASES
2835 testparam.iFileName = LOCAL_TEST_FILE_AMR_IETF;
2836 testparam.iFileType = LOCAL_TEST_FILE_AMR_FORMAT_TYPE;
2837 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2838 fprintf(file, "AMR IETF ");
2839 #else
2840 fprintf(file, "AMR file tests not enabled\n");
2841 #endif
2842 break;
2843
2844 case AMRIF2FileOpenPlayStopTest:
2845 #if RUN_AMRFILE_TESTCASES
2846 testparam.iFileName = LOCAL_TEST_FILE_AMR_IF2;
2847 testparam.iFileType = LOCAL_TEST_FILE_AMR_FORMAT_TYPE;
2848 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2849 fprintf(file, "AMR IF2 ");
2850 #else
2851 fprintf(file, "AMR file tests not enabled\n");
2852 #endif
2853 break;
2854
2855 case AMRIF2FilePlayStopPlayStopTest:
2856 #if RUN_AMRFILE_TESTCASES
2857 testparam.iFileName = LOCAL_TEST_FILE_AMR_IF2;
2858 testparam.iFileType = LOCAL_TEST_FILE_AMR_FORMAT_TYPE;
2859 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2860 fprintf(file, "AMR IF2 ");
2861 #else
2862 fprintf(file, "AMR file tests not enabled\n");
2863 #endif
2864 break;
2865
2866 case AACADTSFileOpenPlayStopTest:
2867 #if RUN_AACFILE_TESTCASES
2868 testparam.iFileName = LOCAL_TEST_FILE_AAC_ADTS;
2869 testparam.iFileType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
2870 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2871 fprintf(file, "AAC ADTS ");
2872 #else
2873 fprintf(file, "AAC file tests not enabled\n");
2874 #endif
2875 break;
2876
2877 case AACADTSFilePlayStopPlayStopTest:
2878 #if RUN_AACFILE_TESTCASES
2879 testparam.iFileName = LOCAL_TEST_FILE_AAC_ADTS;
2880 testparam.iFileType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
2881 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2882 fprintf(file, "AAC ADTS ");
2883 #else
2884 fprintf(file, "AAC file tests not enabled\n");
2885 #endif
2886 break;
2887
2888 case AACADIFFileOpenPlayStopTest:
2889 #if RUN_AACFILE_TESTCASES
2890 testparam.iFileName = LOCAL_TEST_FILE_AAC_ADIF;
2891 testparam.iFileType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
2892 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2893 fprintf(file, "AAC ADIF ");
2894 #else
2895 fprintf(file, "AAC file tests not enabled\n");
2896 #endif
2897 break;
2898
2899 case AACADIFFilePlayStopPlayStopTest:
2900 #if RUN_AACFILE_TESTCASES
2901 testparam.iFileName = LOCAL_TEST_FILE_AAC_ADIF;
2902 testparam.iFileType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
2903 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2904 fprintf(file, "AAC ADIF ");
2905 #else
2906 fprintf(file, "AAC file tests not enabled\n");
2907 #endif
2908 break;
2909
2910 case AACRawFileOpenPlayStopTest:
2911 #if RUN_AACFILE_TESTCASES
2912 testparam.iFileName = LOCAL_TEST_FILE_AAC_RAW;
2913 testparam.iFileType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
2914 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2915 fprintf(file, "AAC Raw ");
2916 #else
2917 fprintf(file, "AAC file tests not enabled\n");
2918 #endif
2919 break;
2920
2921 case AACRawFilePlayStopPlayStopTest:
2922 #if RUN_AACFILE_TESTCASES
2923 testparam.iFileName = LOCAL_TEST_FILE_AAC_RAW;
2924 testparam.iFileType = LOCAL_TEST_FILE_AAC_FORMAT_TYPE;
2925 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2926 fprintf(file, "AAC Raw ");
2927 #else
2928 fprintf(file, "AAC file tests not enabled\n");
2929 #endif
2930 break;
2931
2932 case MP3CBRFileOpenPlayStopTest:
2933 #if RUN_MP3FILE_TESTCASES
2934 testparam.iFileName = LOCAL_TEST_FILE_MP3_CBR;
2935 testparam.iFileType = LOCAL_TEST_FILE_MP3_FORMAT_TYPE;
2936 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2937 fprintf(file, "MP3 CBR ");
2938 #else
2939 fprintf(file, "MP3 file tests not enabled\n");
2940 #endif
2941 break;
2942
2943 case MP3CBRFilePlayStopPlayStopTest:
2944 #if RUN_MP3FILE_TESTCASES
2945 testparam.iFileName = LOCAL_TEST_FILE_MP3_CBR;
2946 testparam.iFileType = LOCAL_TEST_FILE_MP3_FORMAT_TYPE;
2947 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2948 fprintf(file, "MP3 CBR ");
2949 #else
2950 fprintf(file, "MP3 file tests not enabled\n");
2951 #endif
2952 break;
2953
2954 case MP3VBRFileOpenPlayStopTest:
2955 #if RUN_MP3FILE_TESTCASES
2956 testparam.iFileName = LOCAL_TEST_FILE_MP3_VBR;
2957 testparam.iFileType = LOCAL_TEST_FILE_MP3_FORMAT_TYPE;
2958 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2959 fprintf(file, "MP3 VBR ");
2960 #else
2961 fprintf(file, "MP3 file tests not enabled\n");
2962 #endif
2963 break;
2964
2965 case MP3VBRFilePlayStopPlayStopTest:
2966 #if RUN_MP3FILE_TESTCASES
2967 testparam.iFileName = LOCAL_TEST_FILE_MP3_VBR;
2968 testparam.iFileType = LOCAL_TEST_FILE_MP3_FORMAT_TYPE;
2969 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2970 fprintf(file, "MP3 VBR ");
2971 #else
2972 fprintf(file, "MP3 file tests not enabled\n");
2973 #endif
2974 break;
2975
2976 case WAVFileOpenPlayStopTest:
2977 #if RUN_WAVFILE_TESTCASES
2978 testparam.iFileName = LOCAL_TEST_FILE_WAV;
2979 testparam.iFileType = LOCAL_TEST_FILE_WAV_FORMAT_TYPE;
2980 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
2981 fprintf(file, "WAV ");
2982 #else
2983 fprintf(file, "WAV file tests not enabled\n");
2984 #endif
2985 break;
2986
2987 case WAVFilePlayStopPlayStopTest:
2988 #if RUN_WAVFILE_TESTCASES
2989 testparam.iFileName = LOCAL_TEST_FILE_WAV;
2990 testparam.iFileType = LOCAL_TEST_FILE_WAV_FORMAT_TYPE;
2991 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
2992 fprintf(file, "WAV ");
2993 #else
2994 fprintf(file, "WAV file tests not enabled\n");
2995 #endif
2996 break;
2997
2998 case ASFFileOpenPlayStopTest:
2999 #if RUN_ASFFILE_TESTCASES
3000 testparam.iFileName = LOCAL_TEST_FILE_ASF;
3001 testparam.iFileType = LOCAL_TEST_FILE_ASF_FORMAT_TYPE;
3002 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
3003 fprintf(file, "ASF ");
3004 #else
3005 fprintf(file, "ASF file tests not enabled\n");
3006 #endif
3007 break;
3008
3009 case ASFFilePlayStopPlayStopTest:
3010 #if RUN_ASFFILE_TESTCASES
3011 testparam.iFileName = LOCAL_TEST_FILE_ASF;
3012 testparam.iFileType = LOCAL_TEST_FILE_ASF_FORMAT_TYPE;
3013 iCurrentTest = new pvplayer_async_test_mediaionode_playstopplay(testparam);
3014 fprintf(file, "ASF ");
3015 #else
3016 fprintf(file, "ASF file tests not enabled\n");
3017 #endif
3018 break;
3019
3020 case RealAudioFileOpenPlayStopTest:
3021 #if RUN_REALAUDIO_FILE_TESTCASES
3022 testparam.iFileName = LOCAL_TEST_FILE_REALAUDIO;
3023 testparam.iFileType = LOCAL_TEST_FILE_REALAUDIO_FORMAT_TYPE;
3024 iCurrentTest = new pvplayer_async_test_mediaionode_openplaystop(testparam);
3025 fprintf(file, "Real Audio ");
3026 #else
3027 fprintf(file, "Real Audio file tests not enabled\n");
3028 #endif
3029 break;
3030
3031 case SetPlaybackAfterPrepare:
3032
3033 iCurrentTest = new pvplayer_async_test_setplaybackafterprepare(testparam);
3034 break;
3035
3036 case FTDownloadOpenPlayStopTest:
3037 #if RUN_FASTTRACK_TESTCASES
3038 #ifndef ONLY_3GPP_STREAMING_FORMAT
3039 iCurrentTest = new pvplayer_async_test_ftdlnormal(testparam);
3040 #else
3041 fprintf(file, "PV Fast track download tests not enabled\n");
3042 #endif
3043 #else
3044 fprintf(file, "Download tests not enabled\n");
3045 #endif
3046 break;
3047
3048 case FTDownloadPlayStopPlayTest:
3049 #if RUN_FASTTRACK_TESTCASES
3050 #ifndef ONLY_3GPP_STREAMING_FORMAT
3051 iCurrentTest = new pvplayer_async_test_ftdlnormal(testparam);
3052 ((pvplayer_async_test_ftdlnormal*)iCurrentTest)->enablePlayStopPlay();
3053
3054 #else
3055 fprintf(file, "PV Fast track download tests not enabled\n");
3056 #endif
3057 #else
3058 fprintf(file, "Download tests not enabled\n");
3059 #endif
3060 break;
3061
3062 case ProgDownloadPlayAsapTest:
3063 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3064 testparam.iFileType = PVMF_MIME_MPEG4FF;
3065 iCurrentTest = new pvplayer_async_test_3gppdlnormal(testparam);
3066 #else
3067 fprintf(file, "Prog download tests not enabled\n");
3068 #endif
3069 break;
3070
3071 case ProgDownloadPlayStopPlayTest:
3072 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3073 testparam.iFileType = PVMF_MIME_MPEG4FF;
3074 iCurrentTest = new pvplayer_async_test_3gppdlnormal(testparam);
3075 ((pvplayer_async_test_3gppdlnormal*)iCurrentTest)->enablePlayStopPlay();
3076 #else
3077 fprintf(file, "Prog download tests not enabled\n");
3078 #endif
3079 break;
3080
3081 case ProgPlaybackPlayStopPlayTest:
3082 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3083 testparam.iFileType = PVMF_MIME_MPEG4FF;
3084 iCurrentTest = new pvplayer_async_test_ppbnormal(testparam);
3085 ((pvplayer_async_test_ppbnormal*)iCurrentTest)->enablePlayStopPlay();
3086 #else
3087 fprintf(file, "Prog Download tests not enabled\n");
3088 #endif
3089 break;
3090
3091 case ProgDownloadDownloadThenPlayTest:
3092 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3093 testparam.iFileType = PVMF_MIME_MPEG4FF;
3094 iCurrentTest = new pvplayer_async_test_3gppdlnormal_dlthenplay(testparam);
3095 #else
3096 fprintf(file, "Prog Download tests not enabled\n");
3097 #endif
3098 break;
3099
3100 case ProgDownloadDownloadThenPlayPauseTest:
3101 #if RUN_HTTPDOWNLOAD_TESTCASES
3102 testparam.iFileType = PVMF_MIME_MPEG4FF;
3103 iCurrentTest = new pvplayer_async_test_3gppdlnormal_dlthenplay(testparam);
3104 ((pvplayer_async_test_3gppdlnormal_dlthenplay*)iCurrentTest)->enablePauseAfterDownloadComplete();
3105 #else
3106 fprintf(file, "Prog Download tests not enabled\n");
3107 #endif
3108 break;
3109
3110 case ProgDownloadDownloadThenPlayRepositionTest:
3111 #if RUN_HTTPDOWNLOAD_TESTCASES
3112 testparam.iFileType = PVMF_MIME_MPEG4FF;
3113 iCurrentTest = new pvplayer_async_test_3gppdlnormal_dlthenplay(testparam);
3114 ((pvplayer_async_test_3gppdlnormal_dlthenplay*)iCurrentTest)->enableReposAfterDownloadComplete();
3115 #else
3116 fprintf(file, "Prog Download tests not enabled\n");
3117 #endif
3118 break;
3119
3120 case ProgDownloadDownloadOnlyTest:
3121 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3122 testparam.iFileType = PVMF_MIME_MPEG4FF;
3123 iCurrentTest = new pvplayer_async_test_3gppdlnormal_dlonly(testparam);
3124 #else
3125 fprintf(file, "Prog Download tests not enabled\n");
3126 #endif
3127 break;
3128
3129 case ProgDownloadCancelDuringInitTest:
3130 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3131 testparam.iFileType = PVMF_MIME_MPEG4FF;
3132 iCurrentTest = new pvplayer_async_test_3gppdlcancelduringinit(testparam);
3133 #else
3134 fprintf(file, "Prog Download tests not enabled\n");
3135 #endif
3136 break;
3137
3138 case ProgDownloadCancelDuringInitDelayTest: //114
3139 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3140 testparam.iFileType = PVMF_MIME_MPEG4FF;
3141 iCurrentTest = new pvplayer_async_test_3gppdlcancelduringinitdelay(testparam);
3142 #else
3143 fprintf(file, "Prog Download tests not enabled\n");
3144 #endif
3145 break;
3146 case ProgDownloadPauseResumeAfterUnderflowTest: //115
3147 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3148 testparam.iFileType = PVMF_MIME_MPEG4FF;
3149 iCurrentTest = new pvplayer_async_test_PDLPauseResumeAfterUnderFlow(testparam);
3150 #else
3151 fprintf(file, "Prog Download tests not enabled\n");
3152 #endif
3153 break;
3154
3155 case ProgDownloadContentTooLarge:
3156 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3157 testparam.iFileType = PVMF_MIME_MPEG4FF;
3158 iCurrentTest = new pvplayer_async_test_3gppdlcontenttoolarge(testparam);
3159 #else
3160 fprintf(file, "Prog Download tests not enabled\n");
3161 #endif
3162 break;
3163
3164 case ProgDownloadTruncated:
3165 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3166 #ifndef ONLY_3GPP_STREAMING_FORMAT
3167 testparam.iFileType = PVMF_MIME_MPEG4FF;
3168 iCurrentTest = new pvplayer_async_test_3gppdlContentTruncated(testparam);
3169 #else
3170 fprintf(file, "Prog Truncated download tests not enabled\n");
3171 #endif
3172 #else
3173 fprintf(file, "Prog Download tests not enabled\n");
3174 #endif
3175 break;
3176
3177 case ProgDownloadProtocolRolloverTest:
3178 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3179 testparam.iFileType = PVMF_MIME_MPEG4FF;
3180 iCurrentTest = new pvplayer_async_test_3gppdlnormal(testparam);
3181 ((pvplayer_async_test_3gppdlnormal*)iCurrentTest)->setProtocolRollOverMode();
3182 #else
3183 fprintf(file, "Prog Download tests not enabled\n");
3184 #endif
3185 break;
3186
3187 case ProgDownloadSetPlayBackRangeTest:
3188 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3189 testparam.iFileType = PVMF_MIME_MPEG4FF;
3190 iCurrentTest = new pvplayer_async_test_3gppdlnormal(testparam);
3191 ((pvplayer_async_test_3gppdlnormal*)iCurrentTest)->enableReposAfterDownloadComplete();
3192 #else
3193 fprintf(file, "Prog Download tests not enabled\n");
3194 #endif
3195 break;
3196
3197 case ProgDownloadPlayUtilEOSTest:
3198 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3199 testparam.iFileType = PVMF_MIME_MPEG4FF;
3200 iCurrentTest = new pvplayer_async_test_3gppdlnormal(testparam);
3201 ((pvplayer_async_test_3gppdlnormal*)iCurrentTest)->enablePlayUntilEOS();
3202 #else
3203 fprintf(file, "Prog Download tests not enabled\n");
3204 #endif
3205 break;
3206
3207 case ProgPlaybackMP4UntilEOSTest:
3208 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3209 testparam.iFileType = PVMF_MIME_MPEG4FF;
3210 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3211 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enablePlayUntilEOS();
3212 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Until EOS");
3213 #else
3214 fprintf(file, "MP4 progressive playback tests not enabled\n");
3215 #endif
3216 break;
3217
3218 case ProgPlaybackMP4ShortTest:
3219 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3220 testparam.iFileType = PVMF_MIME_MPEG4FF;
3221 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3222 #else
3223 fprintf(file, "MP4 progressive playback tests not enabled\n");
3224 #endif
3225 break;
3226
3227 case ProgPlaybackMP4ShortPauseResumeTest:
3228 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3229 testparam.iFileType = PVMF_MIME_MPEG4FF;
3230 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3231 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableShortPauseResume();
3232 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Short Pause Resume");
3233 #else
3234 fprintf(file, "MP4 progressive playback tests not enabled\n");
3235 #endif
3236 break;
3237
3238 case ProgPlaybackMP4LongPauseResumeTest:
3239 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3240 testparam.iFileType = PVMF_MIME_MPEG4FF;
3241 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3242 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableLongPauseResume();
3243 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enablePlayUntilEOS();
3244 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Long Pause Resume Until EOS");
3245 #else
3246 fprintf(file, "MP4 progressive playback tests not enabled\n");
3247 #endif
3248 break;
3249
3250 case ProgPlaybackMP4StartPauseSeekResumeTwiceTest:
3251 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3252 testparam.iFileType = PVMF_MIME_MPEG4FF;
3253 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3254 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableShortPauseResume();
3255 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekAfterStart();
3256 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableTwice();
3257 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Start Pause Seek Resume Twice");
3258 #else
3259 fprintf(file, "MP4 progressive playback tests not enabled\n");
3260 #endif
3261 break;
3262
3263 case ProgPlaybackMP4SeekStartTest:
3264 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3265 testparam.iFileType = PVMF_MIME_MPEG4FF;
3266 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3267 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekBeforeStart();
3268 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enablePlayUntilEOS();
3269 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Seek Start Until EOS");
3270 #else
3271 fprintf(file, "MP4 progressive playback tests not enabled\n");
3272 #endif
3273 break;
3274
3275 case ProgPlaybackMP4StartPauseSeekResumeLoopTest:
3276 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3277 testparam.iFileType = PVMF_MIME_MPEG4FF;
3278 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3279 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableShortPauseResume();
3280 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekAfterStart();
3281 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableLoop();
3282 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Start Pause Seek Resume Loop");
3283 #else
3284 fprintf(file, "MP4 progressive playback tests not enabled\n");
3285 #endif
3286 break;
3287
3288 case ProgPlaybackMP4SeekForwardStepLoopTest:
3289 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3290 testparam.iFileType = PVMF_MIME_MPEG4FF;
3291 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3292 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableShortPauseResume();
3293 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekAfterStart();
3294 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableLoop();
3295 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableForwardStep();
3296 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Seek Forward Step Loop");
3297 #else
3298 fprintf(file, "MP4 progressive playback tests not enabled\n");
3299 #endif
3300 break;
3301
3302 case ProgPlaybackMP4SeekToBOCAfterDownloadCompleteTest:
3303 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3304 testparam.iFileType = PVMF_MIME_MPEG4FF;
3305 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3306 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekToBOC();
3307 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekAfterDownloadComplete();
3308 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Seek To Beginning Of Clip After Download Complete");
3309 #else
3310 fprintf(file, "MP4 progressive playback tests not enabled\n");
3311 #endif
3312 break;
3313
3314 case ProgPlaybackMP4SeekInCacheAfterDownloadCompleteTest:
3315 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3316 testparam.iFileType = PVMF_MIME_MPEG4FF;
3317 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3318 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekInCache();
3319 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableSeekAfterDownloadComplete();
3320 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback Seek To Position In Cache After Download Complete");
3321 #else
3322 fprintf(file, "MP4 progressive playback tests not enabled\n");
3323 #endif
3324 break;
3325
3326 case ProgPlaybackMP4EOSStopPlayAgainTest:
3327 #if RUN_HTTPDOWNLOAD_TESTCASES && RUN_MP4FILE_TESTCASES
3328 testparam.iFileType = PVMF_MIME_MPEG4FF;
3329 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3330 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enablePlayUntilEOS();
3331 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableEOSStopPlay();
3332 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("MP4 Progressive Playback To EOS Stop and Play Again");
3333 #else
3334 fprintf(file, "MP4 progressive playback tests not enabled\n");
3335 #endif
3336 break;
3337
3338 case ShoutcastPlayback5MinuteTest:
3339 #if RUN_SHOUTCAST_TESTCASES
3340 testparam.iFileType = PVMF_MIME_DATA_SOURCE_SHOUTCAST_URL;
3341 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3342 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->setShoutcastSessionDuration();
3343 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("Shoutcast Playback For 5 Minutes");
3344 #else
3345 fprintf(file, "Shoutcast playback tests not enabled\n");
3346 #endif
3347 break;
3348
3349 case ShoutcastPlaybackPauseResumeTest:
3350 #if RUN_SHOUTCAST_TESTCASES
3351 testparam.iFileType = PVMF_MIME_DATA_SOURCE_SHOUTCAST_URL;
3352 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3353 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableShoutcastPauseResume();
3354 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("Shoutcast Playback Pause Resume");
3355 #else
3356 fprintf(file, "Shoutcast playback tests not enabled\n");
3357 #endif
3358 break;
3359
3360 case ShoutcastPlaybackPlayStopPlayTest:
3361 #if RUN_SHOUTCAST_TESTCASES
3362 testparam.iFileType = PVMF_MIME_DATA_SOURCE_SHOUTCAST_URL;
3363 iCurrentTest = new pvplayer_async_test_ppb_normal(testparam);
3364 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->enableShoutcastPlayStopPlay();
3365 ((pvplayer_async_test_ppb_normal*)iCurrentTest)->iTestCaseName = _STRLIT_CHAR("Shoutcast Playback Play Stop Play");
3366 #else
3367 fprintf(file, "Shoutcast playback tests not enabled\n");
3368 #endif
3369 break;
3370
3371 case FTDownloadOpenPlayUntilEOSTest:
3372 #if RUN_FASTTRACK_TESTCASES
3373 #ifndef ONLY_3GPP_STREAMING_FORMAT
3374 iCurrentTest = new pvplayer_async_test_ftdlnormal(testparam);
3375 ((pvplayer_async_test_ftdlnormal*)iCurrentTest)->enablePlayUntilEOS();
3376 #else
3377 fprintf(file, "PV Fast track download tests not enabled\n");
3378 #endif
3379 #else
3380 fprintf(file, "Download tests not enabled\n");
3381 #endif
3382 break;
3383
3384 case MultipleInstanceOpenPlayStopTest:
3385 {
3386 iCurrentTest = new pvplayer_async_test_multiple_instance(testparam);
3387 }
3388 break;
3389
3390 case MultipleThreadOpenPlayStopTest:
3391 {
3392 iCurrentTest = new pvplayer_async_test_multiple_thread(testparam);
3393 }
3394 break;
3395
3396 case StreamingOpenPlayStopTest:
3397 {
3398 #if RUN_STREAMING_TESTCASES
3399 fprintf(file, "StreamingOpenPlayStopTest");
3400 iCurrentTest =
3401 new pvplayer_async_test_streamingopenplaystop(testparam,
3402 PVMF_MIME_YUV420,
3403 PVMF_MIME_PCM16,
3404 iCurrentTestNumber,
3405 false,
3406 false,
3407 false,
3408 false,
3409 false,
3410 false);
3411 #else
3412 fprintf(file, "Streaming tests not enabled\n");
3413 #endif
3414 }
3415 break;
3416
3417 case StreamingOpenPlayPausePlayStopTest:
3418 {
3419 #if RUN_STREAMING_TESTCASES
3420 fprintf(file, "StreamingOpenPlayPausePlayStopTest");
3421 iCurrentTest =
3422 new pvplayer_async_test_streamingopenplaystop(testparam,
3423 PVMF_MIME_YUV420,
3424 PVMF_MIME_PCM16,
3425 iCurrentTestNumber,
3426 true,
3427 false,
3428 false,
3429 false,
3430 false,
3431 false);
3432 #else
3433 fprintf(file, "Streaming tests not enabled\n");
3434 #endif
3435 }
3436 break;
3437
3438 case StreamingOpenPlaySeekStopTest:
3439 {
3440 #if RUN_STREAMING_TESTCASES
3441 fprintf(file, "StreamingOpenPlaySeekStopTest");
3442 iCurrentTest =
3443 new pvplayer_async_test_streamingopenplaystop(testparam,
3444 PVMF_MIME_YUV420,
3445 PVMF_MIME_PCM16,
3446 iCurrentTestNumber,
3447 false,
3448 true,
3449 false,
3450 false,
3451 false,
3452 false);
3453 #else
3454 fprintf(file, "Streaming tests not enabled\n");
3455 #endif
3456 }
3457 break;
3458
3459 case StreamingCancelDuringPrepareTest:
3460 {
3461 #if RUN_STREAMING_TESTCASES
3462 fprintf(file, "StreamingCancelDuringPrepareTest");
3463 iCurrentTest =
3464 new pvplayer_async_test_streamingopenplaystop(testparam,
3465 PVMF_MIME_YUV420,
3466 PVMF_MIME_PCM16,
3467 iCurrentTestNumber,
3468 false,
3469 false,
3470 false,
3471 false,
3472 true,
3473 false);
3474 #else
3475 fprintf(file, "Streaming tests not enabled\n");
3476 #endif
3477 }
3478 break;
3479
3480 case PrintMetadataTest:
3481 iCurrentTest = new pvplayer_async_test_printmetadata(testparam, false);
3482 break;
3483
3484 case PrintMemStatsTest:
3485 iCurrentTest = new pvplayer_async_test_printmemstats(testparam);
3486 break;
3487
3488 case PlayUntilEOSTest:
3489 iCurrentTest = new pvplayer_async_test_playuntileos(testparam);
3490 break;
3491
3492 case ReleaseMetadataTest:
3493 iCurrentTest = new pvplayer_async_test_printmetadata(testparam, true);
3494 break;
3495
3496 case CleanDrmData_JanusCPMTest:
3497 #if RUN_CPMJANUS_TESTCASES
3498 iCurrentTest = new pvplayer_async_test_januscpm_cleandata(testparam);
3499 #else
3500 fprintf(file, "Janus CPM tests not enabled\n");
3501 #endif
3502 break;
3503
3504 case LoadLicense_JanusCPMTest:
3505 #if RUN_CPMJANUS_TESTCASES
3506 iCurrentTest = new pvplayer_async_test_januscpm_loadlicense(testparam);
3507 #else
3508 fprintf(file, "Janus CPM tests not enabled\n");
3509 #endif
3510 break;
3511
3512 case OpenPlayStop_JanusCPMTest:
3513 #if RUN_CPMJANUS_TESTCASES
3514 iCurrentTest = new pvplayer_async_test_januscpm_openplaystop(testparam);
3515 #else
3516 fprintf(file, "Janus CPM tests not enabled\n");
3517 #endif
3518 break;
3519
3520 case PlayStopPlayStop_JanusCPMTest:
3521 #if RUN_CPMJANUS_TESTCASES
3522 iCurrentTest = new pvplayer_async_test_januscpm_playstopplay(testparam);
3523 #else
3524 fprintf(file, "Janus CPM tests not enabled\n");
3525 #endif
3526 break;
3527
3528 case QueryEngine_JanusCPMTest:
3529 #if RUN_CPMJANUS_TESTCASES
3530 iCurrentTest = new pvplayer_async_test_januscpm_query(testparam);
3531 #else
3532 fprintf(file, "Janus CPM tests not enabled\n");
3533 #endif
3534 break;
3535
3536 case DLA_CleanDrmData_JanusCPMTest:
3537 #if RUN_CPMJANUS_TESTCASES
3538 iCurrentTest = new pvplayer_async_test_januscpm_dla_cleandata(testparam);
3539 #else
3540 fprintf(file, "Janus CPM tests not enabled\n");
3541 #endif
3542 break;
3543
3544 case DLA_OpenPlayStop_JanusCPMTest:
3545 #if RUN_CPMJANUS_TESTCASES
3546 iCurrentTest = new pvplayer_async_test_januscpm_dla_openplaystop(testparam);
3547 #else
3548 fprintf(file, "Janus CPM tests not enabled\n");
3549 #endif
3550 break;
3551
3552 case DLA_LicenseCapture_JanusCPMTest:
3553 #if RUN_CPMJANUS_TESTCASES
3554 iCurrentTest = new pvplayer_async_test_januscpm_dla_licensecapture(testparam);
3555 #else
3556 fprintf(file, "Janus CPM tests not enabled\n");
3557 #endif
3558 break;
3559
3560 case DLA_CancelAcquireLicense_JanusCPMTest:
3561 #if RUN_CPMJANUS_TESTCASES
3562 iCurrentTest = new pvplayer_async_test_januscpm_dla_cancelacquirelicense(testparam);
3563 #else
3564 fprintf(file, "Janus CPM tests not enabled\n");
3565 #endif
3566 break;
3567
3568 case StartupMeasurement_JanusCPMTest:
3569 #if RUN_CPMJANUS_TESTCASES
3570 iCurrentTest = new pvplayer_async_test_januscpm_startupmeasurement(testparam);
3571 #else
3572 fprintf(file, "Janus CPM tests not enabled\n");
3573 #endif
3574 break;
3575
3576 case DLA_QueryEngine_JupiterCPMTest_v2_WMA:
3577 #if RUN_CPMJUPITER_TESTCASES
3578 iCurrentTest = new pvplayer_async_test_jupitercpm_query(testparam
3579 , EJupContentType_v2_WMA);
3580 #else
3581 fprintf(file, "Jupiter CPM tests not enabled\n");
3582 #endif
3583 break;
3584
3585 case DLA_QueryEngine_JupiterCPMTest_v24_WMA:
3586 #if RUN_CPMJUPITER_TESTCASES
3587 iCurrentTest = new pvplayer_async_test_jupitercpm_query(testparam
3588 , EJupContentType_v24_WMA);
3589 #else
3590 fprintf(file, "Jupiter CPM tests not enabled\n");
3591 #endif
3592 break;
3593
3594 case DLA_QueryEngine_JupiterCPMTest_v4_Enveloped_ASF:
3595 #if RUN_CPMJUPITER_TESTCASES
3596 iCurrentTest = new pvplayer_async_test_jupitercpm_query(testparam
3597 , EJupContentType_v4_Enveloped_ASF);
3598 #else
3599 fprintf(file, "Jupiter CPM tests not enabled\n");
3600 #endif
3601 break;
3602
3603 case DLA_QueryEngine_JupiterCPMTest_v4_Enveloped_MP4:
3604 #if RUN_CPMJUPITER_TESTCASES
3605 iCurrentTest = new pvplayer_async_test_jupitercpm_query(testparam
3606 , EJupContentType_v4_Enveloped_MP4);
3607 #else
3608 fprintf(file, "Jupiter CPM tests not enabled\n");
3609 #endif
3610 break;
3611
3612 case DLA_QueryEngine_JupiterCPMTest_v4_Enveloped_Image:
3613 #if RUN_CPMJUPITER_TESTCASES
3614 iCurrentTest = new pvplayer_async_test_jupitercpm_query(testparam
3615 , EJupContentType_v4_Enveloped_Image);
3616 #else
3617 fprintf(file, "Jupiter CPM tests not enabled\n");
3618 #endif
3619 break;
3620
3621 case DLA_EnvelopeRead_JupiterCPMTest_v4_Enveloped_Image:
3622 #if RUN_CPMJUPITER_TESTCASES
3623 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_envelopeimageread(testparam
3624 , EJupContentType_v4_Enveloped_Image);
3625 #else
3626 fprintf(file, "Jupiter CPM tests not enabled\n");
3627 #endif
3628 break;
3629
3630 case DLA_OpenPlayStop_JupiterCPMTest_v2_WMA:
3631 #if RUN_CPMJUPITER_TESTCASES
3632 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3633 , EJupContentType_v2_WMA);
3634 #else
3635 fprintf(file, "Jupiter CPM tests not enabled\n");
3636 #endif
3637 break;
3638
3639 case DLA_OpenPlayStop_JupiterCPMTest_v2_WMV:
3640 #if RUN_CPMJUPITER_TESTCASES
3641 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3642 , EJupContentType_v2_WMV);
3643 #else
3644 fprintf(file, "Jupiter CPM tests not enabled\n");
3645 #endif
3646 break;
3647
3648 case DLA_OpenPlayStop_JupiterCPMTest_v24_WMA:
3649 #if RUN_CPMJUPITER_TESTCASES
3650 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3651 , EJupContentType_v24_WMA);
3652 #else
3653 fprintf(file, "Jupiter CPM tests not enabled\n");
3654 #endif
3655 break;
3656
3657 case DLA_OpenPlayStop_JupiterCPMTest_redirect:
3658 #if RUN_CPMJUPITER_TESTCASES
3659 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_envelopeimageread(testparam
3660 , EJupContentType_v4_Enveloped_Image
3661 , EJupLicenseType_DLA_With_Redirect);
3662 #else
3663 fprintf(file, "Jupiter CPM tests not enabled\n");
3664 #endif
3665 break;
3666
3667 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMA:
3668 #if RUN_CPMJUPITER_TESTCASES
3669 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3670 , EJupContentType_v4_WMA);
3671 #else
3672 fprintf(file, "Jupiter CPM tests not enabled\n");
3673 #endif
3674 break;
3675
3676 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMV:
3677 #if RUN_CPMJUPITER_TESTCASES
3678 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3679 , EJupContentType_v4_WMV);
3680 #else
3681 fprintf(file, "Jupiter CPM tests not enabled\n");
3682 #endif
3683 break;
3684
3685 case DLA_OpenPlayStop_JupiterCPMTest_v4_AAC:
3686 #if RUN_CPMJUPITER_TESTCASES
3687 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3688 , EJupContentType_v4_AAC);
3689 #else
3690 fprintf(file, "Jupiter CPM tests not enabled\n");
3691 #endif
3692 break;
3693
3694 case DLA_OpenPlayStop_JupiterCPMTest_v4_H264:
3695 #if RUN_CPMJUPITER_TESTCASES
3696 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3697 , EJupContentType_v4_H264);
3698 #else
3699 fprintf(file, "Jupiter CPM tests not enabled\n");
3700 #endif
3701 break;
3702
3703 case DLA_OpenPlayStop_JupiterCPMTest_v4_Enveloped_ASF:
3704 #if RUN_CPMJUPITER_TESTCASES
3705 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3706 , EJupContentType_v4_Enveloped_ASF);
3707 #else
3708 fprintf(file, "Jupiter CPM tests not enabled\n");
3709 #endif
3710 break;
3711
3712 case DLA_OpenPlayStop_JupiterCPMTest_v4_Enveloped_MP4:
3713 #if RUN_CPMJUPITER_TESTCASES
3714 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3715 , EJupContentType_v4_Enveloped_MP4);
3716 #else
3717 fprintf(file, "Jupiter CPM tests not enabled\n");
3718 #endif
3719 break;
3720
3721 case DLA_OpenPlayStop_JupiterCPMTest_unprotected_H264:
3722 #if RUN_CPMJUPITER_TESTCASES
3723 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3724 , EJupContentType_unprotected_H264_in_ASF);
3725 #else
3726 fprintf(file, "Jupiter CPM tests not enabled\n");
3727 #endif
3728 break;
3729
3730 case DLA_OpenPlayStop_JupiterCPMTest_unprotected_AAC:
3731 #if RUN_CPMJUPITER_TESTCASES
3732 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3733 , EJupContentType_unprotected_AAC_in_ASF);
3734 #else
3735 fprintf(file, "Jupiter CPM tests not enabled\n");
3736 #endif
3737 break;
3738
3739 case DLA_OpenPlayStop_JupiterCPMTest_v24_WMA_fallback:
3740 #if RUN_CPMJUPITER_TESTCASES
3741 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3742 , EJupContentType_v24_WMA
3743 , EJupLicenseType_DLA_With_Fallback);
3744 #else
3745 fprintf(file, "Jupiter CPM tests not enabled\n");
3746 #endif
3747 break;
3748
3749 case DLA_OpenPlayStop_JupiterCPMTest_v24_WMV:
3750 #if RUN_CPMJUPITER_TESTCASES
3751 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3752 , EJupContentType_v24_WMV);
3753 #else
3754 fprintf(file, "Jupiter CPM tests not enabled\n");
3755 #endif
3756 break;
3757
3758 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMA_ringtone:
3759 #if RUN_CPMJUPITER_TESTCASES
3760 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3761 , EJupContentType_v4_WMA
3762 , EJupLicenseType_DLA_With_Ringtone);
3763 #else
3764 fprintf(file, "Jupiter CPM tests not enabled\n");
3765 #endif
3766 break;
3767
3768 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMA_domain:
3769 #if RUN_CPMJUPITER_TESTCASES
3770 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3771 , EJupContentType_v4_WMA
3772 , EJupLicenseType_DLA_With_Domain);
3773 #else
3774 fprintf(file, "Jupiter CPM tests not enabled\n");
3775 #endif
3776 break;
3777
3778 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMA_domain_renew:
3779 #if RUN_CPMJUPITER_TESTCASES
3780 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3781 , EJupContentType_v4_WMA
3782 , EJupLicenseType_DLA_With_DomainRenew);
3783 #else
3784 fprintf(file, "Jupiter CPM tests not enabled\n");
3785 #endif
3786 break;
3787
3788 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMA_domain_offline:
3789 #if RUN_CPMJUPITER_TESTCASES
3790 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3791 , EJupContentType_v4_WMA
3792 , EJupLicenseType_DLA_With_DomainOffline);
3793 #else
3794 fprintf(file, "Jupiter CPM tests not enabled\n");
3795 #endif
3796 break;
3797
3798 case DLA_OpenPlayStop_JupiterCPMTest_v4_WMA_domain_history:
3799 #if RUN_CPMJUPITER_TESTCASES
3800 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_openplaystop(testparam
3801 , EJupContentType_v4_WMA
3802 , EJupLicenseType_DLA_With_DomainHistory);
3803 #else
3804 fprintf(file, "Jupiter CPM tests not enabled\n");
3805 #endif
3806 break;
3807
3808 case DLA_JoinDomain_JupiterCPMTest:
3809 #if RUN_CPMJUPITER_TESTCASES
3810 iCurrentTest = new pvplayer_async_test_jupitercpm_joindomain(testparam);
3811 #else
3812 fprintf(file, "Jupiter CPM tests not enabled\n");
3813 #endif
3814 break;
3815
3816 case DLA_LeaveDomain_JupiterCPMTest:
3817 #if RUN_CPMJUPITER_TESTCASES
3818 iCurrentTest = new pvplayer_async_test_jupitercpm_leavedomain(testparam);
3819 #else
3820 fprintf(file, "Jupiter CPM tests not enabled\n");
3821 #endif
3822 break;
3823
3824 case DLA_MeteringByCert_JupiterCPMTest:
3825 #if (RUN_CPMJUPITER_TESTCASES && RUN_CPMJUPITER_METERING_TESTCASES)
3826 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_metering_or_sync(testparam
3827 , EPVMeterTestType_byCert
3828 , EJupContentType_mixed
3829 , EJupLicenseType_DLA_With_Metering);
3830 #else
3831 fprintf(file, "Jupiter CPM tests not enabled\n");
3832 #endif
3833 break;
3834
3835 case DLA_MeteringByMID_JupiterCPMTest:
3836 #if (RUN_CPMJUPITER_TESTCASES && RUN_CPMJUPITER_METERING_TESTCASES)
3837 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_metering_or_sync(testparam
3838 , EPVMeterTestType_byMID
3839 , EJupContentType_mixed
3840 , EJupLicenseType_DLA_With_Metering);
3841 #else
3842 fprintf(file, "Jupiter CPM tests not enabled\n");
3843 #endif
3844 break;
3845
3846 case DLA_MeteringAll_JupiterCPMTest:
3847 #if (RUN_CPMJUPITER_TESTCASES && RUN_CPMJUPITER_METERING_TESTCASES)
3848 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_metering_or_sync(testparam
3849 , EPVMeterTestType_All
3850 , EJupContentType_mixed
3851 , EJupLicenseType_DLA_With_Metering);
3852 #else
3853 fprintf(file, "Jupiter CPM tests not enabled\n");
3854 #endif
3855 break;
3856
3857 case DLA_LicenseUpdateAll_JupiterCPMTest:
3858 #if RUN_CPMJUPITER_TESTCASES
3859 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_metering_or_sync(testparam
3860 , EPVMeterTestType_SyncAll
3861 , EJupContentType_mixed
3862 , EJupLicenseType_DLA_With_Sync);
3863 #else
3864 fprintf(file, "Jupiter CPM tests not enabled\n");
3865 #endif
3866 break;
3867
3868 case DLA_LicenseUpdateExpired_JupiterCPMTest:
3869 #if RUN_CPMJUPITER_TESTCASES
3870 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_metering_or_sync(testparam
3871 , EPVMeterTestType_SyncExpiredOnly
3872 , EJupContentType_mixed
3873 , EJupLicenseType_DLA_With_Sync);
3874 #else
3875 fprintf(file, "Jupiter CPM tests not enabled\n");
3876 #endif
3877 break;
3878
3879
3880 case DLA_DeleteLicense_JupiterCPMTest_v2_Content:
3881 #if RUN_CPMJUPITER_TESTCASES
3882 iCurrentTest = new pvplayer_async_test_jupitercpm_deletelicense(testparam, EJupContentType_v2_WMA, EJupLicenseType_DLA);
3883 #else
3884 fprintf(file, "Jupiter CPM tests not enabled\n");
3885 #endif
3886 break;
3887
3888 case DLA_DeleteLicense_JupiterCPMTest_v24_Content:
3889 #if RUN_CPMJUPITER_TESTCASES
3890 iCurrentTest = new pvplayer_async_test_jupitercpm_deletelicense(testparam, EJupContentType_v24_WMA, EJupLicenseType_DLA);
3891 #else
3892 fprintf(file, "Jupiter CPM tests not enabled\n");
3893 #endif
3894 break;
3895
3896 case DLA_CancelAcquireLicense_JupiterCPMTest_v4_Enveloped_Image:
3897 #if RUN_CPMJUPITER_TESTCASES
3898 iCurrentTest = new pvplayer_async_test_jupitercpm_dla_cancelacquirelicense_envelopeimageread(testparam
3899 , EJupContentType_v4_Enveloped_Image);
3900 #else
3901 fprintf(file, "Jupiter CPM tests not enabled\n");
3902 #endif
3903 break;
3904
3905 case DLA_CancelAcquireLicense_JupiterCPMTest_v2_Content:
3906 #if RUN_CPMJUPITER_TESTCASES
3907 iCurrentTest = new pvplayer_async_test_jupitercpm_cancelacquirelicense(testparam, EJupContentType_v2_WMA, EJupLicenseType_DLA);
3908 #else
3909 fprintf(file, "Jupiter CPM tests not enabled\n");
3910 #endif
3911 break;
3912
3913 case DLA_CancelAcquireLicense_JupiterCPMTest_v24_Content:
3914 #if RUN_CPMJUPITER_TESTCASES
3915 iCurrentTest = new pvplayer_async_test_jupitercpm_cancelacquirelicense(testparam, EJupContentType_v24_WMA, EJupLicenseType_DLA);
3916 #else
3917 fprintf(file, "Jupiter CPM tests not enabled\n");
3918 #endif
3919 break;
3920
3921 case DLA_CancelAcquireLicense_JupiterCPMTest_v4_Enveloped_MP4:
3922 #if RUN_CPMJUPITER_TESTCASES
3923 iCurrentTest = new pvplayer_async_test_jupitercpm_cancelacquirelicense(testparam, EJupContentType_v4_Enveloped_MP4, EJupLicenseType_DLA);
3924 #else
3925 fprintf(file, "Jupiter CPM tests not enabled\n");
3926 #endif
3927 break;
3928
3929 case DLA_PDL_OpenPlayUntilEOS_JanusCPMTest:
3930 #if (RUN_HTTPDOWNLOAD_TESTCASES && RUN_CPMJANUS_TESTCASES)
3931 iCurrentTest = new pvplayer_async_test_januscpm_pdl_openplaystop(testparam);
3932 ((pvplayer_async_test_januscpm_pdl_openplaystop*)iCurrentTest)->enablePlayUntilEOS();
3933 #else
3934 fprintf(file, "Janus CPM + PDL tests not enabled\n");
3935 #endif
3936 break;
3937
3938 case StreamingOpenPlayUntilEOSTest:
3939 #if RUN_STREAMING_TESTCASES
3940 fprintf(file, "StreamingOpenPlayUntilEOSTest");
3941 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
3942 PVMF_MIME_YUV420,
3943 PVMF_MIME_PCM16,
3944 iCurrentTestNumber,
3945 false,
3946 false,
3947 true,
3948 false,
3949 false,
3950 false);
3951 #else
3952 fprintf(file, "Streaming tests not enabled\n");
3953 #endif
3954 break;
3955 case StreamingCloakingOpenPlayUntilEOSTest:
3956 #if RUN_STREAMING_TESTCASES
3957 #if RUN_RTSP_CLOAKING_TESTCASES
3958 fprintf(file, "StreamingCloakingOpenPlayUntilEOSTest");
3959 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
3960 PVMF_MIME_YUV420,
3961 PVMF_MIME_PCM16,
3962 iCurrentTestNumber,
3963 false,
3964 false,
3965 true,
3966 true,
3967 false,
3968 false);
3969 #else
3970 fprintf(file, "Streaming: cloaking tests not enabled\n");
3971 #endif
3972 #else
3973 fprintf(file, "Streaming tests not enabled\n");
3974 #endif
3975 break;
3976 case StreamingOpenPlayPausePlayUntilEOSTest:
3977 #if RUN_STREAMING_TESTCASES
3978 fprintf(file, "StreamingOpenPlayPausePlayUntilEOSTest");
3979 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
3980 PVMF_MIME_YUV420,
3981 PVMF_MIME_PCM16,
3982 iCurrentTestNumber,
3983 true,
3984 false,
3985 true,
3986 false,
3987 false,
3988 false);
3989 #else
3990 fprintf(file, "Streaming tests not enabled\n");
3991 #endif
3992 break;
3993
3994 case StreamingOpenPlayMultiplePausePlayUntilEOSTest:
3995 {
3996 #if RUN_STREAMING_TESTCASES
3997 fprintf(file, "StreamingOpenPlayPausePlayUntilEOSTest");
3998 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
3999 PVMF_MIME_YUV420,
4000 PVMF_MIME_PCM16,
4001 iCurrentTestNumber,
4002 true,
4003 false,
4004 true,
4005 false,
4006 false,
4007 false);
4008
4009 pvplayer_async_test_streamingopenplaystop* ptr =
4010 (pvplayer_async_test_streamingopenplaystop*)iCurrentTest;
4011 ptr->setMultiplePauseMode(1);
4012
4013 #else
4014 fprintf(file, "Streaming tests not enabled\n");
4015 #endif
4016 }
4017 break;
4018
4019
4020 case StreamingOpenPlaySeekPlayUntilEOSTest:
4021 #if RUN_STREAMING_TESTCASES
4022 fprintf(file, "StreamingOpenPlaySeekPlayUntilEOSTest");
4023 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4024 PVMF_MIME_YUV420,
4025 PVMF_MIME_PCM16,
4026 iCurrentTestNumber,
4027 false,
4028 true,
4029 true,
4030 false,
4031 false,
4032 false);
4033 #else
4034 fprintf(file, "Streaming tests not enabled\n");
4035 #endif
4036 break;
4037
4038 case StreamingOpenPlayForwardPlayUntilEOSTest:
4039 #if RUN_STREAMING_TESTCASES
4040 fprintf(file, "StreamingOpenPlayForwardPlayUntilEOSTest");
4041 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4042 PVMF_MIME_YUV420,
4043 PVMF_MIME_PCM16,
4044 iCurrentTestNumber,
4045 false,
4046 false,
4047 true,
4048 false,
4049 false,
4050 true);
4051 #else
4052 fprintf(file, "Streaming tests not enabled\n");
4053 #endif
4054 break;
4055
4056 case StreamingJitterBufferAdjustUntilEOSTest:
4057 #if RUN_STREAMING_TESTCASES
4058 fprintf(file, "StreamingJitterBufferAdjustUntilEOSTest");
4059 iCurrentTest = new pvplayer_async_test_streamingJBadjust(testparam,
4060 PVMF_MIME_YUV420,
4061 PVMF_MIME_PCM16,
4062 iCurrentTestNumber,
4063 false,
4064 false,
4065 true);
4066 #else
4067 fprintf(file, "Streaming tests not enabled\n");
4068 #endif
4069 break;
4070
4071 case StreamingPlayBitStreamSwitchPlayUntilEOSTest:
4072 #if RUN_STREAMING_TESTCASES
4073 #ifndef ONLY_3GPP_STREAMING_FORMAT
4074 fprintf(file, "StreamingPlayBitStreamSwitchPlayUntilEOSTest");
4075 if ((NULL == (oscl_strstr(testparam.iFileName, "rtsp://"))) &&
4076 (NULL == (oscl_strstr(testparam.iFileName, ".sdp"))))
4077 {
4078 iCurrentTest = new pvplayer_async_test_streaming_bitstream_switch(testparam,
4079 PVMF_MIME_YUV420,
4080 PVMF_MIME_PCM16,
4081 iCurrentTestNumber,
4082 true);
4083 }
4084 else
4085 {
4086 fprintf(file, "\nBitStreamSwitching Can't be initiated by client for a RTSP url\n");
4087 }
4088 #else
4089 fprintf(file, "Streaming: bitstream switching tests not enabled\n");
4090 #endif
4091 #else
4092 fprintf(file, "Streaming tests not enabled\n");
4093 #endif
4094 break;
4095
4096 case StreamingMultiplePlayUntilEOSTest:
4097 {
4098 #if RUN_STREAMING_TESTCASES
4099 fprintf(file, "StreamingMultiplePlayUntilEOSTest");
4100 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4101 PVMF_MIME_YUV420,
4102 PVMF_MIME_PCM16,
4103 iCurrentTestNumber,
4104 false,
4105 false,
4106 true,
4107 false,
4108 false,
4109 false);
4110
4111 pvplayer_async_test_streamingopenplaystop* ptr =
4112 (pvplayer_async_test_streamingopenplaystop*)iCurrentTest;
4113 ptr->setMultiplePlayMode(2);
4114 #else
4115 fprintf(file, "Streaming tests not enabled\n");
4116 #endif
4117 }
4118 break;
4119
4120 case StreamingMultipleCloakingPlayUntilEOSTest:
4121 {
4122 #if RUN_STREAMING_TESTCASES
4123 #if RUN_RTSP_CLOAKING_TESTCASES
4124 fprintf(file, "StreamingMultipleCloakingPlayUntilEOSTest");
4125 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4126 PVMF_MIME_YUV420,
4127 PVMF_MIME_PCM16,
4128 iCurrentTestNumber,
4129 false,
4130 false,
4131 true,
4132 true,
4133 false,
4134 false);
4135
4136 pvplayer_async_test_streamingopenplaystop* ptr =
4137 (pvplayer_async_test_streamingopenplaystop*)iCurrentTest;
4138 ptr->setMultiplePlayMode(2);
4139 #else
4140 fprintf(file, "Streaming: cloaking tests not enabled\n");
4141 #endif
4142 #else
4143 fprintf(file, "Streaming tests not enabled\n");
4144 #endif
4145 }
4146 break;
4147
4148 case StreamingProtocolRollOverTest:
4149 {
4150 #if RUN_STREAMING_TESTCASES
4151 fprintf(file, "StreamingProtocolRollOverTest");
4152 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4153 PVMF_MIME_YUV420,
4154 PVMF_MIME_PCM16,
4155 iCurrentTestNumber,
4156 false,
4157 false,
4158 true,
4159 false,
4160 false,
4161 false);
4162
4163 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setProtocolRollOverMode();
4164 #else
4165 fprintf(file, "Streaming tests not enabled\n");
4166 #endif
4167 }
4168 break;
4169
4170 case StreamingOpenPlayUntilEOSTestWithFileHandle:
4171 #if RUN_STREAMING_TESTCASES
4172 fprintf(file, "StreamingOpenPlayUntilEOSTestWithFileHandle");
4173 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4174 PVMF_MIME_YUV420,
4175 PVMF_MIME_PCM16,
4176 iCurrentTestNumber,
4177 false,
4178 false,
4179 true,
4180 false,
4181 false,
4182 false,
4183 true);
4184 #else
4185 fprintf(file, "Streaming tests not enabled\n");
4186 #endif
4187 break;
4188
4189 case StreamingProtocolRollOverTestWithUnknownURLType:
4190 {
4191 #if RUN_STREAMING_TESTCASES
4192 fprintf(file, "StreamingProtocolRollOverTestWithUnknownURLType");
4193 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4194 PVMF_MIME_YUV420,
4195 PVMF_MIME_PCM16,
4196 iCurrentTestNumber,
4197 false,
4198 false,
4199 true,
4200 false,
4201 false,
4202 false);
4203
4204 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setProtocolRollOverModeWithUnknownURL();
4205 #else
4206 fprintf(file, "Streaming tests not enabled\n");
4207 #endif
4208 }
4209 break;
4210
4211 case StreamingPlayListSeekTest:
4212 {
4213 #if RUN_STREAMING_TESTCASES
4214 #ifndef ONLY_3GPP_STREAMING_FORMAT
4215 fprintf(file, "StreamingPlayListSeekTest");
4216 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4217 PVMF_MIME_YUV420,
4218 PVMF_MIME_PCM16,
4219 iCurrentTestNumber,
4220 false,
4221 true,
4222 true,
4223 false,
4224 false,
4225 false);
4226
4227 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setPlayListMode();
4228 #else
4229 fprintf(file, "Streaming: playlist tests not enabled\n");
4230 #endif
4231 #else
4232 fprintf(file, "Streaming tests not enabled\n");
4233 #endif
4234 }
4235 break;
4236
4237 case StreamingSeekAfterEOSTest:
4238 {
4239 #if RUN_STREAMING_TESTCASES
4240 fprintf(file, "StreamingSeekAfterEOSTest");
4241 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4242 PVMF_MIME_YUV420,
4243 PVMF_MIME_PCM16,
4244 iCurrentTestNumber,
4245 false,
4246 false,
4247 true,
4248 false,
4249 false,
4250 false);
4251
4252 pvplayer_async_test_streamingopenplaystop* ptr =
4253 (pvplayer_async_test_streamingopenplaystop*)iCurrentTest;
4254 ptr->setSeekAfterEOSMode();
4255 #else
4256 fprintf(file, "Streaming tests not enabled\n");
4257 #endif
4258 }
4259 break;
4260
4261 case StreamingPlayListErrorCodeTest:
4262 {
4263 #if RUN_STREAMING_TESTCASES
4264 #ifndef ONLY_3GPP_STREAMING_FORMAT
4265 fprintf(file, "StreamingPlayListErrorCodeTest");
4266 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4267 PVMF_MIME_YUV420,
4268 PVMF_MIME_PCM16,
4269 iCurrentTestNumber,
4270 false,
4271 true,
4272 true,
4273 false,
4274 false,
4275 false);
4276
4277 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setPlayListMode();
4278 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setErrorCodeTest();
4279 #else
4280 fprintf(file, "Streaming: playlist tests not enabled\n");
4281 #endif
4282 #else
4283 fprintf(file, "Streaming tests not enabled\n");
4284 #endif
4285 }
4286 break;
4287
4288 case StreamingOpenPlayMultipleSeekToEndOfClipUntilEOSTest:
4289 {
4290 #if RUN_STREAMING_TESTCASES
4291 fprintf(file, "StreamingOpenPlayMultipleSeekToEndOfClipUntilEOSTest");
4292 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4293 PVMF_MIME_YUV420,
4294 PVMF_MIME_PCM16,
4295 iCurrentTestNumber,
4296 false,
4297 true,
4298 true,
4299 false,
4300 false,
4301 false,
4302 false,
4303 true);
4304 #else
4305 fprintf(file, "Streaming tests not enabled\n");
4306 #endif
4307 }
4308 break;
4309
4310
4311 case StreamingLongPauseTest:
4312 #if RUN_STREAMING_TESTCASES
4313 fprintf(file, "StreamingLongPauseTest");
4314 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
4315 PVMF_MIME_YUV420,
4316 PVMF_MIME_PCM16,
4317 iCurrentTestNumber,
4318 true,
4319 false,
4320 true,
4321 false,
4322 false,
4323 false);
4324
4325 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setPauseDurationInMS(2*60*1000);
4326 #else
4327 fprintf(file, "Streaming tests not enabled\n");
4328 #endif
4329 break;
4330
4331 case DLA_StreamingOpenPlayUntilEOST_JanusCPMTest:
4332 {
4333 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4334 fprintf(file, "DLA_StreamingOpenPlayUntilEOST_JanusCPMTest");
4335 iCurrentTest =
4336 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4337 PVMF_MIME_YUV420,
4338 PVMF_MIME_PCM16,
4339 iCurrentTestNumber,
4340 false,
4341 false,
4342 true,
4343 false,
4344 false,
4345 false);
4346 #else
4347 fprintf(file, "Streaming tests not enabled\n");
4348 #endif
4349 }
4350 break;
4351
4352 case DLA_StreamingOpenPlayPausePlayUntilEOS_JanusCPMTest:
4353 {
4354 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4355 fprintf(file, "DLA_StreamingOpenPlayPausePlayUntilEOS_JanusCPMTest");
4356 iCurrentTest =
4357 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4358 PVMF_MIME_YUV420,
4359 PVMF_MIME_PCM16,
4360 iCurrentTestNumber,
4361 true,
4362 false,
4363 true,
4364 false,
4365 false,
4366 false);
4367 #else
4368 fprintf(file, "Streaming tests not enabled\n");
4369 #endif
4370 }
4371 break;
4372
4373 case DLA_StreamingOpenPlaySeekPlayUntilEOS_JanusCPMTest:
4374 {
4375 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4376 fprintf(file, "DLA_StreamingOpenPlaySeekPlayUntilEOS_JanusCPMTest");
4377 iCurrentTest = new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4378 PVMF_MIME_YUV420,
4379 PVMF_MIME_PCM16,
4380 iCurrentTestNumber,
4381 false,
4382 true,
4383 true,
4384 false,
4385 false,
4386 false);
4387 #else
4388 fprintf(file, "Streaming tests not enabled\n");
4389 #endif
4390 }
4391 break;
4392
4393 case DLA_StreamingMultiplePlayUntilEOS_JanusCPMTest:
4394 {
4395 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4396 fprintf(file, "DLA_StreamingMultiplePlayUntilEOS_JanusCPMTest");
4397 iCurrentTest =
4398 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4399 PVMF_MIME_YUV420,
4400 PVMF_MIME_PCM16,
4401 iCurrentTestNumber,
4402 false,
4403 false,
4404 true,
4405 false,
4406 false,
4407 false);
4408
4409 pvplayer_async_test_DLAstreamingopenplaystop* ptr =
4410 (pvplayer_async_test_DLAstreamingopenplaystop*)iCurrentTest;
4411 ptr->setMultiplePlayMode(2);
4412 fprintf(file, "\nsetMultiplePlayMode\n");
4413 #else
4414 fprintf(file, "Streaming tests not enabled\n");
4415 #endif
4416 }
4417 break;
4418
4419 case DLA_StreamingProtocolRollOverTest_JanusCPMTest:
4420 {
4421 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4422 fprintf(file, "DLA_StreamingProtocolRollOverTest_JanusCPMTest");
4423 iCurrentTest = new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4424 PVMF_MIME_YUV420,
4425 PVMF_MIME_PCM16,
4426 iCurrentTestNumber,
4427 false,
4428 false,
4429 true,
4430 false,
4431 false,
4432 false);
4433
4434 ((pvplayer_async_test_DLAstreamingopenplaystop*)iCurrentTest)->setProtocolRollOverMode();
4435 #else
4436 fprintf(file, "Streaming tests not enabled\n");
4437 #endif
4438 }
4439 break;
4440
4441 case DLA_StreamingProtocolRollOverTestWithUnknownURLType_JanusCPMTest:
4442 {
4443 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4444 fprintf(file, "DLA_StreamingProtocolRollOverTestWithUnknownURLType_JanusCPMTest");
4445 iCurrentTest = new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4446 PVMF_MIME_YUV420,
4447 PVMF_MIME_PCM16,
4448 iCurrentTestNumber,
4449 false,
4450 false,
4451 true,
4452 false,
4453 false,
4454 false);
4455
4456 ((pvplayer_async_test_DLAstreamingopenplaystop*)iCurrentTest)->setProtocolRollOverModeWithUnknownURL();
4457 #else
4458 fprintf(file, "Streaming tests not enabled\n");
4459 #endif
4460 }
4461 break;
4462
4463 case DLA_StreamingCancelAcquireLicense_JanusCPMTest:
4464 {
4465 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
4466 fprintf(file, "DLA_StreamingCancelAcquireLicense_JanusCPMTest");
4467 iCurrentTest = new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
4468 PVMF_MIME_YUV420,
4469 PVMF_MIME_PCM16,
4470 iCurrentTestNumber,
4471 false,
4472 false,
4473 true,
4474 false,
4475 false,
4476 true);
4477
4478 #else
4479 fprintf(file, "Streaming tests not enabled\n");
4480 #endif
4481 }
4482 break;
4483
4484 case GenericReset_AddDataSource:
4485 {
4486 fprintf(file, "GenericReset_AddDataSource");
4487 iCurrentTest =
4488 new pvplayer_async_test_genericreset(testparam,
4489 PVMF_MIME_YUV420,
4490 PVMF_MIME_PCM16,
4491 iCurrentTestNumber,
4492 true,
4493 false,
4494 true,
4495 false,
4496 false, STATE_ADDDATASOURCE);
4497 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4498 }
4499 break;
4500 case GenericReset_Init:
4501 {
4502 fprintf(file, "GenericReset_Init");
4503 iCurrentTest =
4504 new pvplayer_async_test_genericreset(testparam,
4505 PVMF_MIME_YUV420,
4506 PVMF_MIME_PCM16,
4507 iCurrentTestNumber,
4508 true,
4509 false,
4510 true,
4511 false,
4512 false, STATE_INIT);
4513 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4514 }
4515 break;
4516 case GenericReset_AddDataSinkVideo:
4517 {
4518 fprintf(file, "GenericReset_AddDataSinkVideo");
4519 iCurrentTest =
4520 new pvplayer_async_test_genericreset(testparam,
4521 PVMF_MIME_YUV420,
4522 PVMF_MIME_PCM16,
4523 iCurrentTestNumber,
4524 true,
4525 false,
4526 true,
4527 false,
4528 false, STATE_ADDDATASINK_VIDEO);
4529 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4530 }
4531 break;
4532 case GenericReset_AddDataSinkAudio:
4533 {
4534 fprintf(file, "GenericReset_AddDataSinkAudio");
4535 iCurrentTest =
4536 new pvplayer_async_test_genericreset(testparam,
4537 PVMF_MIME_YUV420,
4538 PVMF_MIME_PCM16,
4539 iCurrentTestNumber,
4540 true,
4541 false,
4542 true,
4543 false,
4544 false, STATE_ADDDATASINK_AUDIO);
4545 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4546 }
4547 break;
4548 case GenericReset_Prepare:
4549 {
4550 fprintf(file, "GenericReset_Prepare");
4551 iCurrentTest =
4552 new pvplayer_async_test_genericreset(testparam,
4553 PVMF_MIME_YUV420,
4554 PVMF_MIME_PCM16,
4555 iCurrentTestNumber,
4556 true,
4557 false,
4558 true,
4559 false,
4560 false, STATE_PREPARE);
4561 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4562 }
4563 break;
4564 case GenericReset_Start:
4565 {
4566 fprintf(file, "GenericReset_Start");
4567 iCurrentTest =
4568 new pvplayer_async_test_genericreset(testparam,
4569 PVMF_MIME_YUV420,
4570 PVMF_MIME_PCM16,
4571 iCurrentTestNumber,
4572 true,
4573 false,
4574 true,
4575 false,
4576 false, STATE_START);
4577 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4578 }
4579 break;
4580 case GenericReset_Pause:
4581 {
4582 fprintf(file, "GenericReset_Pause");
4583 iCurrentTest =
4584 new pvplayer_async_test_genericreset(testparam,
4585 PVMF_MIME_YUV420,
4586 PVMF_MIME_PCM16,
4587 iCurrentTestNumber,
4588 true,
4589 false,
4590 true,
4591 false,
4592 false, STATE_PAUSE);
4593 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4594 }
4595 break;
4596 case GenericReset_Resume:
4597 {
4598 fprintf(file, "GenericReset_Resume");
4599 iCurrentTest =
4600 new pvplayer_async_test_genericreset(testparam,
4601 PVMF_MIME_YUV420,
4602 PVMF_MIME_PCM16,
4603 iCurrentTestNumber,
4604 true,
4605 false,
4606 true,
4607 false,
4608 false, STATE_RESUME);
4609 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4610 }
4611 break;
4612 case GenericReset_Stop:
4613 {
4614 fprintf(file, "GenericReset_Stop");
4615 iCurrentTest =
4616 new pvplayer_async_test_genericreset(testparam,
4617 PVMF_MIME_YUV420,
4618 PVMF_MIME_PCM16,
4619 iCurrentTestNumber,
4620 false,
4621 false,
4622 false,
4623 false,
4624 false, STATE_STOP);
4625 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4626 }
4627 break;
4628
4629 case GenericReset_SetPlaybackRange:
4630 {
4631 fprintf(file, "GenericReset_SetPlaybackRange");
4632 iCurrentTest =
4633 new pvplayer_async_test_genericreset(testparam,
4634 PVMF_MIME_YUV420,
4635 PVMF_MIME_PCM16,
4636 iCurrentTestNumber,
4637 false,
4638 true,
4639 true,
4640 false,
4641 false, STATE_SETPLAYBACKRANGE);
4642 ((pvplayer_async_test_genericreset*)iCurrentTest)->setProtocolRollOverMode();
4643 }
4644 break;
4645 case GenericDelete_AddDataSource:
4646 {
4647 fprintf(file, "GenericDelete_AddDataSource");
4648 iCurrentTest =
4649 new pvplayer_async_test_genericdelete(testparam,
4650 PVMF_MIME_YUV420,
4651 PVMF_MIME_PCM16,
4652 iCurrentTestNumber,
4653 true,
4654 false,
4655 true,
4656 false,
4657 false, STATE_ADDDATASOURCE, false);
4658 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4659 }
4660 break;
4661 case GenericDelete_Init:
4662 {
4663 fprintf(file, "GenericDelete_Init");
4664 iCurrentTest =
4665 new pvplayer_async_test_genericdelete(testparam,
4666 PVMF_MIME_YUV420,
4667 PVMF_MIME_PCM16,
4668 iCurrentTestNumber,
4669 true,
4670 false,
4671 true,
4672 false,
4673 false, STATE_INIT, false);
4674 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4675 }
4676 break;
4677 case GenericDelete_AddDataSinkVideo:
4678 {
4679 fprintf(file, "GenericDelete_AddDataSinkVideo");
4680 iCurrentTest =
4681 new pvplayer_async_test_genericdelete(testparam,
4682 PVMF_MIME_YUV420,
4683 PVMF_MIME_PCM16,
4684 iCurrentTestNumber,
4685 true,
4686 false,
4687 true,
4688 false,
4689 false, STATE_ADDDATASINK_VIDEO, false);
4690 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4691 }
4692 break;
4693 case GenericDelete_AddDataSinkAudio:
4694 {
4695 fprintf(file, "GenericDelete_AddDataSinkAudio");
4696 iCurrentTest =
4697 new pvplayer_async_test_genericdelete(testparam,
4698 PVMF_MIME_YUV420,
4699 PVMF_MIME_PCM16,
4700 iCurrentTestNumber,
4701 true,
4702 false,
4703 true,
4704 false,
4705 false, STATE_ADDDATASINK_AUDIO, false);
4706 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4707 }
4708 break;
4709 case GenericDelete_Prepare:
4710 {
4711 fprintf(file, "GenericDelete_Prepare");
4712 iCurrentTest =
4713 new pvplayer_async_test_genericdelete(testparam,
4714 PVMF_MIME_YUV420,
4715 PVMF_MIME_PCM16,
4716 iCurrentTestNumber,
4717 true,
4718 false,
4719 true,
4720 false,
4721 false, STATE_PREPARE, false);
4722 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4723 }
4724 break;
4725 case GenericDelete_Start:
4726 {
4727 fprintf(file, "GenericDelete_Start");
4728 iCurrentTest =
4729 new pvplayer_async_test_genericdelete(testparam,
4730 PVMF_MIME_YUV420,
4731 PVMF_MIME_PCM16,
4732 iCurrentTestNumber,
4733 true,
4734 false,
4735 true,
4736 false,
4737 false, STATE_START, false);
4738 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4739 }
4740 break;
4741 case GenericDelete_Pause:
4742 {
4743 fprintf(file, "GenericDelete_Pause");
4744 iCurrentTest =
4745 new pvplayer_async_test_genericdelete(testparam,
4746 PVMF_MIME_YUV420,
4747 PVMF_MIME_PCM16,
4748 iCurrentTestNumber,
4749 true,
4750 false,
4751 true,
4752 false,
4753 false, STATE_PAUSE, false);
4754 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4755 }
4756 break;
4757 case GenericDelete_Resume:
4758 {
4759 fprintf(file, "GenericDelete_Resume");
4760 iCurrentTest =
4761 new pvplayer_async_test_genericdelete(testparam,
4762 PVMF_MIME_YUV420,
4763 PVMF_MIME_PCM16,
4764 iCurrentTestNumber,
4765 true,
4766 false,
4767 true,
4768 false,
4769 false, STATE_RESUME, false);
4770 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4771 }
4772 break;
4773 case GenericDelete_Stop:
4774 {
4775 fprintf(file, "GenericDelete_Stop");
4776 iCurrentTest =
4777 new pvplayer_async_test_genericdelete(testparam,
4778 PVMF_MIME_YUV420,
4779 PVMF_MIME_PCM16,
4780 iCurrentTestNumber,
4781 false,
4782 false,
4783 false,
4784 false,
4785 false, STATE_STOP, false);
4786 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4787 }
4788 break;
4789
4790 case GenericDelete_SetPlaybackRange:
4791 {
4792 fprintf(file, "GenericDelete_SetPlaybackRange");
4793 iCurrentTest =
4794 new pvplayer_async_test_genericdelete(testparam,
4795 PVMF_MIME_YUV420,
4796 PVMF_MIME_PCM16,
4797 iCurrentTestNumber,
4798 false,
4799 true,
4800 true,
4801 false,
4802 false, STATE_SETPLAYBACKRANGE, false);
4803 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4804 }
4805 break;
4806 case GenericDeleteWhileProc_AddDataSource:
4807 {
4808 fprintf(file, "GenericDeleteWhileProc_AddDataSource");
4809 iCurrentTest =
4810 new pvplayer_async_test_genericdelete(testparam,
4811 PVMF_MIME_YUV420,
4812 PVMF_MIME_PCM16,
4813 iCurrentTestNumber,
4814 true,
4815 false,
4816 true,
4817 false,
4818 false, STATE_ADDDATASOURCE, true);
4819 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4820 }
4821 break;
4822 case GenericDeleteWhileProc_Init:
4823 {
4824 fprintf(file, "GenericDeleteWhileProc_Init");
4825 iCurrentTest =
4826 new pvplayer_async_test_genericdelete(testparam,
4827 PVMF_MIME_YUV420,
4828 PVMF_MIME_PCM16,
4829 iCurrentTestNumber,
4830 true,
4831 false,
4832 true,
4833 false,
4834 false, STATE_INIT, true);
4835 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4836 }
4837 break;
4838 case GenericDeleteWhileProc_AddDataSinkVideo:
4839 {
4840 fprintf(file, "GenericDeleteWhileProc_AddDataSinkVideo");
4841 iCurrentTest =
4842 new pvplayer_async_test_genericdelete(testparam,
4843 PVMF_MIME_YUV420,
4844 PVMF_MIME_PCM16,
4845 iCurrentTestNumber,
4846 true,
4847 false,
4848 true,
4849 false,
4850 false, STATE_ADDDATASINK_VIDEO, true);
4851 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4852 }
4853 break;
4854 case GenericDeleteWhileProc_AddDataSinkAudio:
4855 {
4856 fprintf(file, "GenericDeleteWhileProc_AddDataSinkAudio");
4857 iCurrentTest =
4858 new pvplayer_async_test_genericdelete(testparam,
4859 PVMF_MIME_YUV420,
4860 PVMF_MIME_PCM16,
4861 iCurrentTestNumber,
4862 true,
4863 false,
4864 true,
4865 false,
4866 false, STATE_ADDDATASINK_AUDIO, true);
4867 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4868 }
4869 break;
4870 case GenericDeleteWhileProc_Prepare:
4871 {
4872 fprintf(file, "GenericDeleteWhileProc_Prepare");
4873 iCurrentTest =
4874 new pvplayer_async_test_genericdelete(testparam,
4875 PVMF_MIME_YUV420,
4876 PVMF_MIME_PCM16,
4877 iCurrentTestNumber,
4878 true,
4879 false,
4880 true,
4881 false,
4882 false, STATE_PREPARE, true);
4883 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4884 }
4885 break;
4886 case GenericDeleteWhileProc_Start:
4887 {
4888 fprintf(file, "GenericDeleteWhileProc_Start");
4889 iCurrentTest =
4890 new pvplayer_async_test_genericdelete(testparam,
4891 PVMF_MIME_YUV420,
4892 PVMF_MIME_PCM16,
4893 iCurrentTestNumber,
4894 true,
4895 false,
4896 true,
4897 false,
4898 false, STATE_START, true);
4899 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4900 }
4901 break;
4902 case GenericDeleteWhileProc_Pause:
4903 {
4904 fprintf(file, "GenericDeleteWhileProc_Pause");
4905 iCurrentTest =
4906 new pvplayer_async_test_genericdelete(testparam,
4907 PVMF_MIME_YUV420,
4908 PVMF_MIME_PCM16,
4909 iCurrentTestNumber,
4910 true,
4911 false,
4912 true,
4913 false,
4914 false, STATE_PAUSE, true);
4915 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4916 }
4917 break;
4918 case GenericDeleteWhileProc_Resume:
4919 {
4920 fprintf(file, "GenericDeleteWhileProc_Resume");
4921 iCurrentTest =
4922 new pvplayer_async_test_genericdelete(testparam,
4923 PVMF_MIME_YUV420,
4924 PVMF_MIME_PCM16,
4925 iCurrentTestNumber,
4926 true,
4927 false,
4928 true,
4929 false,
4930 false, STATE_RESUME, true);
4931 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4932 }
4933 break;
4934 case GenericDeleteWhileProc_Stop:
4935 {
4936 fprintf(file, "GenericDeleteWhileProc_Stop");
4937 iCurrentTest =
4938 new pvplayer_async_test_genericdelete(testparam,
4939 PVMF_MIME_YUV420,
4940 PVMF_MIME_PCM16,
4941 iCurrentTestNumber,
4942 false,
4943 false,
4944 false,
4945 false,
4946 false, STATE_STOP, true);
4947 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4948 }
4949 break;
4950 case GenericDeleteWhileProc_SetPlaybackRange:
4951 {
4952 fprintf(file, "GenericDeleteWhileProc_SetPlaybackRange");
4953 iCurrentTest =
4954 new pvplayer_async_test_genericdelete(testparam,
4955 PVMF_MIME_YUV420,
4956 PVMF_MIME_PCM16,
4957 iCurrentTestNumber,
4958 false,
4959 true,
4960 true,
4961 false,
4962 false, STATE_SETPLAYBACKRANGE, true);
4963 ((pvplayer_async_test_genericdelete*)iCurrentTest)->setProtocolRollOverMode();
4964 }
4965 break;
4966 case GenericCancelAll_AddDataSource:
4967 {
4968 fprintf(file, "GenericCancelAll_AddDataSource");
4969 iCurrentTest =
4970 new pvplayer_async_test_genericcancelall(testparam,
4971 PVMF_MIME_YUV420,
4972 PVMF_MIME_PCM16,
4973 iCurrentTestNumber,
4974 true,
4975 false,
4976 true,
4977 false,
4978 false, STATE_ADDDATASOURCE, false);
4979 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
4980 }
4981 break;
4982 case GenericCancelAll_Init:
4983 {
4984 fprintf(file, "GenericCancelAll_Init");
4985 iCurrentTest =
4986 new pvplayer_async_test_genericcancelall(testparam,
4987 PVMF_MIME_YUV420,
4988 PVMF_MIME_PCM16,
4989 iCurrentTestNumber,
4990 true,
4991 false,
4992 true,
4993 false,
4994 false, STATE_INIT, false);
4995 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
4996 }
4997 break;
4998 case GenericCancelAll_AddDataSinkVideo:
4999 {
5000 fprintf(file, "GenericCancelAll_AddDataSinkVideo");
5001 iCurrentTest =
5002 new pvplayer_async_test_genericcancelall(testparam,
5003 PVMF_MIME_YUV420,
5004 PVMF_MIME_PCM16,
5005 iCurrentTestNumber,
5006 true,
5007 false,
5008 true,
5009 false,
5010 false, STATE_ADDDATASINK_VIDEO, false);
5011 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5012 }
5013 break;
5014 case GenericCancelAll_AddDataSinkAudio:
5015 {
5016 fprintf(file, "GenericCancelAll_AddDataSinkAudio");
5017 iCurrentTest =
5018 new pvplayer_async_test_genericcancelall(testparam,
5019 PVMF_MIME_YUV420,
5020 PVMF_MIME_PCM16,
5021 iCurrentTestNumber,
5022 true,
5023 false,
5024 true,
5025 false,
5026 false, STATE_ADDDATASINK_AUDIO, false);
5027
5028 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5029 }
5030 break;
5031 case GenericCancelAll_Prepare:
5032 {
5033 fprintf(file, "GenericCancelAll_Prepare");
5034 iCurrentTest =
5035 new pvplayer_async_test_genericcancelall(testparam,
5036 PVMF_MIME_YUV420,
5037 PVMF_MIME_PCM16,
5038 iCurrentTestNumber,
5039 true,
5040 false,
5041 true,
5042 false,
5043 false, STATE_PREPARE, false);
5044 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5045 }
5046 break;
5047 case GenericCancelAll_Start:
5048 {
5049 fprintf(file, "GenericCancelAll_Start");
5050 iCurrentTest =
5051 new pvplayer_async_test_genericcancelall(testparam,
5052 PVMF_MIME_YUV420,
5053 PVMF_MIME_PCM16,
5054 iCurrentTestNumber,
5055 true,
5056 false,
5057 true,
5058 false,
5059 false, STATE_START, false);
5060 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5061 }
5062 break;
5063 case GenericCancelAll_Pause:
5064 {
5065 fprintf(file, "GenericCancelAll_Pause");
5066 iCurrentTest =
5067 new pvplayer_async_test_genericcancelall(testparam,
5068 PVMF_MIME_YUV420,
5069 PVMF_MIME_PCM16,
5070 iCurrentTestNumber,
5071 true,
5072 false,
5073 true,
5074 false,
5075 false, STATE_PAUSE, false);
5076 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5077 }
5078 break;
5079 case GenericCancelAll_Resume:
5080 {
5081 fprintf(file, "GenericCancelAll_Resume");
5082 iCurrentTest =
5083 new pvplayer_async_test_genericcancelall(testparam,
5084 PVMF_MIME_YUV420,
5085 PVMF_MIME_PCM16,
5086 iCurrentTestNumber,
5087 true,
5088 false,
5089 true,
5090 false,
5091 false, STATE_RESUME, false);
5092 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5093 }
5094 break;
5095 case GenericCancelAll_Stop:
5096 {
5097 fprintf(file, "GenericCancelAll_Stop");
5098 iCurrentTest =
5099 new pvplayer_async_test_genericcancelall(testparam,
5100 PVMF_MIME_YUV420,
5101 PVMF_MIME_PCM16,
5102 iCurrentTestNumber,
5103 false,
5104 false,
5105 false,
5106 false,
5107 false, STATE_STOP, false);
5108 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5109 }
5110 break;
5111 case GenericCancelAll_SetPlaybackRange:
5112 {
5113 fprintf(file, "GenericCancelAll_SetPlaybackRange");
5114 iCurrentTest =
5115 new pvplayer_async_test_genericcancelall(testparam,
5116 PVMF_MIME_YUV420,
5117 PVMF_MIME_PCM16,
5118 iCurrentTestNumber,
5119 false,
5120 true,
5121 true,
5122 false,
5123 false, STATE_SETPLAYBACKRANGE, false);
5124 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5125 }
5126 break;
5127 case GenericCancelAllWhileProc_AddDataSource:
5128 {
5129 fprintf(file, "GenericCancelAllWhileProc_AddDataSource");
5130 iCurrentTest =
5131 new pvplayer_async_test_genericcancelall(testparam,
5132 PVMF_MIME_YUV420,
5133 PVMF_MIME_PCM16,
5134 iCurrentTestNumber,
5135 true,
5136 false,
5137 true,
5138 false,
5139 false, STATE_ADDDATASOURCE, true);
5140 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5141 }
5142 break;
5143 case GenericCancelAllWhileProc_Init:
5144 {
5145 fprintf(file, "GenericCancelAllWhileProc_Init");
5146 iCurrentTest =
5147 new pvplayer_async_test_genericcancelall(testparam,
5148 PVMF_MIME_YUV420,
5149 PVMF_MIME_PCM16,
5150 iCurrentTestNumber,
5151 true,
5152 false,
5153 true,
5154 false,
5155 false, STATE_INIT, true);
5156 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5157 }
5158 break;
5159 case GenericCancelAllWhileProc_AddDataSinkVideo:
5160 {
5161 fprintf(file, "GenericCancelAllWhileProc_AddDataSinkVideo");
5162 iCurrentTest =
5163 new pvplayer_async_test_genericcancelall(testparam,
5164 PVMF_MIME_YUV420,
5165 PVMF_MIME_PCM16,
5166 iCurrentTestNumber,
5167 true,
5168 false,
5169 true,
5170 false,
5171 false, STATE_ADDDATASINK_VIDEO, true);
5172 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5173 }
5174 break;
5175 case GenericCancelAllWhileProc_AddDataSinkAudio:
5176 {
5177 fprintf(file, "GenericCancelAllWhileProc_AddDataSinkAudio");
5178 iCurrentTest =
5179 new pvplayer_async_test_genericcancelall(testparam,
5180 PVMF_MIME_YUV420,
5181 PVMF_MIME_PCM16,
5182 iCurrentTestNumber,
5183 true,
5184 false,
5185 true,
5186 false,
5187 false, STATE_ADDDATASINK_AUDIO, true);
5188 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5189 }
5190 break;
5191 case GenericCancelAllWhileProc_Prepare:
5192 {
5193 fprintf(file, "GenericCancelAllWhileProc_Prepare");
5194 iCurrentTest =
5195 new pvplayer_async_test_genericcancelall(testparam,
5196 PVMF_MIME_YUV420,
5197 PVMF_MIME_PCM16,
5198 iCurrentTestNumber,
5199 true,
5200 false,
5201 true,
5202 false,
5203 false, STATE_PREPARE, true);
5204 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5205 }
5206 break;
5207 case GenericCancelAllWhileProc_Start:
5208 {
5209 fprintf(file, "GenericCancelAllWhileProc_Start");
5210 iCurrentTest =
5211 new pvplayer_async_test_genericcancelall(testparam,
5212 PVMF_MIME_YUV420,
5213 PVMF_MIME_PCM16,
5214 iCurrentTestNumber,
5215 true,
5216 false,
5217 true,
5218 false,
5219 false, STATE_START, true);
5220 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5221 }
5222 break;
5223 case GenericCancelAllWhileProc_Pause:
5224 {
5225 fprintf(file, "GenericCancelAllWhileProc_Pause");
5226 iCurrentTest =
5227 new pvplayer_async_test_genericcancelall(testparam,
5228 PVMF_MIME_YUV420,
5229 PVMF_MIME_PCM16,
5230 iCurrentTestNumber,
5231 true,
5232 false,
5233 true,
5234 false,
5235 false, STATE_PAUSE, true);
5236 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5237 }
5238 break;
5239 case GenericCancelAllWhileProc_Resume:
5240 {
5241 fprintf(file, "GenericCancelAllWhileProc_Resume");
5242 iCurrentTest =
5243 new pvplayer_async_test_genericcancelall(testparam,
5244 PVMF_MIME_YUV420,
5245 PVMF_MIME_PCM16,
5246 iCurrentTestNumber,
5247 true,
5248 false,
5249 true,
5250 false,
5251 false, STATE_RESUME, true);
5252 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5253 }
5254 break;
5255 case GenericCancelAllWhileProc_Stop:
5256 {
5257 fprintf(file, "GenericCancelAllWhileProc_Stop");
5258 iCurrentTest =
5259 new pvplayer_async_test_genericcancelall(testparam,
5260 PVMF_MIME_YUV420,
5261 PVMF_MIME_PCM16,
5262 iCurrentTestNumber,
5263 false,
5264 false,
5265 false,
5266 false,
5267 false, STATE_STOP, true);
5268 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5269 }
5270 break;
5271 case GenericCancelAllWhileProc_SetPlaybackRange:
5272 {
5273 fprintf(file, "GenericCancelAllWhileProc_SetPlaybackRange");
5274 iCurrentTest =
5275 new pvplayer_async_test_genericcancelall(testparam,
5276 PVMF_MIME_YUV420,
5277 PVMF_MIME_PCM16,
5278 iCurrentTestNumber,
5279 false,
5280 true,
5281 true,
5282 false,
5283 false, STATE_SETPLAYBACKRANGE, true);
5284 ((pvplayer_async_test_genericcancelall*)iCurrentTest)->setProtocolRollOverMode();
5285 }
5286 break;
5287
5288 case GenericNetworkDisconnect_AddDataSource:
5289 {
5290 fprintf(file, "GenericNetworkDisconnect_AddDataSource");
5291 iCurrentTest =
5292 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5293 PVMF_MIME_YUV420,
5294 PVMF_MIME_PCM16,
5295 iCurrentTestNumber,
5296 false,
5297 false,
5298 true,
5299 false,
5300 false, STATE_ADDDATASOURCE, false);
5301 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5302 }
5303 break;
5304 case GenericNetworkDisconnect_Init:
5305 {
5306 fprintf(file, "GenericNetworkDisconnect_Init");
5307 iCurrentTest =
5308 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5309 PVMF_MIME_YUV420,
5310 PVMF_MIME_PCM16,
5311 iCurrentTestNumber,
5312 false,
5313 false,
5314 true,
5315 false,
5316 false, STATE_INIT, false);
5317 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5318 }
5319 break;
5320 case GenericNetworkDisconnect_AddDataSinkVideo:
5321 {
5322 fprintf(file, "GenericNetworkDisconnect_AddDataSinkVideo");
5323 iCurrentTest =
5324 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5325 PVMF_MIME_YUV420,
5326 PVMF_MIME_PCM16,
5327 iCurrentTestNumber,
5328 false,
5329 false,
5330 true,
5331 false,
5332 false, STATE_ADDDATASINK_VIDEO, false);
5333 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5334 }
5335 break;
5336 case GenericNetworkDisconnect_AddDataSinkAudio:
5337 {
5338 fprintf(file, "GenericNetworkDisconnect_AddDataSinkAudio");
5339 iCurrentTest =
5340 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5341 PVMF_MIME_YUV420,
5342 PVMF_MIME_PCM16,
5343 iCurrentTestNumber,
5344 false,
5345 false,
5346 true,
5347 false,
5348 false, STATE_ADDDATASINK_AUDIO, false);
5349
5350 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5351 }
5352 break;
5353 case GenericNetworkDisconnect_Prepare:
5354 {
5355 fprintf(file, "GenericNetworkDisconnect_Prepare");
5356 iCurrentTest =
5357 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5358 PVMF_MIME_YUV420,
5359 PVMF_MIME_PCM16,
5360 iCurrentTestNumber,
5361 false,
5362 false,
5363 true,
5364 false,
5365 false, STATE_PREPARE, false);
5366 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5367 }
5368 break;
5369 case GenericNetworkDisconnect_Start:
5370 {
5371 fprintf(file, "GenericNetworkDisconnect_Start");
5372 iCurrentTest =
5373 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5374 PVMF_MIME_YUV420,
5375 PVMF_MIME_PCM16,
5376 iCurrentTestNumber,
5377 false,
5378 false,
5379 true,
5380 false,
5381 false, STATE_START, false);
5382 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5383 }
5384 break;
5385 case GenericNetworkDisconnect_Pause:
5386 {
5387 fprintf(file, "GenericNetworkDisconnect_Pause");
5388 iCurrentTest =
5389 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5390 PVMF_MIME_YUV420,
5391 PVMF_MIME_PCM16,
5392 iCurrentTestNumber,
5393 true,
5394 false,
5395 true,
5396 false,
5397 false, STATE_PAUSE, false);
5398 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5399 }
5400 break;
5401 case GenericNetworkDisconnect_Resume:
5402 {
5403 fprintf(file, "GenericNetworkDisconnect_Resume");
5404 iCurrentTest =
5405 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5406 PVMF_MIME_YUV420,
5407 PVMF_MIME_PCM16,
5408 iCurrentTestNumber,
5409 true,
5410 false,
5411 true,
5412 false,
5413 false, STATE_RESUME, false);
5414 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5415 }
5416 break;
5417 case GenericNetworkDisconnect_Stop:
5418 {
5419 fprintf(file, "GenericNetworkDisconnect_Stop");
5420 iCurrentTest =
5421 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5422 PVMF_MIME_YUV420,
5423 PVMF_MIME_PCM16,
5424 iCurrentTestNumber,
5425 false,
5426 false,
5427 false,
5428 false,
5429 false, STATE_STOP, false);
5430 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5431 }
5432 break;
5433
5434 case GenericNetworkDisconnect_SetPlaybackRange:
5435 {
5436 fprintf(file, "GenericNetworkDisconnect_SetPlaybackRange");
5437 iCurrentTest =
5438 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5439 PVMF_MIME_YUV420,
5440 PVMF_MIME_PCM16,
5441 iCurrentTestNumber,
5442 false,
5443 true,
5444 true,
5445 false,
5446 false, STATE_SETPLAYBACKRANGE, false);
5447 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5448 }
5449 break;
5450 case GenericNetworkDisconnectWhileProc_AddDataSource:
5451 {
5452 fprintf(file, "GenericNetworkDisconnectWhileProc_AddDataSource");
5453 iCurrentTest =
5454 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5455 PVMF_MIME_YUV420,
5456 PVMF_MIME_PCM16,
5457 iCurrentTestNumber,
5458 false,
5459 false,
5460 true,
5461 false,
5462 false, STATE_ADDDATASOURCE, true);
5463 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5464 }
5465 break;
5466 case GenericNetworkDisconnectWhileProc_Init:
5467 {
5468 fprintf(file, "GenericNetworkDisconnectWhileProc_Init");
5469 iCurrentTest =
5470 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5471 PVMF_MIME_YUV420,
5472 PVMF_MIME_PCM16,
5473 iCurrentTestNumber,
5474 false,
5475 false,
5476 true,
5477 false,
5478 false, STATE_INIT, true);
5479 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5480 }
5481 break;
5482 case GenericNetworkDisconnectWhileProc_AddDataSinkVideo:
5483 {
5484 fprintf(file, "GenericNetworkDisconnectWhileProc_AddDataSinkVideo");
5485 iCurrentTest =
5486 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5487 PVMF_MIME_YUV420,
5488 PVMF_MIME_PCM16,
5489 iCurrentTestNumber,
5490 false,
5491 false,
5492 true,
5493 false,
5494 false, STATE_ADDDATASINK_VIDEO, true);
5495 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5496 }
5497 break;
5498 case GenericNetworkDisconnectWhileProc_AddDataSinkAudio:
5499 {
5500 fprintf(file, "GenericNetworkDisconnectWhileProc_AddDataSinkAudio");
5501 iCurrentTest =
5502 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5503 PVMF_MIME_YUV420,
5504 PVMF_MIME_PCM16,
5505 iCurrentTestNumber,
5506 false,
5507 false,
5508 true,
5509 false,
5510 false, STATE_ADDDATASINK_AUDIO, true);
5511 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5512 }
5513 break;
5514 case GenericNetworkDisconnectWhileProc_Prepare:
5515 {
5516 fprintf(file, "GenericNetworkDisconnectWhileProc_Prepare");
5517 iCurrentTest =
5518 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5519 PVMF_MIME_YUV420,
5520 PVMF_MIME_PCM16,
5521 iCurrentTestNumber,
5522 false,
5523 false,
5524 true,
5525 false,
5526 false, STATE_PREPARE, true);
5527 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5528 }
5529 break;
5530 case GenericNetworkDisconnectWhileProc_Start:
5531 {
5532 fprintf(file, "GenericNetworkDisconnectWhileProc_Start");
5533 iCurrentTest =
5534 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5535 PVMF_MIME_YUV420,
5536 PVMF_MIME_PCM16,
5537 iCurrentTestNumber,
5538 false,
5539 false,
5540 true,
5541 false,
5542 false, STATE_START, true);
5543 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5544 }
5545 break;
5546 case GenericNetworkDisconnectWhileProc_Pause:
5547 {
5548 fprintf(file, "GenericNetworkDisconnectWhileProc_Pause");
5549 iCurrentTest =
5550 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5551 PVMF_MIME_YUV420,
5552 PVMF_MIME_PCM16,
5553 iCurrentTestNumber,
5554 true,
5555 false,
5556 true,
5557 false,
5558 false, STATE_PAUSE, true);
5559 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5560 }
5561 break;
5562 case GenericNetworkDisconnectWhileProc_Resume:
5563 {
5564 fprintf(file, "GenericNetworkDisconnectWhileProc_Resume");
5565 iCurrentTest =
5566 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5567 PVMF_MIME_YUV420,
5568 PVMF_MIME_PCM16,
5569 iCurrentTestNumber,
5570 true,
5571 false,
5572 true,
5573 false,
5574 false, STATE_RESUME, true);
5575 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5576 }
5577 break;
5578 case GenericNetworkDisconnectWhileProc_Stop:
5579 {
5580 fprintf(file, "GenericNetworkDisconnectWhileProc_Stop");
5581 iCurrentTest =
5582 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5583 PVMF_MIME_YUV420,
5584 PVMF_MIME_PCM16,
5585 iCurrentTestNumber,
5586 false,
5587 false,
5588 false,
5589 false,
5590 false, STATE_STOP, true);
5591 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5592 }
5593 break;
5594 case GenericNetworkDisconnectWhileProc_SetPlaybackRange:
5595 {
5596 fprintf(file, "GenericNetworkDisconnectWhileProc_SetPlaybackRange");
5597 iCurrentTest =
5598 new pvplayer_async_test_genericnetworkdisconnect(testparam,
5599 PVMF_MIME_YUV420,
5600 PVMF_MIME_PCM16,
5601 iCurrentTestNumber,
5602 false,
5603 true,
5604 true,
5605 false,
5606 false, STATE_SETPLAYBACKRANGE, true);
5607 ((pvplayer_async_test_genericnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5608 }
5609 break;
5610
5611 case GenericNetworkDisconnectReconnect_AddDataSource:
5612 {
5613 fprintf(file, "GenericNetworkDisconnectReconnect_AddDataSource");
5614 iCurrentTest =
5615 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5616 PVMF_MIME_YUV420,
5617 PVMF_MIME_PCM16,
5618 iCurrentTestNumber,
5619 false,
5620 false,
5621 true,
5622 false,
5623 false, STATE_ADDDATASOURCE, false);
5624 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5625 }
5626 break;
5627 case GenericNetworkDisconnectReconnect_Init:
5628 {
5629 fprintf(file, "GenericNetworkDisconnectReconnect_Init");
5630 iCurrentTest =
5631 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5632 PVMF_MIME_YUV420,
5633 PVMF_MIME_PCM16,
5634 iCurrentTestNumber,
5635 false,
5636 false,
5637 true,
5638 false,
5639 false, STATE_INIT, false);
5640 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5641 }
5642 break;
5643 case GenericNetworkDisconnectReconnect_AddDataSinkVideo:
5644 {
5645 fprintf(file, "GenericNetworkDisconnectReconnect_AddDataSinkVideo");
5646 iCurrentTest =
5647 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5648 PVMF_MIME_YUV420,
5649 PVMF_MIME_PCM16,
5650 iCurrentTestNumber,
5651 false,
5652 false,
5653 true,
5654 false,
5655 false, STATE_ADDDATASINK_VIDEO, false);
5656 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5657 }
5658 break;
5659 case GenericNetworkDisconnectReconnect_AddDataSinkAudio:
5660 {
5661 fprintf(file, "GenericNetworkDisconnectReconnect_AddDataSinkAudio");
5662 iCurrentTest =
5663 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5664 PVMF_MIME_YUV420,
5665 PVMF_MIME_PCM16,
5666 iCurrentTestNumber,
5667 false,
5668 false,
5669 true,
5670 false,
5671 false, STATE_ADDDATASINK_AUDIO, false);
5672
5673 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5674 }
5675 break;
5676 case GenericNetworkDisconnectReconnect_Prepare:
5677 {
5678 fprintf(file, "GenericNetworkDisconnectReconnect_Prepare");
5679 iCurrentTest =
5680 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5681 PVMF_MIME_YUV420,
5682 PVMF_MIME_PCM16,
5683 iCurrentTestNumber,
5684 false,
5685 false,
5686 true,
5687 false,
5688 false, STATE_PREPARE, false);
5689 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5690 }
5691 break;
5692 case GenericNetworkDisconnectReconnect_Start:
5693 {
5694 fprintf(file, "GenericNetworkDisconnectReconnect_Start");
5695 iCurrentTest =
5696 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5697 PVMF_MIME_YUV420,
5698 PVMF_MIME_PCM16,
5699 iCurrentTestNumber,
5700 false,
5701 false,
5702 true,
5703 false,
5704 false, STATE_START, false);
5705 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5706 }
5707 break;
5708 case GenericNetworkDisconnectReconnect_Pause:
5709 {
5710 fprintf(file, "GenericNetworkDisconnectReconnect_Pause");
5711 iCurrentTest =
5712 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5713 PVMF_MIME_YUV420,
5714 PVMF_MIME_PCM16,
5715 iCurrentTestNumber,
5716 true,
5717 false,
5718 true,
5719 false,
5720 false, STATE_PAUSE, false);
5721 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5722 }
5723 break;
5724 case GenericNetworkDisconnectReconnect_Resume:
5725 {
5726 fprintf(file, "GenericNetworkDisconnectReconnect_Resume");
5727 iCurrentTest =
5728 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5729 PVMF_MIME_YUV420,
5730 PVMF_MIME_PCM16,
5731 iCurrentTestNumber,
5732 true,
5733 false,
5734 true,
5735 false,
5736 false, STATE_RESUME, false);
5737 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5738 }
5739 break;
5740 case GenericNetworkDisconnectReconnect_Stop:
5741 {
5742 fprintf(file, "GenericNetworkDisconnectReconnect_Stop");
5743 iCurrentTest =
5744 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5745 PVMF_MIME_YUV420,
5746 PVMF_MIME_PCM16,
5747 iCurrentTestNumber,
5748 false,
5749 false,
5750 false,
5751 false,
5752 false, STATE_STOP, false);
5753 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5754 }
5755 break;
5756
5757 case GenericNetworkDisconnectReconnect_SetPlaybackRange:
5758 {
5759 fprintf(file, "GenericNetworkDisconnectReconnect_SetPlaybackRange");
5760 iCurrentTest =
5761 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5762 PVMF_MIME_YUV420,
5763 PVMF_MIME_PCM16,
5764 iCurrentTestNumber,
5765 false,
5766 true,
5767 true,
5768 false,
5769 false, STATE_SETPLAYBACKRANGE, false);
5770 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5771 }
5772 break;
5773 case GenericNetworkDisconnectReconnectWhileProc_AddDataSource:
5774 {
5775 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_AddDataSource");
5776 iCurrentTest =
5777 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5778 PVMF_MIME_YUV420,
5779 PVMF_MIME_PCM16,
5780 iCurrentTestNumber,
5781 false,
5782 false,
5783 true,
5784 false,
5785 false, STATE_ADDDATASOURCE, true);
5786 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5787 }
5788 break;
5789 case GenericNetworkDisconnectReconnectWhileProc_Init:
5790 {
5791 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_Init");
5792 iCurrentTest =
5793 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5794 PVMF_MIME_YUV420,
5795 PVMF_MIME_PCM16,
5796 iCurrentTestNumber,
5797 false,
5798 false,
5799 true,
5800 false,
5801 false, STATE_INIT, true);
5802 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5803 }
5804 break;
5805 case GenericNetworkDisconnectReconnectWhileProc_AddDataSinkVideo:
5806 {
5807 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_AddDataSinkVideo");
5808 iCurrentTest =
5809 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5810 PVMF_MIME_YUV420,
5811 PVMF_MIME_PCM16,
5812 iCurrentTestNumber,
5813 false,
5814 false,
5815 true,
5816 false,
5817 false, STATE_ADDDATASINK_VIDEO, true);
5818 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5819 }
5820 break;
5821 case GenericNetworkDisconnectReconnectWhileProc_AddDataSinkAudio:
5822 {
5823 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_AddDataSinkAudio");
5824 iCurrentTest =
5825 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5826 PVMF_MIME_YUV420,
5827 PVMF_MIME_PCM16,
5828 iCurrentTestNumber,
5829 false,
5830 false,
5831 true,
5832 false,
5833 false, STATE_ADDDATASINK_AUDIO, true);
5834 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5835 }
5836 break;
5837 case GenericNetworkDisconnectReconnectWhileProc_Prepare:
5838 {
5839 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_Prepare");
5840 iCurrentTest =
5841 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5842 PVMF_MIME_YUV420,
5843 PVMF_MIME_PCM16,
5844 iCurrentTestNumber,
5845 false,
5846 false,
5847 true,
5848 false,
5849 false, STATE_PREPARE, true);
5850 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5851 }
5852 break;
5853 case GenericNetworkDisconnectReconnectWhileProc_Start:
5854 {
5855 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_Start");
5856 iCurrentTest =
5857 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5858 PVMF_MIME_YUV420,
5859 PVMF_MIME_PCM16,
5860 iCurrentTestNumber,
5861 false,
5862 false,
5863 true,
5864 false,
5865 false, STATE_START, true);
5866 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5867 }
5868 break;
5869 case GenericNetworkDisconnectReconnectWhileProc_Pause:
5870 {
5871 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_Pause");
5872 iCurrentTest =
5873 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5874 PVMF_MIME_YUV420,
5875 PVMF_MIME_PCM16,
5876 iCurrentTestNumber,
5877 true,
5878 false,
5879 true,
5880 false,
5881 false, STATE_PAUSE, true);
5882 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5883 }
5884 break;
5885 case GenericNetworkDisconnectReconnectWhileProc_Resume:
5886 {
5887 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_Resume");
5888 iCurrentTest =
5889 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5890 PVMF_MIME_YUV420,
5891 PVMF_MIME_PCM16,
5892 iCurrentTestNumber,
5893 true,
5894 false,
5895 true,
5896 false,
5897 false, STATE_RESUME, true);
5898 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5899 }
5900 break;
5901 case GenericNetworkDisconnectReconnectWhileProc_Stop:
5902 {
5903 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_Stop");
5904 iCurrentTest =
5905 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5906 PVMF_MIME_YUV420,
5907 PVMF_MIME_PCM16,
5908 iCurrentTestNumber,
5909 false,
5910 false,
5911 false,
5912 false,
5913 false, STATE_STOP, true);
5914 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5915 }
5916 break;
5917
5918 case GenericNetworkDisconnectReconnectWhileProc_SetPlaybackRange:
5919 {
5920 fprintf(file, "GenericNetworkDisconnectReconnectWhileProc_SetPlaybackRange");
5921 iCurrentTest =
5922 new pvplayer_async_test_genericnetworkdisconnectreconnect(testparam,
5923 PVMF_MIME_YUV420,
5924 PVMF_MIME_PCM16,
5925 iCurrentTestNumber,
5926 false,
5927 true,
5928 true,
5929 false,
5930 false, STATE_SETPLAYBACKRANGE, true);
5931 ((pvplayer_async_test_genericnetworkdisconnectreconnect*)iCurrentTest)->setProtocolRollOverMode();
5932 }
5933 break;
5934
5935 case GenericNetworkDisconnectCancelAll_AddDataSource:
5936 {
5937 fprintf(file, "GenericNetworkDisconnectCancelAll_AddDataSource");
5938 iCurrentTest =
5939 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
5940 PVMF_MIME_YUV420,
5941 PVMF_MIME_PCM16,
5942 iCurrentTestNumber,
5943 false,
5944 false,
5945 true,
5946 false,
5947 false, STATE_ADDDATASOURCE, false);
5948 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5949 }
5950 break;
5951 case GenericNetworkDisconnectCancelAll_Init:
5952 {
5953 fprintf(file, "GenericNetworkDisconnectCancelAll_Init");
5954 iCurrentTest =
5955 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
5956 PVMF_MIME_YUV420,
5957 PVMF_MIME_PCM16,
5958 iCurrentTestNumber,
5959 false,
5960 false,
5961 true,
5962 false,
5963 false, STATE_INIT, false);
5964 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5965 }
5966 break;
5967 case GenericNetworkDisconnectCancelAll_AddDataSinkVideo:
5968 {
5969 fprintf(file, "GenericNetworkDisconnectCancelAll_AddDataSinkVideo");
5970 iCurrentTest =
5971 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
5972 PVMF_MIME_YUV420,
5973 PVMF_MIME_PCM16,
5974 iCurrentTestNumber,
5975 false,
5976 false,
5977 true,
5978 false,
5979 false, STATE_ADDDATASINK_VIDEO, false);
5980 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5981 }
5982 break;
5983 case GenericNetworkDisconnectCancelAll_AddDataSinkAudio:
5984 {
5985 fprintf(file, "GenericNetworkDisconnectCancelAll_AddDataSinkAudio");
5986 iCurrentTest =
5987 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
5988 PVMF_MIME_YUV420,
5989 PVMF_MIME_PCM16,
5990 iCurrentTestNumber,
5991 false,
5992 false,
5993 true,
5994 false,
5995 false, STATE_ADDDATASINK_AUDIO, false);
5996
5997 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
5998 }
5999 break;
6000 case GenericNetworkDisconnectCancelAll_Prepare:
6001 {
6002 fprintf(file, "GenericNetworkDisconnectCancelAll_Prepare");
6003 iCurrentTest =
6004 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6005 PVMF_MIME_YUV420,
6006 PVMF_MIME_PCM16,
6007 iCurrentTestNumber,
6008 false,
6009 false,
6010 true,
6011 false,
6012 false, STATE_PREPARE, false);
6013 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6014 }
6015 break;
6016 case GenericNetworkDisconnectCancelAll_Start:
6017 {
6018 fprintf(file, "GenericNetworkDisconnectCancelAll_Start");
6019 iCurrentTest =
6020 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6021 PVMF_MIME_YUV420,
6022 PVMF_MIME_PCM16,
6023 iCurrentTestNumber,
6024 false,
6025 false,
6026 true,
6027 false,
6028 false, STATE_START, false);
6029 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6030 }
6031 break;
6032 case GenericNetworkDisconnectCancelAll_Pause:
6033 {
6034 fprintf(file, "GenericNetworkDisconnectCancelAll_Pause");
6035 iCurrentTest =
6036 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6037 PVMF_MIME_YUV420,
6038 PVMF_MIME_PCM16,
6039 iCurrentTestNumber,
6040 true,
6041 false,
6042 true,
6043 false,
6044 false, STATE_PAUSE, false);
6045 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6046 }
6047 break;
6048 case GenericNetworkDisconnectCancelAll_Resume:
6049 {
6050 fprintf(file, "GenericNetworkDisconnectCancelAll_Resume");
6051 iCurrentTest =
6052 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6053 PVMF_MIME_YUV420,
6054 PVMF_MIME_PCM16,
6055 iCurrentTestNumber,
6056 true,
6057 false,
6058 true,
6059 false,
6060 false, STATE_RESUME, false);
6061 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6062 }
6063 break;
6064 case GenericNetworkDisconnectCancelAll_Stop:
6065 {
6066 fprintf(file, "GenericNetworkDisconnectCancelAll_Stop");
6067 iCurrentTest =
6068 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6069 PVMF_MIME_YUV420,
6070 PVMF_MIME_PCM16,
6071 iCurrentTestNumber,
6072 false,
6073 false,
6074 false,
6075 false,
6076 false, STATE_STOP, false);
6077 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6078 }
6079 break;
6080 case GenericNetworkDisconnectCancelAll_SetPlaybackRange:
6081 {
6082 fprintf(file, "GenericNetworkDisconnectCancelAll_SetPlaybackRange");
6083 iCurrentTest =
6084 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6085 PVMF_MIME_YUV420,
6086 PVMF_MIME_PCM16,
6087 iCurrentTestNumber,
6088 false,
6089 true,
6090 true,
6091 false,
6092 false, STATE_SETPLAYBACKRANGE, false);
6093 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6094 }
6095 break;
6096 case GenericNetworkDisconnectCancelAllWhileProc_AddDataSource:
6097 {
6098 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_AddDataSource");
6099 iCurrentTest =
6100 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6101 PVMF_MIME_YUV420,
6102 PVMF_MIME_PCM16,
6103 iCurrentTestNumber,
6104 false,
6105 false,
6106 true,
6107 false,
6108 false, STATE_ADDDATASOURCE, true);
6109 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6110 }
6111 break;
6112 case GenericNetworkDisconnectCancelAllWhileProc_Init:
6113 {
6114 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_Init");
6115 iCurrentTest =
6116 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6117 PVMF_MIME_YUV420,
6118 PVMF_MIME_PCM16,
6119 iCurrentTestNumber,
6120 false,
6121 false,
6122 true,
6123 false,
6124 false, STATE_INIT, true);
6125 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6126 }
6127 break;
6128 case GenericNetworkDisconnectCancelAllWhileProc_AddDataSinkVideo:
6129 {
6130 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_AddDataSinkVideo");
6131 iCurrentTest =
6132 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6133 PVMF_MIME_YUV420,
6134 PVMF_MIME_PCM16,
6135 iCurrentTestNumber,
6136 false,
6137 false,
6138 true,
6139 false,
6140 false, STATE_ADDDATASINK_VIDEO, true);
6141 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6142 }
6143 break;
6144 case GenericNetworkDisconnectCancelAllWhileProc_AddDataSinkAudio:
6145 {
6146 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_AddDataSinkAudio");
6147 iCurrentTest =
6148 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6149 PVMF_MIME_YUV420,
6150 PVMF_MIME_PCM16,
6151 iCurrentTestNumber,
6152 false,
6153 false,
6154 true,
6155 false,
6156 false, STATE_ADDDATASINK_AUDIO, true);
6157 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6158 }
6159 break;
6160 case GenericNetworkDisconnectCancelAllWhileProc_Prepare:
6161 {
6162 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_Prepare");
6163 iCurrentTest =
6164 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6165 PVMF_MIME_YUV420,
6166 PVMF_MIME_PCM16,
6167 iCurrentTestNumber,
6168 false,
6169 false,
6170 true,
6171 false,
6172 false, STATE_PREPARE, true);
6173 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6174 }
6175 break;
6176 case GenericNetworkDisconnectCancelAllWhileProc_Start:
6177 {
6178 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_Start");
6179 iCurrentTest =
6180 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6181 PVMF_MIME_YUV420,
6182 PVMF_MIME_PCM16,
6183 iCurrentTestNumber,
6184 false,
6185 false,
6186 true,
6187 false,
6188 false, STATE_START, true);
6189 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6190 }
6191 break;
6192 case GenericNetworkDisconnectCancelAllWhileProc_Pause:
6193 {
6194 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_Pause");
6195 iCurrentTest =
6196 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6197 PVMF_MIME_YUV420,
6198 PVMF_MIME_PCM16,
6199 iCurrentTestNumber,
6200 true,
6201 false,
6202 true,
6203 false,
6204 false, STATE_PAUSE, true);
6205 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6206 }
6207 break;
6208 case GenericNetworkDisconnectCancelAllWhileProc_Resume:
6209 {
6210 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_Resume");
6211 iCurrentTest =
6212 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6213 PVMF_MIME_YUV420,
6214 PVMF_MIME_PCM16,
6215 iCurrentTestNumber,
6216 true,
6217 false,
6218 true,
6219 false,
6220 false, STATE_RESUME, true);
6221 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6222 }
6223 break;
6224 case GenericNetworkDisconnectCancelAllWhileProc_Stop:
6225 {
6226 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_Stop");
6227 iCurrentTest =
6228 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6229 PVMF_MIME_YUV420,
6230 PVMF_MIME_PCM16,
6231 iCurrentTestNumber,
6232 false,
6233 false,
6234 false,
6235 false,
6236 false, STATE_STOP, true);
6237 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6238 }
6239 break;
6240 case GenericNetworkDisconnectCancelAllWhileProc_SetPlaybackRange:
6241 {
6242 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProc_SetPlaybackRange");
6243 iCurrentTest =
6244 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6245 PVMF_MIME_YUV420,
6246 PVMF_MIME_PCM16,
6247 iCurrentTestNumber,
6248 false,
6249 true,
6250 true,
6251 false,
6252 false, STATE_SETPLAYBACKRANGE, true);
6253 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6254 }
6255 break;
6256
6257 case GenericNetworkDisconnectCancelAllWhileProtocolRollover:
6258 {
6259 fprintf(file, "GenericNetworkDisconnectCancelAllWhileProtocolRollover");
6260 iCurrentTest =
6261 new pvplayer_async_test_genericcancelallnetworkdisconnect(testparam,
6262 PVMF_MIME_YUV420,
6263 PVMF_MIME_PCM16,
6264 iCurrentTestNumber,
6265 false,
6266 false,
6267 true,
6268 false,
6269 false, STATE_PROTOCOLROLLOVER, true);
6270 ((pvplayer_async_test_genericcancelallnetworkdisconnect*)iCurrentTest)->setProtocolRollOverMode();
6271 }
6272 break;
6273
6274 case GenericOpenPlayMultiplePauseResumeUntilEOSTest:
6275 {
6276 fprintf(file, "GenericOpenPlayMultiplePauseResumeUntilEOSTest");
6277 iCurrentTest =
6278 new pvplayer_async_test_genericopenplaystop(testparam,
6279 PVMF_MIME_YUV420,
6280 PVMF_MIME_PCM16,
6281 iCurrentTestNumber,
6282 true,
6283 false,
6284 true,
6285 false,
6286 false);
6287 pvplayer_async_test_genericopenplaystop* ptr =
6288 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6289 ptr->setMultiplePauseMode(NUM_PAUSE, SEQUENTIAL_PAUSE_INTERVAL, FIRST_PAUSE_AFTER_START);
6290 ptr->setProtocolRollOverMode();
6291 }
6292 break;
6293
6294 case GenericOpenPlayMultipleSeekUntilEOSTest:
6295 {
6296 fprintf(file, "GenericOpenPlayMultipleSeekUntilEOSTest");
6297 iCurrentTest =
6298 new pvplayer_async_test_genericopenplaystop(testparam,
6299 PVMF_MIME_YUV420,
6300 PVMF_MIME_PCM16,
6301 iCurrentTestNumber,
6302 false,
6303 true,
6304 true,
6305 false,
6306 false);
6307 pvplayer_async_test_genericopenplaystop* ptr =
6308 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6309 ptr->setProtocolRollOverMode();
6310 ptr->setMultipleSeekMode(SEQUENTIAL_SEEK_INTERVAL, FIRST_SEEK_AFTER_START);
6311 }
6312 break;
6313
6314 case GenericOpenPlayStop_SleepAddDataSource:
6315 {
6316 fprintf(file, "GenericOpenPlayStop_SleepAddDataSource");
6317 iCurrentTest =
6318 new pvplayer_async_test_genericopenplaystop(testparam,
6319 PVMF_MIME_YUV420,
6320 PVMF_MIME_PCM16,
6321 iCurrentTestNumber,
6322 false,
6323 false,
6324 false,
6325 false,
6326 false,
6327 STATE_ADDDATASOURCE,
6328 true);
6329 pvplayer_async_test_genericopenplaystop* ptr =
6330 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6331 ptr->setProtocolRollOverMode();
6332 }
6333 break;
6334
6335 case GenericOpenPlayStop_SleepInit:
6336 {
6337 fprintf(file, "GenericOpenPlayStop_SleepInit");
6338 iCurrentTest =
6339 new pvplayer_async_test_genericopenplaystop(testparam,
6340 PVMF_MIME_YUV420,
6341 PVMF_MIME_PCM16,
6342 iCurrentTestNumber,
6343 false,
6344 false,
6345 false,
6346 false,
6347 false,
6348 STATE_INIT,
6349 true);
6350 pvplayer_async_test_genericopenplaystop* ptr =
6351 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6352 ptr->setProtocolRollOverMode();
6353 }
6354 break;
6355
6356 case GenericOpenPlayStop_SleepAddDataSinkVideo:
6357 {
6358 fprintf(file, "GenericOpenPlayStop_SleepAddDataSinkVideo");
6359 iCurrentTest =
6360 new pvplayer_async_test_genericopenplaystop(testparam,
6361 PVMF_MIME_YUV420,
6362 PVMF_MIME_PCM16,
6363 iCurrentTestNumber,
6364 false,
6365 false,
6366 false,
6367 false,
6368 false,
6369 STATE_ADDDATASINK_VIDEO,
6370 true);
6371 pvplayer_async_test_genericopenplaystop* ptr =
6372 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6373 ptr->setProtocolRollOverMode();
6374 }
6375 break;
6376
6377 case GenericOpenPlayStop_SleepAddDataSinkAudio:
6378 {
6379 fprintf(file, "GenericOpenPlayStop_SleepAddDataSinkAudio");
6380 iCurrentTest =
6381 new pvplayer_async_test_genericopenplaystop(testparam,
6382 PVMF_MIME_YUV420,
6383 PVMF_MIME_PCM16,
6384 iCurrentTestNumber,
6385 false,
6386 false,
6387 false,
6388 false,
6389 false,
6390 STATE_ADDDATASINK_AUDIO,
6391 true);
6392 pvplayer_async_test_genericopenplaystop* ptr =
6393 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6394 ptr->setProtocolRollOverMode();
6395 }
6396 break;
6397
6398 case GenericOpenPlayStop_SleepPrepare:
6399 {
6400 fprintf(file, "GenericOpenPlayStop_SleepPrepare");
6401 iCurrentTest =
6402 new pvplayer_async_test_genericopenplaystop(testparam,
6403 PVMF_MIME_YUV420,
6404 PVMF_MIME_PCM16,
6405 iCurrentTestNumber,
6406 false,
6407 false,
6408 false,
6409 false,
6410 false,
6411 STATE_PREPARE,
6412 true);
6413 pvplayer_async_test_genericopenplaystop* ptr =
6414 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6415 ptr->setProtocolRollOverMode();
6416 }
6417 break;
6418
6419 case GenericOpenPlayStop_SleepGetMetaDataValueList:
6420 {
6421 fprintf(file, "GenericOpenPlayStop_SleepGetMetaDataValueList");
6422 iCurrentTest =
6423 new pvplayer_async_test_genericopenplaystop(testparam,
6424 PVMF_MIME_YUV420,
6425 PVMF_MIME_PCM16,
6426 iCurrentTestNumber,
6427 false,
6428 false,
6429 false,
6430 false,
6431 false,
6432 STATE_GETMETADATAVALUELIST,
6433 true);
6434 pvplayer_async_test_genericopenplaystop* ptr =
6435 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6436 ptr->setProtocolRollOverMode();
6437 }
6438 break;
6439
6440 case GenericOpenPlayStop_SleepStop:
6441 {
6442 fprintf(file, "GenericOpenPlayStop_SleepStop");
6443 iCurrentTest =
6444 new pvplayer_async_test_genericopenplaystop(testparam,
6445 PVMF_MIME_YUV420,
6446 PVMF_MIME_PCM16,
6447 iCurrentTestNumber,
6448 false,
6449 false,
6450 false,
6451 false,
6452 false,
6453 STATE_STOP,
6454 true);
6455 pvplayer_async_test_genericopenplaystop* ptr =
6456 (pvplayer_async_test_genericopenplaystop*)iCurrentTest;
6457 ptr->setProtocolRollOverMode();
6458 }
6459 break;
6460
6461 case GenericOpenPlayPauseResumeSeekStopProfiling:
6462 {
6463 fprintf(file, "GenericOpenPlayPauseResumeSeekStopProfiling");
6464 iCurrentTest =
6465 new pvplayer_async_test_genericprofiling(testparam,
6466 PVMF_MIME_YUV420,
6467 PVMF_MIME_PCM16,
6468 iCurrentTestNumber,
6469 false,
6470 false,
6471 false);
6472 pvplayer_async_test_genericprofiling* ptr =
6473 (pvplayer_async_test_genericprofiling*)iCurrentTest;
6474 ptr->setProtocolRollOverMode();
6475 }
6476 break;
6477
6478 case GenericOpenPlayPauseRepositionResumeUntilEOSTest:
6479 {
6480 fprintf(file, "GenericOpenPlayPauseRepositionResumeUntilEOSTest");
6481 iCurrentTest =
6482 new pvplayer_async_test_genericplaypauserepositionresumetest(testparam,
6483 PVMF_MIME_YUV420,
6484 PVMF_MIME_PCM16,
6485 iCurrentTestNumber,
6486 true,
6487 false,
6488 false);
6489 pvplayer_async_test_genericplaypauserepositionresumetest* ptr =
6490 (pvplayer_async_test_genericplaypauserepositionresumetest*)iCurrentTest;
6491 ptr->setProtocolRollOverMode();
6492 }
6493 break;
6494
6495 case GenericOpenPlayPauseRepositionResumeNetworkDisconnectCancelAllTest:
6496 {
6497 fprintf(file, "GenericOpenPlayPauseRepositionResumeNetworkDisconnectCancelAllTest");
6498 iCurrentTest =
6499 new pvplayer_async_test_genericplaypauserepositionresumenwdisconnectcancelalltest(testparam,
6500 PVMF_MIME_YUV420,
6501 PVMF_MIME_PCM16,
6502 iCurrentTestNumber,
6503 true,
6504 false,
6505 false);
6506 pvplayer_async_test_genericplaypauserepositionresumenwdisconnectcancelalltest* ptr =
6507 (pvplayer_async_test_genericplaypauserepositionresumenwdisconnectcancelalltest*)iCurrentTest;
6508 ptr->setProtocolRollOverMode();
6509 }
6510 break;
6511
6512 case GenericOpenSetPlaybackRangeStartPlayStopTest:
6513 {
6514 fprintf(file, "GenericOpenSetPlaybackRangeStartPlayStopTest");
6515 iCurrentTest =
6516 new pvplayer_async_test_genericopensetplaybackrangestartplaystoptest(testparam,
6517 PVMF_MIME_YUV420,
6518 PVMF_MIME_PCM16,
6519 iCurrentTestNumber,
6520 false,
6521 false,
6522 false);
6523 pvplayer_async_test_genericopensetplaybackrangestartplaystoptest* ptr =
6524 (pvplayer_async_test_genericopensetplaybackrangestartplaystoptest*)iCurrentTest;
6525 ptr->setProtocolRollOverMode();
6526 }
6527 break;
6528
6529 case GenericOpenPlayRepositionToEndTest:
6530 {
6531 fprintf(file, "GenericOpenPlayRepositionToEndPlayTest");
6532 iCurrentTest =
6533 new pvplayer_async_test_genericopenplayrepositiontoendtest(testparam,
6534 PVMF_MIME_YUV420,
6535 PVMF_MIME_PCM16,
6536 iCurrentTestNumber,
6537 true,
6538 false,
6539 false);
6540 pvplayer_async_test_genericopenplayrepositiontoendtest* ptr =
6541 (pvplayer_async_test_genericopenplayrepositiontoendtest*)iCurrentTest;
6542 ptr->setProtocolRollOverMode();
6543 }
6544 break;
6545
6546 case GenericPVMFErrorCorruptReNotified:
6547 {
6548 fprintf(file, "GenericPVMFErrorCorruptReNotified");
6549 iCurrentTest =
6550 new pvplayer_async_test_genericpvmferrorcorruptrenotified(testparam,
6551 PVMF_MIME_YUV420,
6552 PVMF_MIME_PCM16,
6553 iCurrentTestNumber,
6554 false);
6555 pvplayer_async_test_genericpvmferrorcorruptrenotified* ptr =
6556 (pvplayer_async_test_genericpvmferrorcorruptrenotified*)iCurrentTest;
6557 OSCL_UNUSED_ARG(ptr);
6558 }
6559 break;
6560
6561 case GenericOpenPlayPauseGetMetaDataUntilEOSTest:
6562 {
6563 fprintf(file, "GenericOpenPlayPauseGetMetaDataUntilEOSTest");
6564 iCurrentTest =
6565 new pvplayer_async_test_genericopenplaygetmetadatatest(testparam,
6566 PVMF_MIME_YUV420,
6567 PVMF_MIME_PCM16,
6568 iCurrentTestNumber,
6569 true,
6570 false);
6571 pvplayer_async_test_genericopenplaygetmetadatatest* ptr =
6572 (pvplayer_async_test_genericopenplaygetmetadatatest*)iCurrentTest;
6573 OSCL_UNUSED_ARG(ptr);
6574
6575 }
6576 break;
6577
6578 case GenericOpenGetMetaDataPicTest:
6579 {
6580 fprintf(file, "GenericOpenGetMetaDataPicTest");
6581 iCurrentTest =
6582 new pvplayer_async_test_genericopengetmetadatapictest(testparam,
6583 PVMF_MIME_YUV420,
6584 PVMF_MIME_PCM16,
6585 iCurrentTestNumber,
6586 true,
6587 false);
6588 pvplayer_async_test_genericopengetmetadatapictest* ptr =
6589 (pvplayer_async_test_genericopengetmetadatapictest*)iCurrentTest;
6590 OSCL_UNUSED_ARG(ptr);
6591 }
6592 break;
6593
6594 case DLA_StreamingOpenPlayUntilEOST_JupiterCPMTest:
6595 {
6596 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
6597 fprintf(file, "DLA_StreamingOpenPlayUntilEOST_JupiterCPMTest");
6598 iCurrentTest =
6599 new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
6600 PVMF_MIME_YUV420,
6601 PVMF_MIME_PCM16,
6602 iCurrentTestNumber,
6603 false,
6604 false,
6605 true,
6606 false,
6607 false,
6608 false);
6609 #else
6610 fprintf(file, "Jupiter Streaming tests not enabled\n");
6611 #endif
6612 }
6613 break;
6614
6615 case DLA_StreamingOpenPlayPausePlayUntilEOS_JupiterCPMTest:
6616 {
6617 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
6618 fprintf(file, "DLA_StreamingOpenPlayPausePlayUntilEOS_JupiterCPMTest");
6619 iCurrentTest =
6620 new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
6621 PVMF_MIME_YUV420,
6622 PVMF_MIME_PCM16,
6623 iCurrentTestNumber,
6624 true,
6625 false,
6626 true,
6627 false,
6628 false,
6629 false);
6630 #else
6631 fprintf(file, "Jupiter Streaming tests not enabled\n");
6632 #endif
6633 }
6634 break;
6635
6636 case DLA_StreamingOpenPlaySeekPlayUntilEOS_JupiterCPMTest:
6637 {
6638 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
6639 fprintf(file, "DLA_StreamingOpenPlaySeekPlayUntilEOS_JupiterCPMTest");
6640 iCurrentTest = new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
6641 PVMF_MIME_YUV420,
6642 PVMF_MIME_PCM16,
6643 iCurrentTestNumber,
6644 false,
6645 true,
6646 true,
6647 false,
6648 false,
6649 false);
6650 #else
6651 fprintf(file, "Jupiter Streaming tests not enabled\n");
6652 #endif
6653 }
6654 break;
6655
6656 case DLA_StreamingMultiplePlayUntilEOS_JupiterCPMTest:
6657 {
6658 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
6659 fprintf(file, "DLA_StreamingMultiplePlayUntilEOS_JupiterCPMTest");
6660 iCurrentTest =
6661 new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
6662 PVMF_MIME_YUV420,
6663 PVMF_MIME_PCM16,
6664 iCurrentTestNumber,
6665 false,
6666 false,
6667 true,
6668 false,
6669 false,
6670 false);
6671
6672 pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop* ptr =
6673 (pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop*)iCurrentTest;
6674 ptr->setMultiplePlayMode(2);
6675 fprintf(file, "\n0x%x 0x%x setMultiplePlayMode\n", ptr, iCurrentTest);
6676 #else
6677 fprintf(file, "Jupiter Streaming tests not enabled\n");
6678 #endif
6679 }
6680 break;
6681
6682 case DLA_StreamingProtocolRollOverTest_JupiterCPMTest:
6683 {
6684 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
6685 fprintf(file, "DLA_StreamingProtocolRollOverTest_JupiterCPMTest");
6686 iCurrentTest = new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
6687 PVMF_MIME_YUV420,
6688 PVMF_MIME_PCM16,
6689 iCurrentTestNumber,
6690 false,
6691 false,
6692 true,
6693 false,
6694 false,
6695 false);
6696
6697 ((pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop*)iCurrentTest)->setProtocolRollOverMode();
6698 #else
6699 fprintf(file, "Jupiter Streaming tests not enabled\n");
6700 #endif
6701 }
6702 break;
6703
6704 case DLA_StreamingProtocolRollOverTestWithUnknownURLType_JupiterCPMTest:
6705 {
6706 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
6707 fprintf(file, "DLA_StreamingProtocolRollOverTestWithUnknownURLType_JupiterCPMTest");
6708 iCurrentTest = new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
6709 PVMF_MIME_YUV420,
6710 PVMF_MIME_PCM16,
6711 iCurrentTestNumber,
6712 false,
6713 false,
6714 true,
6715 false,
6716 false,
6717 false);
6718
6719 ((pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop*)iCurrentTest)->setProtocolRollOverModeWithUnknownURL();
6720 #else
6721 fprintf(file, "Jupiter Streaming tests not enabled\n");
6722 #endif
6723 }
6724 break;
6725
6726 case DLA_StreamingCancelAll_AddDataSource:
6727 {
6728 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6729 fprintf(file, "DLA_StreamingCancelAll_AddDataSource");
6730 iCurrentTest =
6731 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6732 PVMF_MIME_YUV420,
6733 PVMF_MIME_PCM16,
6734 iCurrentTestNumber,
6735 false,
6736 false,
6737 true,
6738 false,
6739 false,
6740 false,
6741 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASOURCE,
6742 false);
6743 #else
6744 fprintf(file, "Streaming tests not enabled\n");
6745 #endif
6746 }
6747 break;
6748
6749 case DLA_StreamingCancelAll_Init:
6750 {
6751 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6752 fprintf(file, "DLA_StreamingCancelAll_Init");
6753 iCurrentTest =
6754 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6755 PVMF_MIME_YUV420,
6756 PVMF_MIME_PCM16,
6757 iCurrentTestNumber,
6758 false,
6759 false,
6760 true,
6761 false,
6762 false,
6763 false,
6764 pvplayer_async_test_DLAstreamingopenplaystop::STATE_INIT1,
6765 false);
6766 #else
6767 fprintf(file, "Streaming tests not enabled\n");
6768 #endif
6769 }
6770 break;
6771
6772 case DLA_StreamingCancelAll_LicenseAcquired:
6773 {
6774 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6775 fprintf(file, "DLA_StreamingCancelAll_LicenseAcquired");
6776 iCurrentTest =
6777 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6778 PVMF_MIME_YUV420,
6779 PVMF_MIME_PCM16,
6780 iCurrentTestNumber,
6781 false,
6782 false,
6783 true,
6784 false,
6785 false,
6786 false,
6787 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ACQUIRELICENSE,
6788 false);
6789 #else
6790 fprintf(file, "Streaming tests not enabled\n");
6791 #endif
6792 }
6793 break;
6794
6795 case DLA_StreamingCancelAll_AddDataSinkVideo:
6796 {
6797 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6798 fprintf(file, "DLA_StreamingCancelAll_AddDataSinkVideo");
6799 iCurrentTest =
6800 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6801 PVMF_MIME_YUV420,
6802 PVMF_MIME_PCM16,
6803 iCurrentTestNumber,
6804 false,
6805 false,
6806 true,
6807 false,
6808 false,
6809 false,
6810 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASINK_VIDEO,
6811 false);
6812 #else
6813 fprintf(file, "Streaming tests not enabled\n");
6814 #endif
6815 }
6816 break;
6817
6818
6819 case DLA_StreamingCancelAll_AddDataSinkAudio:
6820 {
6821 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6822 fprintf(file, "DLA_StreamingCancelAll_AddDataSinkAudio");
6823 iCurrentTest =
6824 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6825 PVMF_MIME_YUV420,
6826 PVMF_MIME_PCM16,
6827 iCurrentTestNumber,
6828 false,
6829 false,
6830 true,
6831 false,
6832 false,
6833 false,
6834 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASINK_AUDIO,
6835 false);
6836 #else
6837 fprintf(file, "Streaming tests not enabled\n");
6838 #endif
6839 }
6840 break;
6841
6842
6843 case DLA_StreamingCancelAll_Prepare:
6844 {
6845 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6846 fprintf(file, "DLA_StreamingCancelAll_Prepare");
6847 iCurrentTest =
6848 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6849 PVMF_MIME_YUV420,
6850 PVMF_MIME_PCM16,
6851 iCurrentTestNumber,
6852 false,
6853 false,
6854 true,
6855 false,
6856 false,
6857 false,
6858 pvplayer_async_test_DLAstreamingopenplaystop::STATE_PREPARE,
6859 false);
6860 #else
6861 fprintf(file, "Streaming tests not enabled\n");
6862 #endif
6863 }
6864 break;
6865
6866
6867 case DLA_StreamingCancelAll_Start:
6868 {
6869 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6870 fprintf(file, "DLA_StreamingCancelAll_Start");
6871 iCurrentTest =
6872 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6873 PVMF_MIME_YUV420,
6874 PVMF_MIME_PCM16,
6875 iCurrentTestNumber,
6876 false,
6877 false,
6878 true,
6879 false,
6880 false,
6881 false,
6882 pvplayer_async_test_DLAstreamingopenplaystop::STATE_START,
6883 false);
6884 #else
6885 fprintf(file, "Streaming tests not enabled\n");
6886 #endif
6887 }
6888 break;
6889
6890
6891 case DLA_StreamingCancelAll_Pause:
6892 {
6893 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6894 fprintf(file, "DLA_StreamingCancelAll_Pause");
6895 iCurrentTest =
6896 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6897 PVMF_MIME_YUV420,
6898 PVMF_MIME_PCM16,
6899 iCurrentTestNumber,
6900 true,
6901 false,
6902 true,
6903 false,
6904 false,
6905 false,
6906 pvplayer_async_test_DLAstreamingopenplaystop::STATE_PAUSE,
6907 false);
6908 #else
6909 fprintf(file, "Streaming tests not enabled\n");
6910 #endif
6911 }
6912 break;
6913
6914 case DLA_StreamingCancelAll_Resume:
6915 {
6916 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6917 fprintf(file, "DLA_StreamingCancelAll_Resume");
6918 iCurrentTest =
6919 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6920 PVMF_MIME_YUV420,
6921 PVMF_MIME_PCM16,
6922 iCurrentTestNumber,
6923 true,
6924 false,
6925 true,
6926 false,
6927 false,
6928 false,
6929 pvplayer_async_test_DLAstreamingopenplaystop::STATE_RESUME,
6930 false);
6931 #else
6932 fprintf(file, "Streaming tests not enabled\n");
6933 #endif
6934 }
6935 break;
6936
6937 case DLA_StreamingCancelAll_Stop:
6938 {
6939 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6940 fprintf(file, "DLA_StreamingCancelAll_Stop");
6941 iCurrentTest =
6942 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6943 PVMF_MIME_YUV420,
6944 PVMF_MIME_PCM16,
6945 iCurrentTestNumber,
6946 false,
6947 false,
6948 true,
6949 false,
6950 false,
6951 false,
6952 pvplayer_async_test_DLAstreamingopenplaystop::STATE_STOP,
6953 false);
6954 #else
6955 fprintf(file, "Streaming tests not enabled\n");
6956 #endif
6957 }
6958 break;
6959
6960 case DLA_StreamingCancelAll_SetPlaybackRange:
6961 {
6962 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6963 fprintf(file, "DLA_StreamingCancelAll_SetPlaybackRange");
6964 iCurrentTest =
6965 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6966 PVMF_MIME_YUV420,
6967 PVMF_MIME_PCM16,
6968 iCurrentTestNumber,
6969 false,
6970 true,
6971 true,
6972 false,
6973 false,
6974 false,
6975 pvplayer_async_test_DLAstreamingopenplaystop::STATE_SETPLAYBACKRANGE,
6976 false);
6977 #else
6978 fprintf(file, "Streaming tests not enabled\n");
6979 #endif
6980 }
6981 break;
6982
6983 case DLA_StreamingCancelAllWhileProc_AddDataSource:
6984 {
6985 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
6986 fprintf(file, "DLA_StreamingCancelAllWhileProc_AddDataSource");
6987 iCurrentTest =
6988 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
6989 PVMF_MIME_YUV420,
6990 PVMF_MIME_PCM16,
6991 iCurrentTestNumber,
6992 false,
6993 false,
6994 true,
6995 false,
6996 false,
6997 false,
6998 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASOURCE,
6999 true);
7000 #else
7001 fprintf(file, "Streaming tests not enabled\n");
7002 #endif
7003 }
7004 break;
7005
7006 case DLA_StreamingCancelAllWhileProc_Init:
7007 {
7008 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7009 fprintf(file, "DLA_StreamingCancelAllWhileProc_Init");
7010 iCurrentTest =
7011 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7012 PVMF_MIME_YUV420,
7013 PVMF_MIME_PCM16,
7014 iCurrentTestNumber,
7015 false,
7016 false,
7017 true,
7018 false,
7019 false,
7020 false,
7021 pvplayer_async_test_DLAstreamingopenplaystop::STATE_INIT1,
7022 true);
7023 #else
7024 fprintf(file, "Streaming tests not enabled\n");
7025 #endif
7026 }
7027 break;
7028
7029
7030 case DLA_StreamingCancelAllWhileProc_LicenseAcquired:
7031 {
7032 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7033 fprintf(file, "DLA_StreamingCancelAllWhileProc_LicenseAcquired");
7034 iCurrentTest =
7035 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7036 PVMF_MIME_YUV420,
7037 PVMF_MIME_PCM16,
7038 iCurrentTestNumber,
7039 false,
7040 false,
7041 true,
7042 false,
7043 false,
7044 false,
7045 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ACQUIRELICENSE,
7046 true);
7047 #else
7048 fprintf(file, "Streaming tests not enabled\n");
7049 #endif
7050 }
7051 break;
7052
7053
7054 case DLA_StreamingCancelAllWhileProc_AddDataSinkVideo:
7055 {
7056 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7057 fprintf(file, "DLA_StreamingCancelAllWhileProc_AddDataSinkVideo");
7058 iCurrentTest =
7059 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7060 PVMF_MIME_YUV420,
7061 PVMF_MIME_PCM16,
7062 iCurrentTestNumber,
7063 false,
7064 false,
7065 true,
7066 false,
7067 false,
7068 false,
7069 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASINK_VIDEO,
7070 true);
7071 #else
7072 fprintf(file, "Streaming tests not enabled\n");
7073 #endif
7074 }
7075 break;
7076
7077 case DLA_StreamingCancelAllWhileProc_AddDataSinkAudio:
7078 {
7079 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7080 fprintf(file, "DLA_StreamingCancelAllWhileProc_AddDataSinkAudio");
7081 iCurrentTest =
7082 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7083 PVMF_MIME_YUV420,
7084 PVMF_MIME_PCM16,
7085 iCurrentTestNumber,
7086 false,
7087 false,
7088 true,
7089 false,
7090 false,
7091 false,
7092 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASINK_AUDIO,
7093 true);
7094 #else
7095 fprintf(file, "Streaming tests not enabled\n");
7096 #endif
7097 }
7098 break;
7099
7100 case DLA_StreamingCancelAllWhileProc_Prepare:
7101 {
7102 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7103 fprintf(file, "DLA_StreamingCancelAllWhileProc_Prepare");
7104 iCurrentTest =
7105 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7106 PVMF_MIME_YUV420,
7107 PVMF_MIME_PCM16,
7108 iCurrentTestNumber,
7109 false,
7110 false,
7111 true,
7112 false,
7113 false,
7114 false,
7115 pvplayer_async_test_DLAstreamingopenplaystop::STATE_PREPARE,
7116 true);
7117 #else
7118 fprintf(file, "Streaming tests not enabled\n");
7119 #endif
7120 }
7121 break;
7122
7123 case DLA_StreamingCancelAllWhileProc_Start:
7124 {
7125 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7126 fprintf(file, "DLA_StreamingCancelAllWhileProc_Start");
7127 iCurrentTest =
7128 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7129 PVMF_MIME_YUV420,
7130 PVMF_MIME_PCM16,
7131 iCurrentTestNumber,
7132 false,
7133 false,
7134 true,
7135 false,
7136 false,
7137 false,
7138 pvplayer_async_test_DLAstreamingopenplaystop::STATE_START,
7139 true);
7140 #else
7141 fprintf(file, "Streaming tests not enabled\n");
7142 #endif
7143 }
7144 break;
7145
7146 case DLA_StreamingCancelAllWhileProc_Pause:
7147 {
7148 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7149 fprintf(file, "DLA_StreamingCancelAllWhileProc_Pause");
7150 iCurrentTest =
7151 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7152 PVMF_MIME_YUV420,
7153 PVMF_MIME_PCM16,
7154 iCurrentTestNumber,
7155 true,
7156 false,
7157 true,
7158 false,
7159 false,
7160 false,
7161 pvplayer_async_test_DLAstreamingopenplaystop::STATE_PAUSE,
7162 true);
7163 #else
7164 fprintf(file, "Streaming tests not enabled\n");
7165 #endif
7166 }
7167 break;
7168
7169 case DLA_StreamingCancelAllWhileProc_Resume:
7170 {
7171 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7172 fprintf(file, "DLA_StreamingCancelAllWhileProc_Resume");
7173 iCurrentTest =
7174 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7175 PVMF_MIME_YUV420,
7176 PVMF_MIME_PCM16,
7177 iCurrentTestNumber,
7178 true,
7179 false,
7180 true,
7181 false,
7182 false,
7183 false,
7184 pvplayer_async_test_DLAstreamingopenplaystop::STATE_RESUME,
7185 true);
7186 #else
7187 fprintf(file, "Streaming tests not enabled\n");
7188 #endif
7189 }
7190 break;
7191
7192 case DLA_StreamingCancelAllWhileProc_Stop:
7193 {
7194 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7195 fprintf(file, "DLA_StreamingCancelAllWhileProc_Stop");
7196 iCurrentTest =
7197 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7198 PVMF_MIME_YUV420,
7199 PVMF_MIME_PCM16,
7200 iCurrentTestNumber,
7201 false,
7202 false,
7203 true,
7204 false,
7205 false,
7206 false,
7207 pvplayer_async_test_DLAstreamingopenplaystop::STATE_STOP,
7208 true);
7209 #else
7210 fprintf(file, "Streaming tests not enabled\n");
7211 #endif
7212 }
7213 break;
7214
7215
7216 case DLA_StreamingCancelAllWhileProc_SetPlaybackRange:
7217 {
7218 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7219 fprintf(file, "DLA_StreamingCancelAllWhileProc_SetPlaybackRange");
7220 iCurrentTest =
7221 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
7222 PVMF_MIME_YUV420,
7223 PVMF_MIME_PCM16,
7224 iCurrentTestNumber,
7225 false,
7226 true,
7227 true,
7228 false,
7229 false,
7230 false,
7231 pvplayer_async_test_DLAstreamingopenplaystop::STATE_SETPLAYBACKRANGE,
7232 true);
7233 #else
7234 fprintf(file, "Streaming tests not enabled\n");
7235 #endif
7236 }
7237 break;
7238
7239 case DLA_StreamingNetworkDisconnect_AddDataSource:
7240 {
7241 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7242 fprintf(file, "DLA_StreamingNetworkDisconnect_AddDataSource");
7243 iCurrentTest =
7244 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7245 PVMF_MIME_YUV420,
7246 PVMF_MIME_PCM16,
7247 iCurrentTestNumber,
7248 false,
7249 false,
7250 true,
7251 false,
7252 false,
7253 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ADDDATASOURCE,
7254 false);
7255 #else
7256 fprintf(file, "Streaming tests not enabled\n");
7257 #endif
7258 }
7259 break;
7260
7261 case DLA_StreamingNetworkDisconnect_Init:
7262 {
7263 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7264 fprintf(file, "DLA_StreamingNetworkDisconnect_Init");
7265 iCurrentTest =
7266 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7267 PVMF_MIME_YUV420,
7268 PVMF_MIME_PCM16,
7269 iCurrentTestNumber,
7270 false,
7271 false,
7272 true,
7273 false,
7274 false,
7275 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_INIT1,
7276 false);
7277 #else
7278 fprintf(file, "Streaming tests not enabled\n");
7279 #endif
7280 }
7281 break;
7282
7283 case DLA_StreamingNetworkDisconnect_LicenseAcquired:
7284 {
7285 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7286 fprintf(file, "DLA_StreamingNetworkDisconnect_LicenseAcquired");
7287 iCurrentTest =
7288 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7289 PVMF_MIME_YUV420,
7290 PVMF_MIME_PCM16,
7291 iCurrentTestNumber,
7292 false,
7293 false,
7294 true,
7295 false,
7296 false,
7297 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ACQUIRELICENSE,
7298 false);
7299 #else
7300 fprintf(file, "Streaming tests not enabled\n");
7301 #endif
7302 }
7303 break;
7304
7305 case DLA_StreamingNetworkDisconnect_AddDataSinkVideo:
7306 {
7307 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7308 fprintf(file, "DLA_StreamingNetworkDisconnect_AddDataSinkVideo");
7309 iCurrentTest =
7310 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7311 PVMF_MIME_YUV420,
7312 PVMF_MIME_PCM16,
7313 iCurrentTestNumber,
7314 false,
7315 false,
7316 true,
7317 false,
7318 false,
7319 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ADDDATASINK_VIDEO,
7320 false);
7321 #else
7322 fprintf(file, "Streaming tests not enabled\n");
7323 #endif
7324 }
7325 break;
7326 case DLA_StreamingNetworkDisconnect_AddDataSinkAudio:
7327 {
7328 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7329 fprintf(file, "DLA_StreamingNetworkDisconnect_AddDataSinkAudio");
7330 iCurrentTest =
7331 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7332 PVMF_MIME_YUV420,
7333 PVMF_MIME_PCM16,
7334 iCurrentTestNumber,
7335 false,
7336 false,
7337 true,
7338 false,
7339 false,
7340 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ADDDATASINK_AUDIO,
7341 false);
7342 #else
7343 fprintf(file, "Streaming tests not enabled\n");
7344 #endif
7345 }
7346 break;
7347 case DLA_StreamingNetworkDisconnect_Prepare:
7348 {
7349 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7350 fprintf(file, "DLA_StreamingNetworkDisconnect_Prepare");
7351 iCurrentTest =
7352 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7353 PVMF_MIME_YUV420,
7354 PVMF_MIME_PCM16,
7355 iCurrentTestNumber,
7356 false,
7357 false,
7358 true,
7359 false,
7360 false,
7361 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_PREPARE,
7362 false);
7363 #else
7364 fprintf(file, "Streaming tests not enabled\n");
7365 #endif
7366 }
7367 break;
7368 case DLA_StreamingNetworkDisconnect_Start:
7369 {
7370 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7371 fprintf(file, "DLA_StreamingNetworkDisconnect_Start");
7372 iCurrentTest =
7373 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7374 PVMF_MIME_YUV420,
7375 PVMF_MIME_PCM16,
7376 iCurrentTestNumber,
7377 false,
7378 false,
7379 true,
7380 false,
7381 false,
7382 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_START,
7383 false);
7384 #else
7385 fprintf(file, "Streaming tests not enabled\n");
7386 #endif
7387 }
7388 break;
7389 case DLA_StreamingNetworkDisconnect_Pause:
7390 {
7391 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7392 fprintf(file, "DLA_StreamingNetworkDisconnect_Pause");
7393 iCurrentTest =
7394 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7395 PVMF_MIME_YUV420,
7396 PVMF_MIME_PCM16,
7397 iCurrentTestNumber,
7398 true,
7399 false,
7400 true,
7401 false,
7402 false,
7403 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_PAUSE,
7404 false);
7405 #else
7406 fprintf(file, "Streaming tests not enabled\n");
7407 #endif
7408 }
7409 break;
7410 case DLA_StreamingNetworkDisconnect_Resume:
7411 {
7412 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7413 fprintf(file, "DLA_StreamingNetworkDisconnect_Resume");
7414 iCurrentTest =
7415 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7416 PVMF_MIME_YUV420,
7417 PVMF_MIME_PCM16,
7418 iCurrentTestNumber,
7419 true,
7420 false,
7421 true,
7422 false,
7423 false,
7424 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_RESUME,
7425 false);
7426 #else
7427 fprintf(file, "Streaming tests not enabled\n");
7428 #endif
7429 }
7430 break;
7431 case DLA_StreamingNetworkDisconnect_Stop:
7432 {
7433 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7434 fprintf(file, "DLA_StreamingNetworkDisconnect_Stop");
7435 iCurrentTest =
7436 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7437 PVMF_MIME_YUV420,
7438 PVMF_MIME_PCM16,
7439 iCurrentTestNumber,
7440 false,
7441 false,
7442 false,
7443 false,
7444 false,
7445 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_STOP,
7446 false);
7447 #else
7448 fprintf(file, "Streaming tests not enabled\n");
7449 #endif
7450 }
7451 break;
7452
7453 case DLA_StreamingNetworkDisconnect_SetPlaybackRange:
7454 {
7455 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7456 fprintf(file, "DLA_StreamingNetworkDisconnect_SetPlaybackRange");
7457 iCurrentTest =
7458 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7459 PVMF_MIME_YUV420,
7460 PVMF_MIME_PCM16,
7461 iCurrentTestNumber,
7462 false,
7463 true,
7464 true,
7465 false,
7466 false,
7467 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_SETPLAYBACKRANGE,
7468 false);
7469 #else
7470 fprintf(file, "Streaming tests not enabled\n");
7471 #endif
7472 }
7473 break;
7474 case DLA_StreamingNetworkDisconnectWhileProc_AddDataSource:
7475 {
7476 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7477 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_AddDataSource");
7478 iCurrentTest =
7479 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7480 PVMF_MIME_YUV420,
7481 PVMF_MIME_PCM16,
7482 iCurrentTestNumber,
7483 false,
7484 false,
7485 true,
7486 false,
7487 false,
7488 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ADDDATASOURCE,
7489 true);
7490 #else
7491 fprintf(file, "Streaming tests not enabled\n");
7492 #endif
7493 }
7494 break;
7495 case DLA_StreamingNetworkDisconnectWhileProc_Init:
7496 {
7497 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7498 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_Init");
7499 iCurrentTest =
7500 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7501 PVMF_MIME_YUV420,
7502 PVMF_MIME_PCM16,
7503 iCurrentTestNumber,
7504 false,
7505 false,
7506 true,
7507 false,
7508 false,
7509 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_INIT1,
7510 true);
7511 #else
7512 fprintf(file, "Streaming tests not enabled\n");
7513 #endif
7514 }
7515 break;
7516 case DLA_StreamingNetworkDisconnectWhileProc_LicenseAcquired:
7517 {
7518 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7519 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_LicenseAcquired");
7520 iCurrentTest =
7521 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7522 PVMF_MIME_YUV420,
7523 PVMF_MIME_PCM16,
7524 iCurrentTestNumber,
7525 false,
7526 false,
7527 true,
7528 false,
7529 false,
7530 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ACQUIRELICENSE,
7531 true);
7532 #else
7533 fprintf(file, "Streaming tests not enabled\n");
7534 #endif
7535 }
7536 break;
7537 case DLA_StreamingNetworkDisconnectWhileProc_AddDataSinkVideo:
7538 {
7539 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7540 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_AddDataSinkVideo");
7541 iCurrentTest =
7542 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7543 PVMF_MIME_YUV420,
7544 PVMF_MIME_PCM16,
7545 iCurrentTestNumber,
7546 false,
7547 false,
7548 true,
7549 false,
7550 false,
7551 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ADDDATASINK_VIDEO,
7552 true);
7553 #else
7554 fprintf(file, "Streaming tests not enabled\n");
7555 #endif
7556 }
7557 break;
7558 case DLA_StreamingNetworkDisconnectWhileProc_AddDataSinkAudio:
7559 {
7560 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7561 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_AddDataSinkAudio");
7562 iCurrentTest =
7563 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7564 PVMF_MIME_YUV420,
7565 PVMF_MIME_PCM16,
7566 iCurrentTestNumber,
7567 false,
7568 false,
7569 true,
7570 false,
7571 false,
7572 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_ADDDATASINK_AUDIO,
7573 true);
7574 #else
7575 fprintf(file, "Streaming tests not enabled\n");
7576 #endif
7577 }
7578 break;
7579 case DLA_StreamingNetworkDisconnectWhileProc_Prepare:
7580 {
7581 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7582 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_Prepare");
7583 iCurrentTest =
7584 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7585 PVMF_MIME_YUV420,
7586 PVMF_MIME_PCM16,
7587 iCurrentTestNumber,
7588 false,
7589 false,
7590 true,
7591 false,
7592 false,
7593 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_PREPARE,
7594 true);
7595 #else
7596 fprintf(file, "Streaming tests not enabled\n");
7597 #endif
7598 }
7599 break;
7600 case DLA_StreamingNetworkDisconnectWhileProc_Start:
7601 {
7602 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7603 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_Start");
7604 iCurrentTest =
7605 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7606 PVMF_MIME_YUV420,
7607 PVMF_MIME_PCM16,
7608 iCurrentTestNumber,
7609 false,
7610 false,
7611 true,
7612 false,
7613 false,
7614 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_START,
7615 true);
7616 #else
7617 fprintf(file, "Streaming tests not enabled\n");
7618 #endif
7619 }
7620 break;
7621 case DLA_StreamingNetworkDisconnectWhileProc_Pause:
7622 {
7623 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7624 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_Pause");
7625 iCurrentTest =
7626 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7627 PVMF_MIME_YUV420,
7628 PVMF_MIME_PCM16,
7629 iCurrentTestNumber,
7630 true,
7631 false,
7632 true,
7633 false,
7634 false,
7635 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_PAUSE,
7636 true);
7637 #else
7638 fprintf(file, "Streaming tests not enabled\n");
7639 #endif
7640 }
7641 break;
7642 case DLA_StreamingNetworkDisconnectWhileProc_Resume:
7643 {
7644 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7645 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_Resume");
7646 iCurrentTest =
7647 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7648 PVMF_MIME_YUV420,
7649 PVMF_MIME_PCM16,
7650 iCurrentTestNumber,
7651 true,
7652 false,
7653 true,
7654 false,
7655 false,
7656 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_RESUME,
7657 true);
7658 #else
7659 fprintf(file, "Streaming tests not enabled\n");
7660 #endif
7661 }
7662 break;
7663 case DLA_StreamingNetworkDisconnectWhileProc_Stop:
7664 {
7665 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7666 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_Stop");
7667 iCurrentTest =
7668 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7669 PVMF_MIME_YUV420,
7670 PVMF_MIME_PCM16,
7671 iCurrentTestNumber,
7672 false,
7673 false,
7674 false,
7675 false,
7676 false,
7677 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_STOP,
7678 true);
7679 #else
7680 fprintf(file, "Streaming tests not enabled\n");
7681 #endif
7682 }
7683 break;
7684
7685 case DLA_StreamingNetworkDisconnectWhileProc_SetPlaybackRange:
7686 {
7687 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7688 fprintf(file, "DLA_StreamingNetworkDisconnectWhileProc_SetPlaybackRange");
7689 iCurrentTest =
7690 new pvplayer_async_test_DLAstreamingnetworkdisconnect(testparam,
7691 PVMF_MIME_YUV420,
7692 PVMF_MIME_PCM16,
7693 iCurrentTestNumber,
7694 false,
7695 true,
7696 true,
7697 false,
7698 false,
7699 pvplayer_async_test_DLAstreamingnetworkdisconnect::STATE_SETPLAYBACKRANGE,
7700 true);
7701 #else
7702 fprintf(file, "Streaming tests not enabled\n");
7703 #endif
7704 }
7705 break;
7706
7707 case DLA_StreamingNetworkDisconnectReconnect_AddDataSource:
7708 {
7709 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7710 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_AddDataSource");
7711 iCurrentTest =
7712 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7713 PVMF_MIME_YUV420,
7714 PVMF_MIME_PCM16,
7715 iCurrentTestNumber,
7716 false,
7717 false,
7718 true,
7719 false,
7720 false,
7721 pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ADDDATASOURCE,
7722 false);
7723 #else
7724 fprintf(file, "Streaming tests not enabled\n");
7725 #endif
7726 }
7727 break;
7728 case DLA_StreamingNetworkDisconnectReconnect_Init:
7729 {
7730 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7731 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_Init");
7732 iCurrentTest =
7733 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7734 PVMF_MIME_YUV420,
7735 PVMF_MIME_PCM16,
7736 iCurrentTestNumber,
7737 false,
7738 false,
7739 true,
7740 false,
7741 false,
7742 pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_INIT1,
7743 false);
7744 #else
7745 fprintf(file, "Streaming tests not enabled\n");
7746 #endif
7747 }
7748 break;
7749 case DLA_StreamingNetworkDisconnectReconnect_LicenseAcquired:
7750 {
7751 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7752 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_LicenseAcquired");
7753 iCurrentTest =
7754 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7755 PVMF_MIME_YUV420,
7756 PVMF_MIME_PCM16,
7757 iCurrentTestNumber,
7758 false,
7759 false,
7760 true,
7761 false,
7762 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ACQUIRELICENSE, false);
7763 #else
7764 fprintf(file, "Streaming tests not enabled\n");
7765 #endif
7766 }
7767 break;
7768 case DLA_StreamingNetworkDisconnectReconnect_AddDataSinkVideo:
7769 {
7770 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7771 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_AddDataSinkVideo");
7772 iCurrentTest =
7773 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7774 PVMF_MIME_YUV420,
7775 PVMF_MIME_PCM16,
7776 iCurrentTestNumber,
7777 false,
7778 false,
7779 true,
7780 false,
7781 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ADDDATASINK_VIDEO, false);
7782 #else
7783 fprintf(file, "Streaming tests not enabled\n");
7784 #endif
7785 }
7786 break;
7787 case DLA_StreamingNetworkDisconnectReconnect_AddDataSinkAudio:
7788 {
7789 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7790 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_AddDataSinkAudio");
7791 iCurrentTest =
7792 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7793 PVMF_MIME_YUV420,
7794 PVMF_MIME_PCM16,
7795 iCurrentTestNumber,
7796 false,
7797 false,
7798 true,
7799 false,
7800 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ADDDATASINK_AUDIO, false);
7801 #else
7802 fprintf(file, "Streaming tests not enabled\n");
7803 #endif
7804 }
7805 break;
7806 case DLA_StreamingNetworkDisconnectReconnect_Prepare:
7807 {
7808 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7809 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_Prepare");
7810 iCurrentTest =
7811 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7812 PVMF_MIME_YUV420,
7813 PVMF_MIME_PCM16,
7814 iCurrentTestNumber,
7815 false,
7816 false,
7817 true,
7818 false,
7819 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_PREPARE, false);
7820 #else
7821 fprintf(file, "Streaming tests not enabled\n");
7822 #endif
7823 }
7824 break;
7825 case DLA_StreamingNetworkDisconnectReconnect_Start:
7826 {
7827 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7828 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_Start");
7829 iCurrentTest =
7830 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7831 PVMF_MIME_YUV420,
7832 PVMF_MIME_PCM16,
7833 iCurrentTestNumber,
7834 false,
7835 false,
7836 true,
7837 false,
7838 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_START, false);
7839 #else
7840 fprintf(file, "Streaming tests not enabled\n");
7841 #endif
7842 }
7843 break;
7844 case DLA_StreamingNetworkDisconnectReconnect_Pause:
7845 {
7846 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7847 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_Pause");
7848 iCurrentTest =
7849 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7850 PVMF_MIME_YUV420,
7851 PVMF_MIME_PCM16,
7852 iCurrentTestNumber,
7853 true,
7854 false,
7855 true,
7856 false,
7857 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_PAUSE, false);
7858 #else
7859 fprintf(file, "Streaming tests not enabled\n");
7860 #endif
7861 }
7862 break;
7863 case DLA_StreamingNetworkDisconnectReconnect_Resume:
7864 {
7865 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7866 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_Resume");
7867 iCurrentTest =
7868 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7869 PVMF_MIME_YUV420,
7870 PVMF_MIME_PCM16,
7871 iCurrentTestNumber,
7872 true,
7873 false,
7874 true,
7875 false,
7876 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_RESUME, false);
7877 #else
7878 fprintf(file, "Streaming tests not enabled\n");
7879 #endif
7880 }
7881 break;
7882 case DLA_StreamingNetworkDisconnectReconnect_Stop:
7883 {
7884 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7885 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_Stop");
7886 iCurrentTest =
7887 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7888 PVMF_MIME_YUV420,
7889 PVMF_MIME_PCM16,
7890 iCurrentTestNumber,
7891 false,
7892 false,
7893 false,
7894 false,
7895 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_STOP, false);
7896 #else
7897 fprintf(file, "Streaming tests not enabled\n");
7898 #endif
7899 }
7900 break;
7901
7902 case DLA_StreamingNetworkDisconnectReconnect_SetPlaybackRange:
7903 {
7904 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7905 fprintf(file, "DLA_StreamingNetworkDisconnectReconnect_SetPlaybackRange");
7906 iCurrentTest =
7907 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7908 PVMF_MIME_YUV420,
7909 PVMF_MIME_PCM16,
7910 iCurrentTestNumber,
7911 false,
7912 true,
7913 true,
7914 false,
7915 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_SETPLAYBACKRANGE, false);
7916 #else
7917 fprintf(file, "Streaming tests not enabled\n");
7918 #endif
7919 }
7920 break;
7921 case DLA_StreamingNetworkDisconnectReconnectWhileProc_AddDataSource:
7922 {
7923 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7924 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_AddDataSource");
7925 iCurrentTest =
7926 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7927 PVMF_MIME_YUV420,
7928 PVMF_MIME_PCM16,
7929 iCurrentTestNumber,
7930 false,
7931 false,
7932 true,
7933 false,
7934 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ADDDATASOURCE, true);
7935 #else
7936 fprintf(file, "Streaming tests not enabled\n");
7937 #endif
7938 }
7939 break;
7940 case DLA_StreamingNetworkDisconnectReconnectWhileProc_Init:
7941 {
7942 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7943 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_Init");
7944 iCurrentTest =
7945 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7946 PVMF_MIME_YUV420,
7947 PVMF_MIME_PCM16,
7948 iCurrentTestNumber,
7949 false,
7950 false,
7951 true,
7952 false,
7953 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_INIT1, true);
7954 #else
7955 fprintf(file, "Streaming tests not enabled\n");
7956 #endif
7957 }
7958 break;
7959 case DLA_StreamingNetworkDisconnectReconnectWhileProc_LicenseAcquired:
7960 {
7961 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7962 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_LicenseAcquired");
7963 iCurrentTest =
7964 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7965 PVMF_MIME_YUV420,
7966 PVMF_MIME_PCM16,
7967 iCurrentTestNumber,
7968 false,
7969 false,
7970 true,
7971 false,
7972 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ACQUIRELICENSE, true);
7973 #else
7974 fprintf(file, "Streaming tests not enabled\n");
7975 #endif
7976 }
7977 break;
7978 case DLA_StreamingNetworkDisconnectReconnectWhileProc_AddDataSinkVideo:
7979 {
7980 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
7981 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_AddDataSinkVideo");
7982 iCurrentTest =
7983 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
7984 PVMF_MIME_YUV420,
7985 PVMF_MIME_PCM16,
7986 iCurrentTestNumber,
7987 false,
7988 false,
7989 true,
7990 false,
7991 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ADDDATASINK_VIDEO, true);
7992 #else
7993 fprintf(file, "Streaming tests not enabled\n");
7994 #endif
7995 }
7996 break;
7997 case DLA_StreamingNetworkDisconnectReconnectWhileProc_AddDataSinkAudio:
7998 {
7999 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8000 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_AddDataSinkAudio");
8001 iCurrentTest =
8002 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8003 PVMF_MIME_YUV420,
8004 PVMF_MIME_PCM16,
8005 iCurrentTestNumber,
8006 false,
8007 false,
8008 true,
8009 false,
8010 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_ADDDATASINK_AUDIO, true);
8011 #else
8012 fprintf(file, "Streaming tests not enabled\n");
8013 #endif
8014 }
8015 break;
8016 case DLA_StreamingNetworkDisconnectReconnectWhileProc_Prepare:
8017 {
8018 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8019 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_Prepare");
8020 iCurrentTest =
8021 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8022 PVMF_MIME_YUV420,
8023 PVMF_MIME_PCM16,
8024 iCurrentTestNumber,
8025 false,
8026 false,
8027 true,
8028 false,
8029 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_PREPARE, true);
8030 #else
8031 fprintf(file, "Streaming tests not enabled\n");
8032 #endif
8033 }
8034 break;
8035 case DLA_StreamingNetworkDisconnectReconnectWhileProc_Start:
8036 {
8037 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8038 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_Start");
8039 iCurrentTest =
8040 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8041 PVMF_MIME_YUV420,
8042 PVMF_MIME_PCM16,
8043 iCurrentTestNumber,
8044 false,
8045 false,
8046 true,
8047 false,
8048 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_START, true);
8049 #else
8050 fprintf(file, "Streaming tests not enabled\n");
8051 #endif
8052 }
8053 break;
8054 case DLA_StreamingNetworkDisconnectReconnectWhileProc_Pause:
8055 {
8056 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8057 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_Pause");
8058 iCurrentTest =
8059 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8060 PVMF_MIME_YUV420,
8061 PVMF_MIME_PCM16,
8062 iCurrentTestNumber,
8063 true,
8064 false,
8065 true,
8066 false,
8067 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_PAUSE, true);
8068 #else
8069 fprintf(file, "Streaming tests not enabled\n");
8070 #endif
8071 }
8072 break;
8073 case DLA_StreamingNetworkDisconnectReconnectWhileProc_Resume:
8074 {
8075 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8076 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_Resume");
8077 iCurrentTest =
8078 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8079 PVMF_MIME_YUV420,
8080 PVMF_MIME_PCM16,
8081 iCurrentTestNumber,
8082 true,
8083 false,
8084 true,
8085 false,
8086 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_RESUME, true);
8087 #else
8088 fprintf(file, "Streaming tests not enabled\n");
8089 #endif
8090 }
8091 break;
8092 case DLA_StreamingNetworkDisconnectReconnectWhileProc_Stop:
8093 {
8094 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8095 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_Stop");
8096 iCurrentTest =
8097 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8098 PVMF_MIME_YUV420,
8099 PVMF_MIME_PCM16,
8100 iCurrentTestNumber,
8101 false,
8102 false,
8103 false,
8104 false,
8105 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_STOP, true);
8106 #else
8107 fprintf(file, "Streaming tests not enabled\n");
8108 #endif
8109 }
8110 break;
8111
8112 case DLA_StreamingNetworkDisconnectReconnectWhileProc_SetPlaybackRange:
8113 {
8114 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8115 fprintf(file, "DLA_StreamingNetworkDisconnectReconnectWhileProc_SetPlaybackRange");
8116 iCurrentTest =
8117 new pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect(testparam,
8118 PVMF_MIME_YUV420,
8119 PVMF_MIME_PCM16,
8120 iCurrentTestNumber,
8121 false,
8122 true,
8123 true,
8124 false,
8125 false, pvplayer_async_test_DLAstreamingnetworkdisconnectreconnect::STATE_SETPLAYBACKRANGE, true);
8126 #else
8127 fprintf(file, "Streaming tests not enabled\n");
8128 #endif
8129 }
8130 break;
8131
8132 case DLA_StreamingNetworkDisconnectCancelAll_AddDataSource:
8133 {
8134 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8135 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_AddDataSource");
8136 iCurrentTest =
8137 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8138 PVMF_MIME_YUV420,
8139 PVMF_MIME_PCM16,
8140 iCurrentTestNumber,
8141 false,
8142 false,
8143 true,
8144 false,
8145 false,
8146 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ADDDATASOURCE,
8147 false);
8148 #else
8149 fprintf(file, "Streaming tests not enabled\n");
8150 #endif
8151 }
8152 break;
8153
8154 case DLA_StreamingNetworkDisconnectCancelAll_Init:
8155 {
8156 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8157 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_Init");
8158 iCurrentTest =
8159 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8160 PVMF_MIME_YUV420,
8161 PVMF_MIME_PCM16,
8162 iCurrentTestNumber,
8163 false,
8164 false,
8165 true,
8166 false,
8167 false,
8168 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_INIT1,
8169 false);
8170 #else
8171 fprintf(file, "Streaming tests not enabled\n");
8172 #endif
8173 }
8174 break;
8175
8176 case DLA_StreamingNetworkDisconnectCancelAll_LicenseAcquired:
8177 {
8178 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8179 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_LicenseAcquired");
8180 iCurrentTest =
8181 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8182 PVMF_MIME_YUV420,
8183 PVMF_MIME_PCM16,
8184 iCurrentTestNumber,
8185 false,
8186 false,
8187 true,
8188 false,
8189 false,
8190 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ACQUIRELICENSE,
8191 false);
8192 #else
8193 fprintf(file, "Streaming tests not enabled\n");
8194 #endif
8195 }
8196 break;
8197
8198 case DLA_StreamingNetworkDisconnectCancelAll_AddDataSinkVideo:
8199 {
8200 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8201 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_AddDataSinkVideo");
8202 iCurrentTest =
8203 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8204 PVMF_MIME_YUV420,
8205 PVMF_MIME_PCM16,
8206 iCurrentTestNumber,
8207 false,
8208 false,
8209 true,
8210 false,
8211 false,
8212 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ADDDATASINK_VIDEO,
8213 false);
8214 #else
8215 fprintf(file, "Streaming tests not enabled\n");
8216 #endif
8217 }
8218 break;
8219
8220
8221 case DLA_StreamingNetworkDisconnectCancelAll_AddDataSinkAudio:
8222 {
8223 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8224 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_AddDataSinkAudio");
8225 iCurrentTest =
8226 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8227 PVMF_MIME_YUV420,
8228 PVMF_MIME_PCM16,
8229 iCurrentTestNumber,
8230 false,
8231 false,
8232 true,
8233 false,
8234 false,
8235 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ADDDATASINK_AUDIO,
8236 false);
8237 #else
8238 fprintf(file, "Streaming tests not enabled\n");
8239 #endif
8240 }
8241 break;
8242
8243
8244 case DLA_StreamingNetworkDisconnectCancelAll_Prepare:
8245 {
8246 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8247 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_Prepare");
8248 iCurrentTest =
8249 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8250 PVMF_MIME_YUV420,
8251 PVMF_MIME_PCM16,
8252 iCurrentTestNumber,
8253 false,
8254 false,
8255 true,
8256 false,
8257 false,
8258 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_PREPARE,
8259 false);
8260 #else
8261 fprintf(file, "Streaming tests not enabled\n");
8262 #endif
8263 }
8264 break;
8265
8266
8267 case DLA_StreamingNetworkDisconnectCancelAll_Start:
8268 {
8269 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8270 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_Start");
8271 iCurrentTest =
8272 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8273 PVMF_MIME_YUV420,
8274 PVMF_MIME_PCM16,
8275 iCurrentTestNumber,
8276 false,
8277 false,
8278 true,
8279 false,
8280 false,
8281 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_START,
8282 false);
8283 #else
8284 fprintf(file, "Streaming tests not enabled\n");
8285 #endif
8286 }
8287 break;
8288
8289
8290 case DLA_StreamingNetworkDisconnectCancelAll_Pause:
8291 {
8292 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8293 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_Pause");
8294 iCurrentTest =
8295 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8296 PVMF_MIME_YUV420,
8297 PVMF_MIME_PCM16,
8298 iCurrentTestNumber,
8299 true,
8300 false,
8301 true,
8302 false,
8303 false,
8304 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_PAUSE,
8305 false);
8306 #else
8307 fprintf(file, "Streaming tests not enabled\n");
8308 #endif
8309 }
8310 break;
8311
8312 case DLA_StreamingNetworkDisconnectCancelAll_Resume:
8313 {
8314 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8315 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_Resume");
8316 iCurrentTest =
8317 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8318 PVMF_MIME_YUV420,
8319 PVMF_MIME_PCM16,
8320 iCurrentTestNumber,
8321 true,
8322 false,
8323 true,
8324 false,
8325 false,
8326 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_RESUME,
8327 false);
8328 #else
8329 fprintf(file, "Streaming tests not enabled\n");
8330 #endif
8331 }
8332 break;
8333
8334 case DLA_StreamingNetworkDisconnectCancelAll_Stop:
8335 {
8336 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8337 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_Stop");
8338 iCurrentTest =
8339 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8340 PVMF_MIME_YUV420,
8341 PVMF_MIME_PCM16,
8342 iCurrentTestNumber,
8343 false,
8344 false,
8345 true,
8346 false,
8347 false,
8348 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_STOP,
8349 false);
8350 #else
8351 fprintf(file, "Streaming tests not enabled\n");
8352 #endif
8353 }
8354 break;
8355
8356 case DLA_StreamingNetworkDisconnectCancelAll_SetPlaybackRange:
8357 {
8358 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8359 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAll_SetPlaybackRange");
8360 iCurrentTest =
8361 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8362 PVMF_MIME_YUV420,
8363 PVMF_MIME_PCM16,
8364 iCurrentTestNumber,
8365 false,
8366 true,
8367 true,
8368 false,
8369 false,
8370 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_SETPLAYBACKRANGE,
8371 false);
8372 #else
8373 fprintf(file, "Streaming tests not enabled\n");
8374 #endif
8375 }
8376 break;
8377
8378 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_AddDataSource:
8379 {
8380 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8381 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_AddDataSource");
8382 iCurrentTest =
8383 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8384 PVMF_MIME_YUV420,
8385 PVMF_MIME_PCM16,
8386 iCurrentTestNumber,
8387 false,
8388 false,
8389 true,
8390 false,
8391 false,
8392 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ADDDATASOURCE,
8393 true);
8394 #else
8395 fprintf(file, "Streaming tests not enabled\n");
8396 #endif
8397 }
8398 break;
8399
8400 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_Init:
8401 {
8402 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8403 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_Init");
8404 iCurrentTest =
8405 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8406 PVMF_MIME_YUV420,
8407 PVMF_MIME_PCM16,
8408 iCurrentTestNumber,
8409 false,
8410 false,
8411 true,
8412 false,
8413 false,
8414 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_INIT1,
8415 true);
8416 #else
8417 fprintf(file, "Streaming tests not enabled\n");
8418 #endif
8419 }
8420 break;
8421
8422
8423 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_LicenseAcquired:
8424 {
8425 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8426 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_LicenseAcquired");
8427 iCurrentTest =
8428 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8429 PVMF_MIME_YUV420,
8430 PVMF_MIME_PCM16,
8431 iCurrentTestNumber,
8432 false,
8433 false,
8434 true,
8435 false,
8436 false,
8437 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ACQUIRELICENSE,
8438 true);
8439 #else
8440 fprintf(file, "Streaming tests not enabled\n");
8441 #endif
8442 }
8443 break;
8444
8445
8446 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_AddDataSinkVideo:
8447 {
8448 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8449 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_AddDataSinkVideo");
8450 iCurrentTest =
8451 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8452 PVMF_MIME_YUV420,
8453 PVMF_MIME_PCM16,
8454 iCurrentTestNumber,
8455 false,
8456 false,
8457 true,
8458 false,
8459 false,
8460 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ADDDATASINK_VIDEO,
8461 true);
8462 #else
8463 fprintf(file, "Streaming tests not enabled\n");
8464 #endif
8465 }
8466 break;
8467
8468 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_AddDataSinkAudio:
8469 {
8470 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8471 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_AddDataSinkAudio");
8472 iCurrentTest =
8473 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8474 PVMF_MIME_YUV420,
8475 PVMF_MIME_PCM16,
8476 iCurrentTestNumber,
8477 false,
8478 false,
8479 true,
8480 false,
8481 false,
8482 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_ADDDATASINK_AUDIO,
8483 true);
8484 #else
8485 fprintf(file, "Streaming tests not enabled\n");
8486 #endif
8487 }
8488 break;
8489
8490 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_Prepare:
8491 {
8492 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8493 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_Prepare");
8494 iCurrentTest =
8495 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8496 PVMF_MIME_YUV420,
8497 PVMF_MIME_PCM16,
8498 iCurrentTestNumber,
8499 false,
8500 false,
8501 true,
8502 false,
8503 false,
8504 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_PREPARE,
8505 true);
8506 #else
8507 fprintf(file, "Streaming tests not enabled\n");
8508 #endif
8509 }
8510 break;
8511
8512 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_Start:
8513 {
8514 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8515 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_Start");
8516 iCurrentTest =
8517 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8518 PVMF_MIME_YUV420,
8519 PVMF_MIME_PCM16,
8520 iCurrentTestNumber,
8521 false,
8522 false,
8523 true,
8524 false,
8525 false,
8526 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_START,
8527 true);
8528 #else
8529 fprintf(file, "Streaming tests not enabled\n");
8530 #endif
8531 }
8532 break;
8533
8534 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_Pause:
8535 {
8536 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8537 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_Pause");
8538 iCurrentTest =
8539 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8540 PVMF_MIME_YUV420,
8541 PVMF_MIME_PCM16,
8542 iCurrentTestNumber,
8543 true,
8544 false,
8545 true,
8546 false,
8547 false,
8548 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_PAUSE,
8549 true);
8550 #else
8551 fprintf(file, "Streaming tests not enabled\n");
8552 #endif
8553 }
8554 break;
8555
8556 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_Resume:
8557 {
8558 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8559 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_Resume");
8560 iCurrentTest =
8561 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8562 PVMF_MIME_YUV420,
8563 PVMF_MIME_PCM16,
8564 iCurrentTestNumber,
8565 true,
8566 false,
8567 true,
8568 false,
8569 false,
8570 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_RESUME,
8571 true);
8572 #else
8573 fprintf(file, "Streaming tests not enabled\n");
8574 #endif
8575 }
8576 break;
8577
8578 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_Stop:
8579 {
8580 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8581 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_Stop");
8582 iCurrentTest =
8583 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8584 PVMF_MIME_YUV420,
8585 PVMF_MIME_PCM16,
8586 iCurrentTestNumber,
8587 false,
8588 false,
8589 true,
8590 false,
8591 false,
8592 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_STOP,
8593 true);
8594 #else
8595 fprintf(file, "Streaming tests not enabled\n");
8596 #endif
8597 }
8598 break;
8599
8600
8601 case DLA_StreamingNetworkDisconnectCancelAllWhileProc_SetPlaybackRange:
8602 {
8603 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8604 fprintf(file, "DLA_StreamingNetworkDisconnectCancelAllWhileProc_SetPlaybackRange");
8605 iCurrentTest =
8606 new pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall(testparam,
8607 PVMF_MIME_YUV420,
8608 PVMF_MIME_PCM16,
8609 iCurrentTestNumber,
8610 false,
8611 true,
8612 true,
8613 false,
8614 false,
8615 pvplayer_async_test_DLAstreamingnetworkdisconnectcancelall::STATE_SETPLAYBACKRANGE,
8616 true);
8617 #else
8618 fprintf(file, "Streaming tests not enabled\n");
8619 #endif
8620 }
8621 break;
8622
8623 case DLA_StreamingOpenPlayMultiplePauseResumeUntilEOSTest:
8624 {
8625 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8626 fprintf(file, "DLA_StreamingOpenPlayMultiplePauseResumeUntilEOSTest");
8627 iCurrentTest =
8628 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8629 PVMF_MIME_YUV420,
8630 PVMF_MIME_PCM16,
8631 iCurrentTestNumber,
8632 true,
8633 false,
8634 true,
8635 false,
8636 false,
8637 false);
8638 pvplayer_async_test_DLAstreamingopenplaystop* ptr =
8639 (pvplayer_async_test_DLAstreamingopenplaystop*)iCurrentTest;
8640 ptr->setMultiplePauseMode(5, 2, 2);
8641 #else
8642 fprintf(file, "Streaming tests not enabled\n");
8643 #endif
8644 }
8645 break;
8646
8647 case DLA_StreamingOpenPlayMultipleSeekUntilEOSTest:
8648 {
8649 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8650 fprintf(file, "DLA_StreamingOpenPlayMultipleSeekUntilEOSTest");
8651 iCurrentTest =
8652 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8653 PVMF_MIME_YUV420,
8654 PVMF_MIME_PCM16,
8655 iCurrentTestNumber,
8656 false,
8657 true,
8658 true,
8659 false,
8660 false,
8661 false);
8662 pvplayer_async_test_DLAstreamingopenplaystop* ptr =
8663 (pvplayer_async_test_DLAstreamingopenplaystop*)iCurrentTest;
8664 ptr->setMultipleSeekMode(SEQUENTIAL_SEEK_INTERVAL, FIRST_SEEK_AFTER_START);
8665 #else
8666 fprintf(file, "Streaming tests not enabled\n");
8667 #endif
8668 }
8669 break;
8670
8671 case DLA_StreamingOpenPlayStop_SleepAddDataSource:
8672 {
8673 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8674 fprintf(file, "DLA_StreamingOpenPlayStop_SleepAddDataSource");
8675 iCurrentTest =
8676 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8677 PVMF_MIME_YUV420,
8678 PVMF_MIME_PCM16,
8679 iCurrentTestNumber,
8680 false,
8681 false,
8682 false,
8683 false,
8684 false,
8685 false,
8686 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8687 false,
8688 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASOURCE,
8689 true);
8690 #else
8691 fprintf(file, "Streaming tests not enabled\n");
8692 #endif
8693 }
8694 break;
8695
8696 case DLA_StreamingOpenPlayStop_SleepInit:
8697 {
8698 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8699 fprintf(file, "DLA_StreamingOpenPlayStop_SleepInit");
8700 iCurrentTest =
8701 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8702 PVMF_MIME_YUV420,
8703 PVMF_MIME_PCM16,
8704 iCurrentTestNumber,
8705 false,
8706 false,
8707 false,
8708 false,
8709 false,
8710 false,
8711 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8712 false,
8713 pvplayer_async_test_DLAstreamingopenplaystop::STATE_INIT1,
8714 true);
8715 #else
8716 fprintf(file, "Streaming tests not enabled\n");
8717 #endif
8718 }
8719
8720 break;
8721
8722 case DLA_StreamingOpenPlayStop_SleepLicenseAcquired:
8723 {
8724 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8725 fprintf(file, "DLA_StreamingOpenPlayStop_SleepLicenseAcquired");
8726 iCurrentTest =
8727 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8728 PVMF_MIME_YUV420,
8729 PVMF_MIME_PCM16,
8730 iCurrentTestNumber,
8731 false,
8732 false,
8733 false,
8734 false,
8735 false,
8736 false,
8737 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8738 false,
8739 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ACQUIRELICENSE,
8740 true);
8741 #else
8742 fprintf(file, "Streaming tests not enabled\n");
8743 #endif
8744 }
8745 break;
8746
8747 case DLA_StreamingOpenPlayStop_SleepAddDataSinkVideo:
8748 {
8749 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8750 fprintf(file, "DLA_StreamingOpenPlayStop_SleepAddDataSinkVideo");
8751 iCurrentTest =
8752 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8753 PVMF_MIME_YUV420,
8754 PVMF_MIME_PCM16,
8755 iCurrentTestNumber,
8756 false,
8757 false,
8758 false,
8759 false,
8760 false,
8761 false,
8762 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8763 false,
8764 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASINK_VIDEO,
8765 true);
8766 #else
8767 fprintf(file, "Streaming tests not enabled\n");
8768 #endif
8769 }
8770 break;
8771
8772 case DLA_StreamingOpenPlayStop_SleepAddDataSinkAudio:
8773 {
8774 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8775 fprintf(file, "DLA_StreamingOpenPlayStop_SleepAddDataSinkAudio");
8776 iCurrentTest =
8777 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8778 PVMF_MIME_YUV420,
8779 PVMF_MIME_PCM16,
8780 iCurrentTestNumber,
8781 false,
8782 false,
8783 false,
8784 false,
8785 false,
8786 false,
8787 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8788 false,
8789 pvplayer_async_test_DLAstreamingopenplaystop::STATE_ADDDATASINK_AUDIO,
8790 true);
8791 #else
8792 fprintf(file, "Streaming tests not enabled\n");
8793 #endif
8794 }
8795 break;
8796
8797 case DLA_StreamingOpenPlayStop_SleepPrepare:
8798 {
8799 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8800 fprintf(file, "DLA_StreamingOpenPlayStop_SleepPrepare");
8801 iCurrentTest =
8802 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8803 PVMF_MIME_YUV420,
8804 PVMF_MIME_PCM16,
8805 iCurrentTestNumber,
8806 false,
8807 false,
8808 false,
8809 false,
8810 false,
8811 false,
8812 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8813 false,
8814 pvplayer_async_test_DLAstreamingopenplaystop::STATE_PREPARE,
8815 true);
8816 #else
8817 fprintf(file, "Streaming tests not enabled\n");
8818 #endif
8819 }
8820 break;
8821
8822 case DLA_StreamingOpenPlayStop_SleepStop:
8823 {
8824 #if RUN_STREAMING_TESTCASES && RUN_CPMJANUS_TESTCASES
8825 fprintf(file, "DLA_StreamingOpenPlayStop_SleepStop");
8826 iCurrentTest =
8827 new pvplayer_async_test_DLAstreamingopenplaystop(testparam,
8828 PVMF_MIME_YUV420,
8829 PVMF_MIME_PCM16,
8830 iCurrentTestNumber,
8831 false,
8832 false,
8833 false,
8834 false,
8835 false,
8836 false,
8837 pvplayer_async_test_DLAstreamingopenplaystop::STATE_CLEANUPANDCOMPLETE,
8838 false,
8839 pvplayer_async_test_DLAstreamingopenplaystop::STATE_STOP,
8840 true);
8841 #else
8842 fprintf(file, "Streaming tests not enabled\n");
8843 #endif
8844 }
8845 break;
8846
8847 case DLA_StreamingCancelAcquireLicense_JupiterCPMTest:
8848 {
8849 #if RUN_STREAMING_TESTCASES && RUN_CPMJUPITER_TESTCASES
8850 fprintf(file, "DLA_StreamingCancelAcquireLicense_JupiterCPMTest");
8851 iCurrentTest = new pvplayer_async_test_jupitercpm_DLAstreamingopenplaystop(testparam,
8852 PVMF_MIME_YUV420,
8853 PVMF_MIME_PCM16,
8854 iCurrentTestNumber,
8855 false,
8856 false,
8857 true,
8858 false,
8859 false,
8860 true);
8861
8862 #else
8863 fprintf(file, "Jupiter Streaming tests not enabled\n");
8864 #endif
8865 }
8866 break;
8867
8868 case DVBH_StreamingOpenPlayStopTest:
8869 #if RUN_STREAMING_TESTCASES
8870 fprintf(file, "DVBH_StreamingOpenPlayStopTest");
8871 iCurrentTest = new pvplayer_async_test_dvbh_streamingopenplaystop(testparam,
8872 PVMF_MIME_YUV420,
8873 PVMF_MIME_PCM16,
8874 iCurrentTestNumber,
8875 false,
8876 false,
8877 false,
8878 false,
8879 false);
8880 #else
8881 fprintf(file, "DVB Streaming tests not enabled\n");
8882 #endif
8883 break;
8884
8885 case DVBH_StreamingOpenPlayUntilEOSTest:
8886 #if RUN_STREAMING_TESTCASES
8887 fprintf(file, "DVBH_StreamingOpenPlayUntilEOSTest");
8888 iCurrentTest = new pvplayer_async_test_dvbh_streamingopenplaystop(testparam,
8889 PVMF_MIME_YUV420,
8890 PVMF_MIME_PCM16,
8891 iCurrentTestNumber,
8892 false,
8893 false,
8894 true,
8895 false,
8896 false);
8897 #else
8898 fprintf(file, "DVB Streaming tests not enabled\n");
8899 #endif
8900 break;
8901
8902 case PVR_FILEPLAYBACK_OpenPlayUntilEOFTest:
8903 #if RUN_STREAMING_TESTCASES
8904 #if PVR_SUPPORT
8905 fprintf(file, "PVR_FILEPLAYBACK_OpenPlayUntilEOFTest");
8906 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
8907 PVMF_MIME_YUV420,
8908 PVMF_MIME_PCM16,
8909 iCurrentTestNumber);
8910 #else
8911 fprintf(file, "PVR tests not enabled\n");
8912 #endif
8913 #else
8914 fprintf(file, "Streaming tests not enabled\n");
8915 #endif
8916 break;
8917
8918 case PVR_FILEPLAYBACK_OpenPlayRepositionPlayStopTest:
8919 #if RUN_STREAMING_TESTCASES
8920 #if PVR_SUPPORT
8921 fprintf(file, "PVR_FILEPLAYBACK_OpenPlayRepositionPlayStopTes");
8922 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
8923 PVMF_MIME_YUV420,
8924 PVMF_MIME_PCM16,
8925 iCurrentTestNumber);
8926 #else
8927 fprintf(file, "PVR tests not enabled\n");
8928 #endif
8929 #else
8930 fprintf(file, "Streaming tests not enabled\n");
8931 #endif
8932 break;
8933
8934 case PVR_FILEPLAYBACK_OpenPlayPauseRepositionTest:
8935 #if RUN_STREAMING_TESTCASES
8936 #if PVR_SUPPORT
8937 fprintf(file, "PVR_FILEPLAYBACK_OpenPlayPauseRepositionTest");
8938 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
8939 PVMF_MIME_YUV420,
8940 PVMF_MIME_PCM16,
8941 iCurrentTestNumber);
8942 #else
8943 fprintf(file, "PVR tests not enabled\n");
8944 #endif
8945 #else
8946 fprintf(file, "Streaming tests not enabled\n");
8947 #endif
8948 break;
8949
8950 case PVR_FILEPLAYBACK_OpenPlayVerifyDurationTest:
8951 #if RUN_STREAMING_TESTCASES
8952 #if PVR_SUPPORT
8953 fprintf(file, "PVR_FILEPLAYBACK_OpenPlayVerifyDurationTest");
8954 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
8955 PVMF_MIME_YUV420,
8956 PVMF_MIME_PCM16,
8957 iCurrentTestNumber);
8958 #else
8959 fprintf(file, "PVR tests not enabled\n");
8960 #endif
8961 #else
8962 fprintf(file, "Streaming tests not enabled\n");
8963 #endif
8964 break;
8965
8966 case PVR_Recorder_RecordOnStartUp:
8967 #if RUN_STREAMING_TESTCASES
8968 #if PVR_SUPPORT
8969 fprintf(file, "PVR_Recorder_RecordOnStartUp");
8970 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
8971 PVMF_MIME_YUV420,
8972 PVMF_MIME_PCM16,
8973 iCurrentTestNumber);
8974 #else
8975 fprintf(file, "PVR tests not enabled\n");
8976 #endif
8977 #else
8978 fprintf(file, "Streaming tests not enabled\n");
8979 #endif
8980 break;
8981
8982 case PVR_Recorder_RecordOnDemand:
8983 #if RUN_STREAMING_TESTCASES
8984 #if PVR_SUPPORT
8985 fprintf(file, "PVR_Recorder_RecordOnDemand");
8986 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
8987 PVMF_MIME_YUV420,
8988 PVMF_MIME_PCM16,
8989 iCurrentTestNumber);
8990 #else
8991 fprintf(file, "PVR tests not enabled\n");
8992 #endif
8993 #else
8994 fprintf(file, "Streaming tests not enabled\n");
8995 #endif
8996 break;
8997
8998 case PVR_Recorder_MultiplePause:
8999 #if RUN_STREAMING_TESTCASES
9000 #if PVR_SUPPORT
9001 fprintf(file, "PVR_Recorder_MultiplePause");
9002 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9003 PVMF_MIME_YUV420,
9004 PVMF_MIME_PCM16,
9005 iCurrentTestNumber);
9006 #else
9007 fprintf(file, "PVR tests not enabled\n");
9008 #endif
9009 #else
9010 fprintf(file, "Streaming tests not enabled\n");
9011 #endif
9012 break;
9013
9014 case PVR_Recorder_MultiplePauseJTL:
9015 #if RUN_STREAMING_TESTCASES
9016 #if PVR_SUPPORT
9017 fprintf(file, "PVR_Recorder_MultiplePauseJTL");
9018 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9019 PVMF_MIME_YUV420,
9020 PVMF_MIME_PCM16,
9021 iCurrentTestNumber);
9022 #else
9023 fprintf(file, "PVR tests not enabled\n");
9024 #endif
9025 #else
9026 fprintf(file, "Streaming tests not enabled\n");
9027 #endif
9028 break;
9029
9030 case PVR_Recorder_MultipleRepos:
9031 #if RUN_STREAMING_TESTCASES
9032 #if PVR_SUPPORT
9033 fprintf(file, "PVR_Recorder_MultipleRepos");
9034 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9035 PVMF_MIME_YUV420,
9036 PVMF_MIME_PCM16,
9037 iCurrentTestNumber);
9038 #else
9039 fprintf(file, "PVR tests not enabled\n");
9040 #endif
9041 #else
9042 fprintf(file, "Streaming tests not enabled\n");
9043 #endif
9044 break;
9045
9046 case PVR_Recorder_MultipleRecord:
9047 #if RUN_STREAMING_TESTCASES
9048 #if PVR_SUPPORT
9049 fprintf(file, "PVR_Recorder_MultipleRepos");
9050 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9051 PVMF_MIME_YUV420,
9052 PVMF_MIME_PCM16,
9053 iCurrentTestNumber);
9054 #else
9055 fprintf(file, "PVR tests not enabled\n");
9056 #endif
9057 #else
9058 fprintf(file, "Streaming tests not enabled\n");
9059 #endif
9060 break;
9061
9062
9063 case PVR_MLB_StreamingOpenPlayLivePausePlayStopTest:
9064 #if RUN_STREAMING_TESTCASES
9065 #if PVR_SUPPORT
9066 fprintf(file, "PVR_MLB_StreamingOpenPlayLivePausePlayStopTest");
9067 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9068 PVMF_MIME_YUV420,
9069 PVMF_MIME_PCM16,
9070 iCurrentTestNumber);
9071 #else
9072 fprintf(file, "PVR tests not enabled\n");
9073 #endif
9074 #else
9075 fprintf(file, "Streaming tests not enabled\n");
9076 #endif
9077 break;
9078
9079 case PVR_MLB_StreamingOpenPlayLivePausePlaySeekStopTest:
9080 #if RUN_STREAMING_TESTCASES
9081 #if PVR_SUPPORT
9082 fprintf(file, "PVR_MLB_StreamingOpenPlayLivePausePlaySeekStopTest");
9083 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9084 PVMF_MIME_YUV420,
9085 PVMF_MIME_PCM16,
9086 iCurrentTestNumber);
9087 #else
9088 fprintf(file, "PVR tests not enabled\n");
9089 #endif
9090 #else
9091 fprintf(file, "Streaming tests not enabled\n");
9092 #endif
9093 break;
9094
9095 case PVR_MLB_StreamingOpenPlayLiveBufferBoundaryCheckTest:
9096 #if RUN_STREAMING_TESTCASES
9097 #if PVR_SUPPORT
9098 fprintf(file, "PVR_MLB_StreamingOpenPlayLiveBufferBoundaryCheckTest");
9099 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9100 PVMF_MIME_YUV420,
9101 PVMF_MIME_PCM16,
9102 iCurrentTestNumber);
9103 #else
9104 fprintf(file, "PVR tests not enabled\n");
9105 #endif
9106 #else
9107 fprintf(file, "Streaming tests not enabled\n");
9108 #endif
9109 break;
9110
9111 case PVR_MLB_StreamingOpenPlayMultipleLivePausePlayTest:
9112 case PVR_FSLB_StreamingOpenPlayMultipleLivePausePlayTest:
9113 {
9114 #if RUN_STREAMING_TESTCASES
9115 #if PVR_SUPPORT
9116 if (PVR_MLB_StreamingOpenPlayMultipleLivePausePlayTest == iCurrentTestNumber)
9117 {
9118 fprintf(file, "PVR_MLB_StreamingOpenPlayMultipleLivePausePlayTest");
9119 }
9120 else
9121 {
9122 fprintf(file, "PVR_FSLB_StreamingOpenPlayMultipleLivePausePlayTest");
9123 }
9124 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9125 PVMF_MIME_YUV420,
9126 PVMF_MIME_PCM16,
9127 iCurrentTestNumber);
9128 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9129 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9130 ptr->setMultiplePauseMode(5);
9131
9132 #else
9133 fprintf(file, "PVR tests not enabled\n");
9134 #endif
9135 #else
9136 fprintf(file, "Streaming tests not enabled\n");
9137 #endif
9138 }
9139 break;
9140
9141 case PVR_MLB_StreamingOpenPlayMultipleLivePauseRandomDurationPlayTest:
9142 case PVR_FSLB_StreamingOpenPlayMultipleLivePauseRandomDurationPlayTest:
9143 {
9144 #if RUN_STREAMING_TESTCASES
9145 #if PVR_SUPPORT
9146 if (PVR_MLB_StreamingOpenPlayMultipleLivePauseRandomDurationPlayTest == iCurrentTestNumber)
9147 {
9148 fprintf(file, "PVR_MLB_StreamingOpenPlayMultipleLivePauseRandomDurationPlayTest");
9149 }
9150 else
9151 {
9152 fprintf(file, "PVR_FSLB_StreamingOpenPlayMultipleLivePauseRandomDurationPlayTest");
9153 }
9154 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9155 PVMF_MIME_YUV420,
9156 PVMF_MIME_PCM16,
9157 iCurrentTestNumber);
9158 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9159 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9160 ptr->setMultiplePauseMode(5);
9161 ptr->setRandomPauseDurationRange(10); // Duration range in seconds
9162
9163 #else
9164 fprintf(file, "PVR tests not enabled\n");
9165 #endif
9166 #else
9167 fprintf(file, "Streaming tests not enabled\n");
9168 #endif
9169 }
9170 break;
9171
9172 case PVR_MLB_StreamingOpenPlayLongLivePausePlayTest:
9173 case PVR_FSLB_StreamingOpenPlayLongLivePausePlayTest:
9174 {
9175 #if RUN_STREAMING_TESTCASES
9176 #if PVR_SUPPORT
9177 if (PVR_MLB_StreamingOpenPlayLongLivePausePlayTest == iCurrentTestNumber)
9178 {
9179 fprintf(file, "PVR_MLB_StreamingOpenPlayLongLivePausePlayTest");
9180 }
9181 else
9182 {
9183 fprintf(file, "PVR_FSLB_StreamingOpenPlayLongLivePausePlayTest");
9184 }
9185 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9186 PVMF_MIME_YUV420,
9187 PVMF_MIME_PCM16,
9188 iCurrentTestNumber);
9189 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9190 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9191 ptr->setLongPauseDuration(60*1000*1000);
9192
9193 #else
9194 fprintf(file, "PVR tests not enabled\n");
9195 #endif
9196 #else
9197 fprintf(file, "Streaming tests not enabled\n");
9198 #endif
9199 }
9200 break;
9201
9202 case PVR_MLB_StreamingOpenPlayLivePauseStopTest:
9203 case PVR_FSLB_StreamingOpenPlayLivePauseStopTest:
9204 {
9205 #if RUN_STREAMING_TESTCASES
9206 #if PVR_SUPPORT
9207 if (PVR_MLB_StreamingOpenPlayLivePauseStopTest == iCurrentTestNumber)
9208 {
9209 fprintf(file, "PVR_MLB_StreamingOpenPlayLivePauseStopTest");
9210 }
9211 else
9212 {
9213 fprintf(file, "PVR_FSLB_StreamingOpenPlayLivePauseStopTest");
9214 }
9215 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9216 PVMF_MIME_YUV420,
9217 PVMF_MIME_PCM16,
9218 iCurrentTestNumber);
9219 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9220 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9221 OSCL_UNUSED_ARG(ptr);
9222 #else
9223 fprintf(file, "PVR tests not enabled\n");
9224 #endif
9225 #else
9226 fprintf(file, "Streaming tests not enabled\n");
9227 #endif
9228 }
9229 break;
9230
9231 case PVR_MLB_StreamingOpenPauseJumpToLiveStopTest:
9232 case PVR_FSLB_StreamingOpenPauseJumpToLiveStopTest:
9233 {
9234 #if RUN_STREAMING_TESTCASES
9235 #if PVR_SUPPORT
9236 if (PVR_MLB_StreamingOpenPauseJumpToLiveStopTest == iCurrentTestNumber)
9237 {
9238 fprintf(file, "PVR_MLB_StreamingOpenPauseJumpToLiveStopTest");
9239 }
9240 else
9241 {
9242 fprintf(file, "PVR_FSLB_StreamingOpenPauseJumpToLiveStopTest");
9243 }
9244 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9245 PVMF_MIME_YUV420,
9246 PVMF_MIME_PCM16,
9247 iCurrentTestNumber);
9248 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9249 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9250 ptr->setMultiplePauseMode(5);
9251 ptr->setRandomPauseDurationRange(10); // Duration range in seconds
9252 #else
9253 fprintf(file, "PVR tests not enabled\n");
9254 #endif
9255 #else
9256 fprintf(file, "Streaming tests not enabled\n");
9257 #endif
9258 }
9259 break;
9260
9261 case PVR_MLB_StreamingOpenPauseResumeJumpToLiveStopTest:
9262 case PVR_FSLB_StreamingOpenPauseResumeJumpToLiveStopTest:
9263 {
9264 #if RUN_STREAMING_TESTCASES
9265 #if PVR_SUPPORT
9266 if (PVR_MLB_StreamingOpenPauseResumeJumpToLiveStopTest == iCurrentTestNumber)
9267 {
9268 fprintf(file, "PVR_MLB_StreamingOpenPauseResumeJumpToLiveStopTest");
9269 }
9270 else
9271 {
9272 fprintf(file, "PVR_FSLB_StreamingOpenPauseResumeJumpToLiveStopTest");
9273 }
9274 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9275 PVMF_MIME_YUV420,
9276 PVMF_MIME_PCM16,
9277 iCurrentTestNumber);
9278 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9279 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9280 ptr->setMultiplePauseMode(5);
9281 ptr->setRandomPauseDurationRange(10); // Duration range in seconds
9282 #else
9283 fprintf(file, "PVR tests not enabled\n");
9284 #endif
9285 #else
9286 fprintf(file, "Streaming tests not enabled\n");
9287 #endif
9288 }
9289 break;
9290
9291 case PVR_MLB_StreamingOpenPauseResumeStopTest:
9292 case PVR_FSLB_StreamingOpenPauseResumeStopTest:
9293 {
9294 #if RUN_STREAMING_TESTCASES
9295 #if PVR_SUPPORT
9296 if (PVR_MLB_StreamingOpenPauseResumeStopTest == iCurrentTestNumber)
9297 {
9298 fprintf(file, "PVR_MLB_StreamingOpenPauseResumeStopTest");
9299 }
9300 else
9301 {
9302 fprintf(file, "PVR_FSLB_StreamingOpenPauseResumeStopTest");
9303 }
9304 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9305 PVMF_MIME_YUV420,
9306 PVMF_MIME_PCM16,
9307 iCurrentTestNumber);
9308 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9309 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9310 OSCL_UNUSED_ARG(ptr);
9311 #else
9312 fprintf(file, "PVR tests not enabled\n");
9313 #endif
9314 #else
9315 fprintf(file, "Streaming tests not enabled\n");
9316 #endif
9317 }
9318 break;
9319 case PVR_MLB_StreamingRTSPUrlPauseResumeStopTest:
9320 case PVR_FSLB_StreamingRTSPUrlPauseResumeStopTest:
9321 {
9322 #if RUN_STREAMING_TESTCASES
9323 #if PVR_SUPPORT
9324 if (PVR_MLB_StreamingRTSPUrlPauseResumeStopTest == iCurrentTestNumber)
9325 {
9326 fprintf(file, "PVR_MLB_StreamingRTSPUrlPauseResumeStopTest");
9327 }
9328 else
9329 {
9330 fprintf(file, "PVR_FSLB_StreamingRTSPUrlPauseResumeStopTest");
9331 }
9332 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9333 PVMF_MIME_YUV420,
9334 PVMF_MIME_PCM16,
9335 iCurrentTestNumber);
9336 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9337 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9338 ptr->setRtspUrlInput();
9339 #else
9340 fprintf(file, "PVR tests not enabled\n");
9341 #endif
9342 #else
9343 fprintf(file, "Streaming tests not enabled\n");
9344 #endif
9345 }
9346 break;
9347
9348 case PVR_MLB_StreamingPauseResumeRepositionStopTest:
9349 case PVR_FSLB_StreamingPauseResumeRepositionStopTest:
9350 {
9351 #if RUN_STREAMING_TESTCASES
9352 #if PVR_SUPPORT
9353 if (PVR_MLB_StreamingPauseResumeRepositionStopTest == iCurrentTestNumber)
9354 {
9355 fprintf(file, "PVR_MLB_StreamingPauseResumeRepositionStopTest");
9356 }
9357 else
9358 {
9359 fprintf(file, "PVR_FSLB_StreamingPauseResumeRepositionStopTest");
9360 }
9361 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9362 PVMF_MIME_YUV420,
9363 PVMF_MIME_PCM16,
9364 iCurrentTestNumber);
9365 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9366 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9367 OSCL_UNUSED_ARG(ptr);
9368 #else
9369 fprintf(file, "PVR tests not enabled\n");
9370 #endif
9371 #else
9372 fprintf(file, "Streaming tests not enabled\n");
9373 #endif
9374 }
9375 break;
9376
9377 case PVR_MLB_StreamingPauseRepositionResumeStopTest:
9378 case PVR_FSLB_StreamingPauseRepositionResumeStopTest:
9379 {
9380 #if RUN_STREAMING_TESTCASES
9381 #if PVR_SUPPORT
9382 if (PVR_MLB_StreamingPauseRepositionResumeStopTest == iCurrentTestNumber)
9383 {
9384 fprintf(file, "PVR_MLB_StreamingPauseRepositionResumeStopTest");
9385 }
9386 else
9387 {
9388 fprintf(file, "PVR_FSLB_StreamingPauseRepositionResumeStopTest");
9389 }
9390 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9391 PVMF_MIME_YUV420,
9392 PVMF_MIME_PCM16,
9393 iCurrentTestNumber);
9394 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9395 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9396 OSCL_UNUSED_ARG(ptr);
9397 #else
9398 fprintf(file, "PVR tests not enabled\n");
9399 #endif
9400 #else
9401 fprintf(file, "Streaming tests not enabled\n");
9402 #endif
9403 }
9404 break;
9405
9406
9407 case PVR_MLB_StreamingOpenPauseJmpToLiveChannelSwitchTest:
9408 case PVR_FSLB_StreamingOpenPauseJmpToLiveChannelSwitchTest:
9409 {
9410 #if RUN_STREAMING_TESTCASES
9411 #if PVR_SUPPORT
9412 if (PVR_FSLB_StreamingOpenPauseJmpToLiveChannelSwitchTest == iCurrentTestNumber)
9413 {
9414 fprintf(file, "PVR_FSLB_StreamingOpenPauseJmpToLiveChannelSwitchTest");
9415 }
9416 else
9417 {
9418 fprintf(file, "PVR_MLB_StreamingOpenPauseJmpToLiveChannelSwitchTest");
9419 }
9420 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9421 PVMF_MIME_YUV420,
9422 PVMF_MIME_PCM16,
9423 iCurrentTestNumber);
9424 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9425 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9426 OSCL_UNUSED_ARG(ptr);
9427 #else
9428 fprintf(file, "PVR tests not enabled\n");
9429 #endif
9430 #else
9431 fprintf(file, "Streaming tests not enabled\n");
9432 #endif
9433 }
9434 break;
9435
9436 case PVR_MLB_StreamingOpenPlayLivePauseWaitForRTSPEOSResumeTest:
9437 case PVR_FSLB_StreamingOpenPlayLivePauseWaitForRTSPEOSResumeTest:
9438 {
9439 #if RUN_STREAMING_TESTCASES
9440 #if PVR_SUPPORT
9441 if (PVR_MLB_StreamingPauseRepositionResumeStopTest == iCurrentTestNumber)
9442 {
9443 fprintf(file, "PVR_MLB_StreamingOpenPlayLivePauseWaitForRTSPEOSResumeTest");
9444 }
9445 else
9446 {
9447 fprintf(file, "PVR_FSLB_StreamingOpenPlayLivePauseWaitForRTSPEOSResumeTest");
9448 }
9449 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9450 PVMF_MIME_YUV420,
9451 PVMF_MIME_PCM16,
9452 iCurrentTestNumber);
9453 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9454 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9455 OSCL_UNUSED_ARG(ptr);
9456 #else
9457 fprintf(file, "PVR tests not enabled\n");
9458 #endif
9459 #else
9460 fprintf(file, "Streaming tests not enabled\n");
9461 #endif
9462 }
9463 break;
9464
9465 case PVR_MLB_StreamingBitrateEstimationTest:
9466 {
9467 #if RUN_STREAMING_TESTCASES
9468 #if PVR_SUPPORT
9469 if (PVR_MLB_StreamingBitrateEstimationTest == iCurrentTestNumber)
9470 {
9471 fprintf(file, "PVR_MLB_StreamingBitrateEstimationTest");
9472 }
9473 else
9474 {
9475 fprintf(file, "PVR_MLB_StreamingBitrateEstimationTest");
9476 }
9477 iCurrentTest = new pvplayer_async_test_pvr_streamingopenplaystop(testparam,
9478 PVMF_MIME_YUV420,
9479 PVMF_MIME_PCM16,
9480 iCurrentTestNumber);
9481 pvplayer_async_test_pvr_streamingopenplaystop* ptr =
9482 (pvplayer_async_test_pvr_streamingopenplaystop*)iCurrentTest;
9483 OSCL_UNUSED_ARG(ptr);
9484 #else
9485 fprintf(file, "PVR tests not enabled\n");
9486 #endif
9487 #else
9488 fprintf(file, "Streaming tests not enabled\n");
9489 #endif
9490 }
9491 break;
9492
9493 /** ALP ACCESS DRM CPM TESTS */
9494 case QueryEngine_AccessCPMTest:
9495 #if RUN_CPMACCESS_TESTCASES
9496 iCurrentTest = new pvplayer_async_test_accesscpm_query(testparam);
9497 #else
9498 fprintf(file, "Access CPM tests not enabled\n");
9499 #endif
9500 break;
9501 case OpenPlayStop_AccessCPMTest:
9502 #if RUN_CPMACCESS_TESTCASES
9503 iCurrentTest = new pvplayer_async_test_accesscpm_openplaystop(testparam);
9504 #else
9505 fprintf(file, "Access CPM tests not enabled\n");
9506 #endif
9507 break;
9508 case PlayStopPlayStop_AccessCPMTest:
9509 #if RUN_CPMACCESS_TESTCASES
9510 iCurrentTest = new pvplayer_async_test_accesscpm_playstopplay(testparam);
9511 #else
9512 fprintf(file, "Access CPM tests not enabled\n");
9513 #endif
9514 break;
9515 case StartupMeasurement_AccessCPMTest:
9516 #if RUN_CPMACCESS_TESTCASES
9517 iCurrentTest = new pvplayer_async_test_accesscpm_startupmeasurement(testparam);
9518 #else
9519 fprintf(file, "Access CPM tests not enabled\n");
9520 #endif
9521 break;
9522
9523 case OpenPlayStop_MultiCPMTest:
9524 #if ((RUN_CPMOMA1_DLAPASSTHRU_TESTCASES) && (RUN_CPMJANUS_TESTCASES))
9525 iCurrentTest = new pvplayer_async_test_multicpm(testparam,
9526 PVMF_MIME_YUV420,
9527 PVMF_MIME_PCM16,
9528 iCurrentTestNumber,
9529 false,
9530 false,
9531 true);
9532
9533 ((pvplayer_async_test_multicpm*)iCurrentTest)->setProtocolRollOverMode();
9534 #else
9535 fprintf(file, "Multi CPM tests not enabled\n");
9536 #endif
9537 break;
9538
9539 case StreamingLongPauseSeekTest:
9540 #if RUN_STREAMING_TESTCASES
9541 iCurrentTest = new pvplayer_async_test_streamingopenplaystop(testparam,
9542 PVMF_MIME_YUV420,
9543 PVMF_MIME_PCM16,
9544 iCurrentTestNumber,
9545 true,
9546 false,
9547 false,
9548 false,
9549 false,
9550 false,
9551 false);
9552 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setPauseDurationInMS(2*60*1000);
9553 ((pvplayer_async_test_streamingopenplaystop*)iCurrentTest)->setPauseSetPlayBackRangeResumeSequence();
9554 #else
9555 fprintf(file, "Streaming tests not enabled\n");
9556 #endif
9557 break;
9558
9559 case ApplicationInvolvedTrackSelectionTestDefault:
9560 {
9561 #if RUN_APP_TRACK_SELECTION_TESTCASES
9562 fprintf(file, "ApplicationInvolvedTrackSelectionTest");
9563 iCurrentTest =
9564 new pvplayer_async_test_apptrackselection(testparam,
9565 PVMF_MIME_YUV420,
9566 PVMF_MIME_PCM16,
9567 iCurrentTestNumber,
9568 false,
9569 false,
9570 true,
9571 false,
9572 false);
9573 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setProtocolRollOverMode();
9574 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setTrackSelectionMode(PVPLAYER_TEST_TRACK_SELECTION_MODE_DEFAULT);
9575 #else
9576 fprintf(file, "ApplicationInvolvedTrackSelectionTestDefault not enabled\n");
9577 #endif
9578 }
9579 break;
9580
9581 case ApplicationInvolvedTrackSelectionTestPassthru:
9582 {
9583 #if RUN_APP_TRACK_SELECTION_TESTCASES
9584 fprintf(file, "ApplicationInvolvedTrackSelectionTestPassthru");
9585 iCurrentTest =
9586 new pvplayer_async_test_apptrackselection(testparam,
9587 PVMF_MIME_YUV420,
9588 PVMF_MIME_PCM16,
9589 iCurrentTestNumber,
9590 false,
9591 false,
9592 true,
9593 false,
9594 false);
9595 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setProtocolRollOverMode();
9596 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setTrackSelectionMode(PVPLAYER_TEST_TRACK_SELECTION_MODE_PASSTHRU);
9597 #else
9598 fprintf(file, "ApplicationInvolvedTrackSelectionTestPassthru not enabled\n");
9599 #endif
9600 }
9601 break;
9602
9603 case ApplicationInvolvedTrackSelectionTestAudioOnly:
9604 {
9605 #if RUN_APP_TRACK_SELECTION_TESTCASES
9606 fprintf(file, "ApplicationInvolvedTrackSelectionTestAudioOnly");
9607 iCurrentTest =
9608 new pvplayer_async_test_apptrackselection(testparam,
9609 PVMF_MIME_YUV420,
9610 PVMF_MIME_PCM16,
9611 iCurrentTestNumber,
9612 false,
9613 false,
9614 true,
9615 false,
9616 false);
9617 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setProtocolRollOverMode();
9618 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setTrackSelectionMode(PVPLAYER_TEST_TRACK_SELECTION_MODE_AUDIO_ONLY);
9619 #else
9620 fprintf(file, "ApplicationInvolvedTrackSelectionTestAudioOnly not enabled\n");
9621 #endif
9622 }
9623 break;
9624
9625 case ApplicationInvolvedTrackSelectionTestVideoOnly:
9626 {
9627 #if RUN_APP_TRACK_SELECTION_TESTCASES
9628 fprintf(file, "ApplicationInvolvedTrackSelectionTestVideoOnly");
9629 iCurrentTest =
9630 new pvplayer_async_test_apptrackselection(testparam,
9631 PVMF_MIME_YUV420,
9632 PVMF_MIME_PCM16,
9633 iCurrentTestNumber,
9634 false,
9635 false,
9636 true,
9637 false,
9638 false);
9639 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setProtocolRollOverMode();
9640 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setTrackSelectionMode(PVPLAYER_TEST_TRACK_SELECTION_MODE_VIDEO_ONLY);
9641 #else
9642 fprintf(file, "ApplicationInvolvedTrackSelectionTestVideoOnly not enabled\n");
9643 #endif
9644 }
9645 break;
9646
9647 case ApplicationInvolvedTrackSelectionTestTextOnly:
9648 {
9649 #if RUN_APP_TRACK_SELECTION_TESTCASES
9650 fprintf(file, "ApplicationInvolvedTrackSelectionTestTextOnly");
9651 iCurrentTest =
9652 new pvplayer_async_test_apptrackselection(testparam,
9653 PVMF_MIME_YUV420,
9654 PVMF_MIME_PCM16,
9655 iCurrentTestNumber,
9656 false,
9657 false,
9658 true,
9659 false,
9660 false);
9661 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setProtocolRollOverMode();
9662 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setTrackSelectionMode(PVPLAYER_TEST_TRACK_SELECTION_MODE_TEXT_ONLY);
9663 #else
9664 fprintf(file, "ApplicationInvolvedTrackSelectionTestTextOnly not enabled\n");
9665 #endif
9666 }
9667 break;
9668
9669 case ApplicationInvolvedTrackSelectionTestNoTracks:
9670 {
9671 #if RUN_APP_TRACK_SELECTION_TESTCASES
9672 fprintf(file, "ApplicationInvolvedTrackSelectionTestNoTracks");
9673 iCurrentTest =
9674 new pvplayer_async_test_apptrackselection(testparam,
9675 PVMF_MIME_YUV420,
9676 PVMF_MIME_PCM16,
9677 iCurrentTestNumber,
9678 false,
9679 false,
9680 true,
9681 false,
9682 false);
9683 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setProtocolRollOverMode();
9684 ((pvplayer_async_test_apptrackselection*)iCurrentTest)->setTrackSelectionMode(PVPLAYER_TEST_TRACK_SELECTION_MODE_NO_TRACKS);
9685 #else
9686 fprintf(file, "ApplicationInvolvedTrackSelectionTestNoTracks not enabled\n");
9687 #endif
9688 }
9689 break;
9690
9691
9692 case BeyondLastTest:
9693 AtleastOneExecuted = false; //Resetting the flag
9694 break;
9695
9696 default:
9697 PVPlayerProjTestFactory projTestFactory;
9698 iCurrentTest = projTestFactory.GetProjTest(iCurrentTestNumber, testparam);
9699 if (!iCurrentTest)
9700 {
9701 //exit the loop.
9702 iCurrentTestNumber = BeyondLastTest;
9703 }
9704 break;
9705 }
9706
9707 if (iCurrentTest)
9708 {
9709 OsclExecScheduler *sched = OsclExecScheduler::Current();
9710 if (sched)
9711 {
9712 // Print out the test name
9713 fprintf(file, "%s\n", iCurrentTest->iTestCaseName.get_cstr());
9714 // Start the test
9715 iCurrentTest->StartTest();
9716 // Start the scheduler so the test case would run
9717 #if USE_NATIVE_SCHEDULER
9718 // Have PV scheduler use the scheduler native to the system
9719 sched->StartNativeScheduler();
9720 #else
9721 // Have PV scheduler use its own implementation of the scheduler
9722 sched->StartScheduler();
9723 #endif
9724 }
9725 else
9726 {
9727 fprintf(file, "ERROR! Scheduler is not available. Test case could not run.");
9728 ++iCurrentTestNumber;
9729 }
9730 }
9731 else //no test to run, skip to next test.
9732 {
9733 ++iCurrentTestNumber;
9734 if (setupLoggerScheduler)
9735 {
9736 // Shutdown PVLogger and scheduler before continuing on
9737 OsclScheduler::Cleanup();
9738 PVLogger::Cleanup();
9739 setupLoggerScheduler = false;
9740 }
9741 }
9742 }
9743 }
9744
9745
SetupLoggerScheduler()9746 void pvplayer_engine_test::SetupLoggerScheduler()
9747 {
9748 // Enable the following code for logging using PV Logger
9749 PVLogger::Init();
9750 OSCL_wHeapString<OsclMemAllocator> logfilename(OUTPUTNAME_PREPEND_WSTRING);
9751 logfilename += _STRLIT_WCHAR("player.log");
9752
9753 PVLoggerAppender *appender = NULL;
9754 OsclRefCounter *refCounter = NULL;
9755 if (iLogMem)
9756 {
9757 appender = (PVLoggerAppender*)MemAppender<TimeAndIdLayout, 1024>::CreateAppender(logfilename.get_str(), 0x200000);
9758 OsclRefCounterSA<LogAppenderDestructDealloc<MemAppender<TimeAndIdLayout, 1024> > > *appenderRefCounter =
9759 new OsclRefCounterSA<LogAppenderDestructDealloc<MemAppender<TimeAndIdLayout, 1024> > >(appender);
9760
9761 refCounter = appenderRefCounter;
9762 }
9763 else if (iLogFile)
9764 {
9765 appender = (PVLoggerAppender*)TextFileAppender<TimeAndIdLayout, 1024>::CreateAppender(logfilename.get_str());
9766 OsclRefCounterSA<LogAppenderDestructDealloc<TextFileAppender<TimeAndIdLayout, 1024> > > *appenderRefCounter =
9767 new OsclRefCounterSA<LogAppenderDestructDealloc<TextFileAppender<TimeAndIdLayout, 1024> > >(appender);
9768 refCounter = appenderRefCounter;
9769 }
9770 else
9771 {
9772 appender = new StdErrAppender<TimeAndIdLayout, 1024>();
9773 OsclRefCounterSA<LogAppenderDestructDealloc<StdErrAppender<TimeAndIdLayout, 1024> > > *appenderRefCounter =
9774 new OsclRefCounterSA<LogAppenderDestructDealloc<StdErrAppender<TimeAndIdLayout, 1024> > >(appender);
9775 refCounter = appenderRefCounter;
9776 }
9777
9778 OsclSharedPtr<PVLoggerAppender> appenderPtr(appender, refCounter);
9779
9780
9781 PVLoggerConfigFile obj;
9782 if (obj.IsLoggerConfigFilePresent())
9783 {
9784 obj.SetLoggerSettings();
9785 // Construct and install the active scheduler
9786 OsclScheduler::Init("PVPlayerEngineTestScheduler");
9787 return;
9788 }
9789
9790 switch (iLogNode)
9791 {
9792 case 0: //default
9793 {
9794 //selective logging
9795 PVLogger *node;
9796 node = PVLogger::GetLoggerObject("PVPlayerEngine");
9797 node->AddAppender(appenderPtr);
9798 node->SetLogLevel(iLogLevel);
9799 /*
9800 node = PVLogger::GetLoggerObject("PVMFMP4FFParserNode");
9801 node->AddAppender(appenderPtr);
9802 node->SetLogLevel(iLogLevel);
9803 */
9804 /*
9805 node = PVLogger::GetLoggerObject("PVMFAMRFFParserNode");
9806 node->AddAppender(appenderPtr);
9807 node->SetLogLevel(iLogLevel);
9808 */
9809 /*
9810 node = PVLogger::GetLoggerObject("PVMFAACFFParserNode");
9811 node->AddAppender(appenderPtr);
9812 node->SetLogLevel(iLogLevel);
9813 */
9814 /*
9815 node = PVLogger::GetLoggerObject("PVMFMP3FFParserNode");
9816 node->AddAppender(appenderPtr);
9817 node->SetLogLevel(iLogLevel);
9818 */
9819 /*
9820 node = PVLogger::GetLoggerObject("PVMFASFParserNode");
9821 node->AddAppender(appenderPtr);
9822 node->SetLogLevel(iLogLevel);
9823 */
9824 /*
9825 node = PVLogger::GetLoggerObject("PVMFVideoDecNode");
9826 node->AddAppender(appenderPtr);
9827 node->SetLogLevel(iLogLevel);
9828 */
9829 /*
9830 node = PVLogger::GetLoggerObject("PVMFAVCDecNode");
9831 node->AddAppender(appenderPtr);
9832 node->SetLogLevel(iLogLevel);
9833 */
9834 /*
9835 node = PVLogger::GetLoggerObject("PVMFWmvDecNode");
9836 node->AddAppender(appenderPtr);
9837 node->SetLogLevel(iLogLevel);
9838 */
9839 /*
9840 node = PVLogger::GetLoggerObject("PVMFGSMAMRDecNode");
9841 node->AddAppender(appenderPtr);
9842 node->SetLogLevel(iLogLevel);
9843 */
9844 /*
9845 node = PVLogger::GetLoggerObject("PVMFAACDecNode");
9846 node->AddAppender(appenderPtr);
9847 node->SetLogLevel(iLogLevel);
9848 */
9849 /*
9850 node = PVLogger::GetLoggerObject("PVMFMP3DecNode");
9851 node->AddAppender(appenderPtr);
9852 node->SetLogLevel(iLogLevel);
9853 */
9854 /*
9855 node = PVLogger::GetLoggerObject("PVMFWMADecNode");
9856 node->AddAppender(appenderPtr);
9857 node->SetLogLevel(iLogLevel);
9858 */
9859 /*
9860 node = PVLogger::GetLoggerObject("PVMFFileOutputNode");
9861 node->AddAppender(appenderPtr);
9862 node->SetLogLevel(iLogLevel);
9863 */
9864 /*
9865 node = PVLogger::GetLoggerObject("PVMediaOutputNode");
9866 node->AddAppender(appenderPtr);
9867 node->SetLogLevel(iLogLevel);
9868 */
9869 /*
9870 node = PVLogger::GetLoggerObject("PVMediaOutputNodePort");
9871 node->AddAppender(appenderPtr);
9872 node->SetLogLevel(iLogLevel);
9873 */
9874 /*
9875 node = PVLogger::GetLoggerObject("PvmfSyncUtil");
9876 node->AddAppender(appenderPtr);
9877 node->SetLogLevel(iLogLevel);
9878 */
9879 /*
9880 node = PVLogger::GetLoggerObject("PvmfSyncUtilDataQueue");
9881 node->AddAppender(appenderPtr);
9882 node->SetLogLevel(iLogLevel);
9883 */
9884 /*
9885 node = PVLogger::GetLoggerObject("datapath.asfparsernode");
9886 node->AddAppender(appenderPtr);
9887 node->SetLogLevel(iLogLevel);
9888 */
9889 }
9890 break;
9891 case 1: //-logall
9892 {
9893 // Log all
9894 PVLogger *rootnode = PVLogger::GetLoggerObject("");
9895 rootnode->AddAppender(appenderPtr);
9896 rootnode->SetLogLevel(iLogLevel);
9897 }
9898 break;
9899 case 2: //-logdatapath
9900 {
9901 // Log datapath only
9902 PVLogger *node = PVLogger::GetLoggerObject("datapath");
9903 node->AddAppender(appenderPtr);
9904 //info level logs ports & synchronization info.
9905 node->SetLogLevel(PVLOGMSG_INFO);
9906 //debug level includes additional memory pool logging.
9907 //node->SetLogLevel(PVLOGMSG_DEBUG);
9908 //diasble logs from all its child nodes
9909 PVLogger* datapathsrc = PVLogger::GetLoggerObject("datapath.sourcenode");
9910 datapathsrc->DisableAppenderInheritance();
9911 PVLogger* datapathdec = PVLogger::GetLoggerObject("datapath.decnode");
9912 datapathdec->DisableAppenderInheritance();
9913 }
9914 break;
9915 case 3: //-logclock
9916 {
9917 // Log clock only
9918 PVLogger *clocknode = PVLogger::GetLoggerObject("clock");
9919 clocknode->AddAppender(appenderPtr);
9920 clocknode->SetLogLevel(PVLOGMSG_DEBUG);
9921 }
9922 break;
9923 case 4: //-logoscl
9924 {
9925 // Log oscl only
9926 PVLogger *clocknode = PVLogger::GetLoggerObject("pvscheduler");
9927 clocknode->AddAppender(appenderPtr);
9928 clocknode->SetLogLevel(iLogLevel);
9929 clocknode = PVLogger::GetLoggerObject("osclsocket");
9930 clocknode->AddAppender(appenderPtr);
9931 clocknode->SetLogLevel(iLogLevel);
9932 }
9933 break;
9934 case 5: //-logperf
9935 {
9936 // Log scheduler perf only.
9937 PVLogger *clocknode ;
9938
9939 clocknode = PVLogger::GetLoggerObject("pvscheduler");
9940 clocknode->AddAppender(appenderPtr);
9941 //info level logs scheduler activity including AO calls and idle time.
9942 clocknode->SetLogLevel(PVLOGMSG_INFO);
9943 //debug level logs additional AO request status changes.
9944 //clocknode->SetLogLevel(PVLOGMSG_DEBUG);
9945
9946 //log streaming packet loss
9947 clocknode = PVLogger::GetLoggerObject("pvplayerdiagnostics.streamingmanager");
9948 clocknode->AddAppender(appenderPtr);
9949 clocknode->SetLogLevel(PVLOGMSG_DEBUG);
9950 }
9951 break;
9952 case 6: //-logdatapathsrc
9953 {
9954 // Log source node data path only.
9955 PVLogger *node = NULL;
9956 node = PVLogger::GetLoggerObject("datapath.sourcenode");
9957 node->AddAppender(appenderPtr);
9958 node->SetLogLevel(PVLOGMSG_INFO);
9959 //node = PVLogger::GetLoggerObject("datapath.sourcenode.mp4parsernode");
9960 //node->AddAppender(appenderPtr);
9961 //node->SetLogLevel(PVLOGMSG_INFO);
9962 //node = PVLogger::GetLoggerObject("datapath.socketnode");
9963 //node->AddAppender(appenderPtr);
9964 //node->SetLogLevel(PVLOGMSG_INFO);
9965 //node = PVLogger::GetLoggerObject("datapath.sourcenode.protocolenginenode");
9966 //node->AddAppender(appenderPtr);
9967 //node->SetLogLevel(PVLOGMSG_INFO);
9968 //node = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer");
9969 //node->AddAppender(appenderPtr);
9970 //node->SetLogLevel(PVLOGMSG_INFO);
9971 //node = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.in");
9972 //node->AddAppender(appenderPtr);
9973 //node->SetLogLevel(PVLOGMSG_INFO);
9974 //node = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.out");
9975 //node->AddAppender(appenderPtr);
9976 //node->SetLogLevel(PVLOGMSG_INFO);
9977 //node = PVLogger::GetLoggerObject("datapath.sourcenode.medialayer");
9978 //node->AddAppender(appenderPtr);
9979 //node->SetLogLevel(PVLOGMSG_INFO);
9980 //node = PVLogger::GetLoggerObject("datapath.sourcenode.medialayer.in");
9981 //node->AddAppender(appenderPtr);
9982 //node->SetLogLevel(PVLOGMSG_INFO);
9983 //node = PVLogger::GetLoggerObject("datapath.sourcenode.medialayer.out");
9984 //node->AddAppender(appenderPtr);
9985 //node->SetLogLevel(PVLOGMSG_INFO);
9986 //node = PVLogger::GetLoggerObject("datapath.sourcenode.medialayer.portflowcontrol");
9987 //node->AddAppender(appenderPtr);
9988 //node->SetLogLevel(PVLOGMSG_INFO);
9989 //node = PVLogger::GetLoggerObject("pvplayerdiagnostics.streamingmanager");
9990 //node->AddAppender(appenderPtr);
9991 //node->SetLogLevel(PVLOGMSG_INFO);
9992 }
9993 break;
9994 case 7://-logdatapathdec
9995 {
9996 // Log decoder node data path only.
9997 PVLogger *node = NULL;
9998 node = PVLogger::GetLoggerObject("datapath.decnode");
9999 node->AddAppender(appenderPtr);
10000 node->SetLogLevel(PVLOGMSG_INFO);
10001 //node = PVLogger::GetLoggerObject("datapath.decnode.m4vdecnode");
10002 //node->AddAppender(appenderPtr);
10003 //node->SetLogLevel(PVLOGMSG_INFO);
10004 //node = PVLogger::GetLoggerObject("datapath.decnode.aacdecnode");
10005 //node->AddAppender(appenderPtr);
10006 //node->SetLogLevel(PVLOGMSG_INFO);
10007 //node = PVLogger::GetLoggerObject("datapath.decnode.wmadecnode");
10008 //node->AddAppender(appenderPtr);
10009 //node->SetLogLevel(PVLOGMSG_INFO);
10010 //node = PVLogger::GetLoggerObject("datapath.decnode.wmvdecnode");
10011 //node->AddAppender(appenderPtr);
10012 //node->SetLogLevel(PVLOGMSG_INFO);
10013 }
10014 break;
10015 case 8://-logsync
10016 {
10017 PVLogger *node = NULL;
10018 node = PVLogger::GetLoggerObject("datapath.sinknode");
10019 node->AddAppender(appenderPtr);
10020 //info level logs ports & synchronization info.
10021 node->SetLogLevel(PVLOGMSG_DEBUG);
10022 }
10023 break;
10024 case 9://-logdiagnostics
10025 {
10026 PVLogger *node = NULL;
10027 node = PVLogger::GetLoggerObject("pvplayerdiagnostics");
10028 node->AddAppender(appenderPtr);
10029 node->SetLogLevel(PVLOGMSG_DEBUG);
10030 //node = PVLogger::GetLoggerObject("pvplayerdiagnostics.streamingmanager");
10031 //node->AddAppender(appenderPtr);
10032 //node->SetLogLevel(PVLOGMSG_DEBUG);
10033 }
10034 break;
10035 case 10://-logosclfileio
10036 {
10037 PVLogger *clocknode = PVLogger::GetLoggerObject("Oscl_File");
10038 clocknode->AddAppender(appenderPtr);
10039 clocknode->SetLogLevel(PVLOGMSG_DEBUG + 1);
10040 }
10041 break;
10042 case 11://-loghds
10043 {
10044 PVLogger *clocknode = PVLogger::GetLoggerObject("PVWmdrmHds");
10045 clocknode->AddAppender(appenderPtr);
10046 clocknode->SetLogLevel(PVLOGMSG_DEBUG + 1);
10047 clocknode = PVLogger::GetLoggerObject("WmdrmStats");
10048 clocknode->AddAppender(appenderPtr);
10049 clocknode->SetLogLevel(PVLOGMSG_DEBUG);
10050 clocknode = PVLogger::GetLoggerObject("OsclFileStats");
10051 clocknode->AddAppender(appenderPtr);
10052 clocknode->SetLogLevel(PVLOGMSG_DEBUG);
10053 clocknode = PVLogger::GetLoggerObject("Oscl_File");
10054 clocknode->AddAppender(appenderPtr);
10055 clocknode->SetLogLevel(PVLOGMSG_DEBUG);
10056 clocknode = PVLogger::GetLoggerObject("OsclNativeFile");
10057 clocknode->AddAppender(appenderPtr);
10058 clocknode->SetLogLevel(PVLOGMSG_DEBUG);
10059 }
10060 break;
10061 case 12://-loghdsandosclfileio
10062 {
10063 PVLogger *clocknode = PVLogger::GetLoggerObject("PVWmdrmHds");
10064 clocknode->AddAppender(appenderPtr);
10065
10066 clocknode = PVLogger::GetLoggerObject("Oscl_File");
10067 clocknode->AddAppender(appenderPtr);
10068 clocknode->SetLogLevel(PVLOGMSG_DEBUG + 1);
10069 }
10070 break;
10071 case 13://-logjupiter
10072 {
10073 //jupiter debugging.
10074 PVLogger *loggernode;
10075 loggernode = PVLogger::GetLoggerObject("PVDrmManagerJupiter");
10076 loggernode->AddAppender(appenderPtr);
10077 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10078 loggernode = PVLogger::GetLoggerObject("PVWMDRM");
10079 loggernode->AddAppender(appenderPtr);
10080 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10081 //loggernode->SetLogLevel(PVLOGMSG_DEBUG+1);//for ChkDR and Oem time logging
10082 loggernode = PVLogger::GetLoggerObject("PVMFJupiterPlugin");
10083 loggernode->AddAppender(appenderPtr);
10084 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10085 /*
10086 loggernode = PVLogger::GetLoggerObject("PVMFJupiterPluginLocalSyncAccessInterfaceImpl");
10087 loggernode->AddAppender(appenderPtr);
10088 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10089 */
10090 loggernode = PVLogger::GetLoggerObject("PVMFJupiterUtility");
10091 loggernode->AddAppender(appenderPtr);
10092 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10093 loggernode = PVLogger::GetLoggerObject("HTTPRequest");
10094 loggernode->AddAppender(appenderPtr);
10095 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10096 /*
10097 loggernode = PVLogger::GetLoggerObject("oscldns");
10098 loggernode->AddAppender(appenderPtr);
10099 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10100 loggernode = PVLogger::GetLoggerObject("osclsocket");
10101 loggernode->AddAppender(appenderPtr);
10102 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10103 loggernode = PVLogger::GetLoggerObject("osclsocketserv");
10104 loggernode->AddAppender(appenderPtr);
10105 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10106 loggernode = PVLogger::GetLoggerObject("osclsocket_serv");
10107 loggernode->AddAppender(appenderPtr);
10108 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10109 */
10110 loggernode = PVLogger::GetLoggerObject("datapath.sourcenode.asfparsernode.drm");
10111 loggernode->AddAppender(appenderPtr);
10112 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10113 }
10114 break;
10115 case 14://-logjanus
10116 {
10117 //janus debugging.
10118 PVLogger *loggernode;
10119 loggernode = PVLogger::GetLoggerObject("PVDrmManager");
10120 loggernode->AddAppender(appenderPtr);
10121 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10122 loggernode = PVLogger::GetLoggerObject("PVWMDRM");
10123 loggernode->AddAppender(appenderPtr);
10124 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10125 //loggernode->SetLogLevel(PVLOGMSG_DEBUG+1);//for ChkDR and Oem time logging
10126 loggernode = PVLogger::GetLoggerObject("PVMFJanusPlugin");
10127 loggernode->AddAppender(appenderPtr);
10128 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10129 /*
10130 loggernode = PVLogger::GetLoggerObject("PVMFJanusPluginLocalSyncAccessInterfaceImpl");
10131 loggernode->AddAppender(appenderPtr);
10132 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10133 */
10134 loggernode = PVLogger::GetLoggerObject("HTTPRequest");
10135 loggernode->AddAppender(appenderPtr);
10136 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10137 /*
10138 loggernode = PVLogger::GetLoggerObject("oscldns");
10139 loggernode->AddAppender(appenderPtr);
10140 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10141 loggernode = PVLogger::GetLoggerObject("osclsocket");
10142 loggernode->AddAppender(appenderPtr);
10143 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10144 loggernode = PVLogger::GetLoggerObject("osclsocketserv");
10145 loggernode->AddAppender(appenderPtr);
10146 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10147 loggernode = PVLogger::GetLoggerObject("osclsocket_serv");
10148 loggernode->AddAppender(appenderPtr);
10149 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10150 */
10151 }
10152 break;
10153 case 15://-logperfmin
10154 {
10155 //minimal scheduler perf logging
10156 PVLogger *loggernode;
10157 loggernode = PVLogger::GetLoggerObject("OsclSchedulerPerfStats");
10158 loggernode->AddAppender(appenderPtr);
10159 loggernode->SetLogLevel(PVLOGMSG_INFO);
10160 }
10161 break;
10162 case 16://-logppb
10163 {
10164 // Log progressive playback node data path only.
10165 PVLogger *loggernode;
10166 /*
10167 loggernode = PVLogger::GetLoggerObject("datapath.sourcenode");
10168 loggernode->AddAppender(appenderPtr);
10169 loggernode->SetLogLevel(PVLOGMSG_INFO);
10170 */
10171 loggernode = PVLogger::GetLoggerObject("datapath.sourcenode.mp4parsernode");
10172 loggernode->AddAppender(appenderPtr);
10173 loggernode->SetLogLevel(PVLOGMSG_INFO);
10174 /*
10175 loggernode = PVLogger::GetLoggerObject("datapath.socketnode");
10176 loggernode->AddAppender(appenderPtr);
10177 loggernode->SetLogLevel(PVLOGMSG_INFO);
10178 */
10179 /*
10180 loggernode = PVLogger::GetLoggerObject("datapath.sourcenode.protocolenginenode");
10181 loggernode->AddAppender(appenderPtr);
10182 loggernode->SetLogLevel(PVLOGMSG_INFO);
10183 */
10184
10185 loggernode = PVLogger::GetLoggerObject("datapath.decnode");
10186 loggernode->AddAppender(appenderPtr);
10187 loggernode->SetLogLevel(PVLOGMSG_INFO);
10188
10189 loggernode = PVLogger::GetLoggerObject("PVMediaOutputNode");
10190 loggernode->AddAppender(appenderPtr);
10191 loggernode->SetLogLevel(PVLOGMSG_INFO);
10192
10193 loggernode = PVLogger::GetLoggerObject("PVRefFileOutput");
10194 loggernode->AddAppender(appenderPtr);
10195 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10196
10197 loggernode = PVLogger::GetLoggerObject("PVMFOMXVideoDecNode");
10198 loggernode->AddAppender(appenderPtr);
10199 loggernode->SetLogLevel(PVLOGMSG_STACK_TRACE);
10200
10201 }
10202 break;
10203 case 17://-logrepos
10204 {
10205 PVLogger *node = NULL;
10206 node = PVLogger::GetLoggerObject("pvplayerrepos");
10207 node->AddAppender(appenderPtr);
10208 //info level logs ports & synchronization info.
10209 node->SetLogLevel(PVLOGMSG_DEBUG);
10210 }
10211 break;
10212 case 18: //-logsnode
10213 {
10214 //minimal scheduler perf logging
10215 PVLogger *loggernode;
10216 loggernode = PVLogger::GetLoggerObject("OsclSchedulerPerfStats");
10217 loggernode->AddAppender(appenderPtr);
10218 loggernode->SetLogLevel(PVLOGMSG_INFO);
10219
10220 //socket node debugging
10221 loggernode = PVLogger::GetLoggerObject("pvplayerdiagnostics.socketnode");
10222 loggernode->AddAppender(appenderPtr);
10223 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10224 /*
10225 loggernode=PVLogger::GetLoggerObject("datapath.socketnode");
10226 loggernode->AddAppender(appenderPtr);
10227 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10228 */
10229 loggernode = PVLogger::GetLoggerObject("pvplayerdiagnostics.streamingmanager");
10230 loggernode->AddAppender(appenderPtr);
10231 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10232 }
10233 case 19://-logshout
10234 {
10235 // Log shoutcast playback node data path only.
10236 PVLogger *loggernode;
10237
10238 loggernode = PVLogger::GetLoggerObject("PVPlayerEngine");
10239 loggernode->AddAppender(appenderPtr);
10240 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10241
10242 loggernode = PVLogger::GetLoggerObject("PVMFShoutcastStreamParser");
10243 loggernode->AddAppender(appenderPtr);
10244 loggernode->SetLogLevel(PVLOGMSG_STACK_TRACE);
10245
10246 loggernode = PVLogger::GetLoggerObject("PVMFMP3FFParserNode");
10247 loggernode->AddAppender(appenderPtr);
10248 loggernode->SetLogLevel(PVLOGMSG_INFO);
10249 /*
10250 loggernode = PVLogger::GetLoggerObject("pvdownloadmanagernode");
10251 loggernode->AddAppender(appenderPtr);
10252 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10253
10254 loggernode = PVLogger::GetLoggerObject("datapath.sourcenode.protocolenginenode");
10255 loggernode->AddAppender(appenderPtr);
10256 loggernode->SetLogLevel(PVLOGMSG_INFO);
10257
10258 loggernode = PVLogger::GetLoggerObject("PVMFMemoryBufferDataStream");
10259 loggernode->AddAppender(appenderPtr);
10260 loggernode->SetLogLevel(PVLOGMSG_DEBUG);
10261 */
10262 }
10263 break;
10264 default:
10265 break;
10266 }
10267
10268 // Construct and install the active scheduler
10269 OsclScheduler::Init("PVPlayerEngineTestScheduler");
10270 }
10271
10272
10273
10274
10275
10276
10277