OSCL_EXPORT_REF PVMFStatus PVMFCreateKVPUtils::CreateKVPForWStringValue(PvmiKvp& aKeyVal, const char* aKeyTypeString, OSCL_wString& aValString, char* aMiscKeyParam, uint32 aMaxSize, uint32 aTruncateFlag) { // Check parameters if (aKeyVal.key != NULL || aKeyTypeString == NULL || aValString.get_size() == 0) { return PVMFErrArgument; } aKeyVal.value.pWChar_value = NULL; aKeyVal.key = NULL; // Determine the length of strings uint32 keylen = oscl_strlen(aKeyTypeString) + 1; // for key string and ";" keylen += oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR); // for "valtype=" keylen += oscl_strlen(PVMI_KVPVALTYPE_WCHARPTR_STRING_CONSTCHAR) + 1; // for "wchar*" and NULL terminator if (aMiscKeyParam) { keylen += oscl_strlen(aMiscKeyParam); } uint32 valuelen = aValString.get_size() + 1; // Allocate memory for the strings int32 leavecode = 0, leavecode1 = 0; OSCL_TRY(leavecode, aKeyVal.key = OSCL_ARRAY_NEW(char, keylen););
int32 OsclNativeFile::Open(const oscl_wchar *filename, uint32 mode , const OsclNativeFileParams& params , Oscl_FileServer& fileserv) { iMode = mode; iOpenFileHandle = false; OSCL_UNUSED_ARG(fileserv); OSCL_UNUSED_ARG(params); char openmode[4]; OpenModeToString(mode, openmode); #ifdef _UNICODE oscl_wchar convopenmode[4]; if (0 == oscl_UTF8ToUnicode(openmode, oscl_strlen(openmode), convopenmode, 4)) { return -1; } if ((iFile = _wfopen(filename, convopenmode)) == NULL) { return -1; } #else //Convert to UTF8 char convfilename[OSCL_IO_FILENAME_MAXLEN]; if (0 == oscl_UnicodeToUTF8(filename, oscl_strlen(filename), convfilename, OSCL_IO_FILENAME_MAXLEN)) { return -1; } return OpenFileOrSharedFd(convfilename, openmode); #endif }
OSCL_EXPORT_REF OSCL_FILEMGMT_ERR_TYPE oscl_chdir(const oscl_wchar *path) { char convpathname[OSCL_IO_FILENAME_MAXLEN]; if (0 == oscl_UnicodeToUTF8(path, oscl_strlen(path), convpathname, OSCL_IO_FILENAME_MAXLEN) && oscl_strlen(path) != 0) { return OSCL_FILEMGMT_E_PATH_TOO_LONG; } return oscl_chdir(convpathname); }
OSCL_EXPORT_REF OSCL_FILEMGMT_ERR_TYPE oscl_rename(const oscl_wchar *oldpath, const oscl_wchar *newpath) { char oldconvpathname[OSCL_IO_FILENAME_MAXLEN]; char newconvpathname[OSCL_IO_FILENAME_MAXLEN]; if (0 == oscl_UnicodeToUTF8(oldpath, oscl_strlen(oldpath), oldconvpathname, OSCL_IO_FILENAME_MAXLEN) || 0 == oscl_UnicodeToUTF8(newpath, oscl_strlen(newpath), newconvpathname, OSCL_IO_FILENAME_MAXLEN)) { return OSCL_FILEMGMT_E_PATH_TOO_LONG; } return oscl_rename(oldconvpathname, newconvpathname); }
void PV2WayUtil::FindTestRange(cmd_line* command_line, uint32 &aFirstTest, uint32 &aLastTest, int32 aTestLimit) { //default is to run all tests. aFirstTest = 0; if (aTestLimit == 0) { aLastTest = MAX_324_TEST; } else { aLastTest = aTestLimit; } int testArgument = 0; char *iTestArgStr1 = NULL; char *iTestArgStr2 = NULL; bool cmdline_iswchar = command_line->is_wchar(); //-test //if (iTestFound) OSCL_HeapString<OsclMemAllocator> argument = "-test"; if (FindCmdArg(command_line, argument, testArgument)) { // Convert to UTF8 if necessary if (cmdline_iswchar) { iTestArgStr1 = OSCL_ARRAY_NEW(char, 256); OSCL_TCHAR* cmd; command_line->get_arg(testArgument, cmd); if (cmd) { oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iTestArgStr1, 256); } iTestArgStr2 = OSCL_ARRAY_NEW(char, 256); command_line->get_arg(testArgument + 1, cmd); if (cmd) { oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iTestArgStr2, 256); } } else { command_line->get_arg(testArgument, iTestArgStr1); command_line->get_arg(testArgument + 1, iTestArgStr2); } //Pull out 2 integers... PV_atoi(iTestArgStr1, 'd', aFirstTest); PV_atoi(iTestArgStr2, 'd', aLastTest); }
bool PVMFSocketPort::pvmiGetPortInPlaceDataProcessingInfoSync(const char* aFormatValType, PvmiKvp*& aKvp) { /* * Create PvmiKvp for capability settings */ aKvp = NULL; OsclMemAllocator alloc; uint32 strLen = oscl_strlen(aFormatValType) + 1; uint8* ptr = (uint8*)alloc.allocate(sizeof(PvmiKvp) + strLen); if (!ptr) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFSocketPort::pvmiGetPortInPlaceDataProcessingInfoSync: Error - No memory. Cannot allocate PvmiKvp")); return false; } aKvp = new(ptr) PvmiKvp; ptr += sizeof(PvmiKvp); aKvp->key = (PvmiKeyType)ptr; oscl_strncpy(aKvp->key, aFormatValType, strLen); aKvp->length = aKvp->capacity = strLen; #if SNODE_ENABLE_UDP_MULTI_PACKET if (iTag == PVMF_SOCKET_NODE_PORT_TYPE_SOURCE) aKvp->value.bool_value = false;//for the multiple UDP recv feature else #endif aKvp->value.bool_value = true; return true; }
OSCL_EXPORT_REF bool PVMFOMXDecPort::pvmiSetPortFormatSpecificInfoSync(OsclRefCounterMemFrag& aMemFrag, PvmiKeyType KvpKey) { if ((iConnectedPort) && (iTag == PVMF_OMX_DEC_NODE_PORT_TYPE_OUTPUT)) { OsclAny* temp = NULL; iConnectedPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, temp); PvmiCapabilityAndConfig *config = (PvmiCapabilityAndConfig*)temp; /* * Create PvmiKvp for capability settings */ if ((config) && (aMemFrag.getMemFragSize() > 0)) { PvmiKvp kvp; kvp.length = oscl_strlen(KvpKey) + 1; // +1 for \0 kvp.key = KvpKey; if (kvp.key == NULL) { return false; } kvp.value.key_specific_value = (OsclAny*)(aMemFrag.getMemFragPtr()); kvp.capacity = aMemFrag.getMemFragSize(); PvmiKvp* retKvp = NULL; // for return value int32 err; OSCL_TRY(err, config->setParametersSync(NULL, &kvp, 1, retKvp););
bool PVMFOMXEncPort::pvmiSetPortFormatSpecificInfoSync(OsclRefCounterMemFrag& aMemFrag) { if ((iConnectedPort) && (iTag == PVMF_OMX_ENC_NODE_PORT_TYPE_OUTPUT)) { OsclAny* temp = NULL; iConnectedPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, temp); PvmiCapabilityAndConfig *config = (PvmiCapabilityAndConfig*) temp; /* * Create PvmiKvp for capability settings */ if ((config) && (aMemFrag.getMemFragSize() > 0)) { OsclMemAllocator alloc; PvmiKvp kvp; kvp.key = NULL; kvp.length = oscl_strlen(PVMF_FORMAT_SPECIFIC_INFO_KEY) + 1; // +1 for \0 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length); if (kvp.key == NULL) { return false; } oscl_strncpy(kvp.key, PVMF_FORMAT_SPECIFIC_INFO_KEY, kvp.length); kvp.value.key_specific_value = (OsclAny*)(aMemFrag.getMemFragPtr()); kvp.capacity = aMemFrag.getMemFragSize(); kvp.length = aMemFrag.getMemFragSize(); PvmiKvp* retKvp = NULL; // for return value int32 err; OSCL_TRY(err, config->setParametersSync(NULL, &kvp, 1, retKvp););
OSCL_EXPORT_REF oscl_wchar* oscl_strstr(oscl_wchar* str1, const oscl_wchar* str2) { uint32 size = oscl_strlen(str1); uint32 size2 = oscl_strlen(str2); oscl_wchar* p = (oscl_wchar*) str1; while ((*p != '\0') && (size >= size2)) { if (!oscl_strncmp(p, str2, size2)) return p; else { p += 1; size -= 1; } } return 0; }
void FindLogLevel(cmd_line* command_line, int32& loglevel, FILE* aFile) { //default is verbose loglevel = PVLOGMSG_DEBUG; bool cmdline_iswchar = command_line->is_wchar(); int count = command_line->get_count(); // Search for the "-logerr"/"-logwarn" argument char *iSourceFind = NULL; if (cmdline_iswchar) { iSourceFind = new char[256]; } // Go through each argument for (int iTestSearch = 0; iTestSearch < count; iTestSearch++) { // Convert to UTF8 if necessary if (cmdline_iswchar) { OSCL_TCHAR* cmd = NULL; command_line->get_arg(iTestSearch, cmd); oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256); } else { iSourceFind = NULL; command_line->get_arg(iTestSearch, iSourceFind); } // Do the string compare if (oscl_strcmp(iSourceFind, "-help") == NULL) { fprintf(aFile, "Log level options. Default is debug level:\n"); fprintf(aFile, " -logerr\n"); fprintf(aFile, " Log at error level\n"); fprintf(aFile, " -logwarn\n"); fprintf(aFile, " Log at warning level\n\n"); } else if (oscl_strcmp(iSourceFind, "-logerr") == NULL) { loglevel = PVLOGMSG_ERR; } else if (oscl_strcmp(iSourceFind, "-logwarn") == NULL) { loglevel = PVLOGMSG_WARNING; } } if (cmdline_iswchar) { delete[] iSourceFind; iSourceFind = NULL; } }
PVLoggerConfigFile(): iLogFileRead(false) { iFileServer.Connect(); // Full path of pvlogger.ini is: SOURCENAME_PREPEND_STRING + pvlogger.ini oscl_strncpy(iLogFileName, SOURCENAME_PREPEND_STRING, oscl_strlen(SOURCENAME_PREPEND_STRING) + 1); oscl_strcat(iLogFileName, "pvlogger.ini"); oscl_memset(ibuffer, 0, sizeof(ibuffer)); iAppenderType = 0; }
OSCL_EXPORT_REF int32 Oscl_FileServer::Oscl_DeleteFile(const oscl_wchar* filename) { { //Convert to UTF8 char convfilename[OSCL_IO_FILENAME_MAXLEN]; if (0 == oscl_UnicodeToUTF8(filename, oscl_strlen(filename), convfilename, OSCL_IO_FILENAME_MAXLEN)) return (-1); return unlink(convfilename); } }
PVMFStatus PVMFAvcEncPort::AllocateKvp(PvmiKvp*& aKvp, PvmiKeyType aKey, int32 aNumParams) { LOG_STACK_TRACE((0, "PVMFAvcEncPort::AllocateKvp")); uint8* buf = NULL; uint32 keyLen = oscl_strlen(aKey) + 1; int32 err = 0; OSCL_TRY(err, buf = (uint8*)iAlloc.allocate(aNumParams * (sizeof(PvmiKvp) + keyLen)); if (!buf) OSCL_LEAVE(OsclErrNoMemory); );
OSCL_EXPORT_REF OSCL_FILEMGMT_ERR_TYPE oscl_getcwd(oscl_wchar *path, uint32 size) { char convpathname[OSCL_IO_FILENAME_MAXLEN]; if (oscl_getcwd(convpathname, size > OSCL_IO_FILENAME_MAXLEN ? OSCL_IO_FILENAME_MAXLEN : size) == OSCL_FILEMGMT_E_OK) { if (0 == oscl_UTF8ToUnicode(convpathname, oscl_strlen(convpathname), path, size) && oscl_strlen(convpathname) != 0) { return OSCL_FILEMGMT_E_PATH_TOO_LONG; } return OSCL_FILEMGMT_E_OK; } return OSCL_FILEMGMT_E_PATH_NOT_FOUND; }
void FindMemMgmtRelatedCmdLineParams(cmd_line* command_line, bool& aPrintDetailedMemLeakInfo, FILE* aFile) { aPrintDetailedMemLeakInfo = false; bool cmdline_iswchar = command_line->is_wchar(); int count = command_line->get_count(); // Search for the "-logerr"/"-logwarn" argument char *iSourceFind = NULL; if (cmdline_iswchar) { iSourceFind = new char[256]; } // Go through each argument for (int iTestSearch = 0; iTestSearch < count; iTestSearch++) { // Convert to UTF8 if necessary if (cmdline_iswchar) { OSCL_TCHAR* cmd = NULL; command_line->get_arg(iTestSearch, cmd); oscl_UnicodeToUTF8(cmd, oscl_strlen(cmd), iSourceFind, 256); } else { iSourceFind = NULL; command_line->get_arg(iTestSearch, iSourceFind); } // Do the string compare if (oscl_strcmp(iSourceFind, "-help") == NULL) { fprintf(aFile, "Printing leak info option. Default is OFF:\n"); fprintf(aFile, " -leakinfo\n"); fprintf(aFile, " If there is a memory leak, prints out the memory leak information\n"); fprintf(aFile, " after all specified test cases have finished running.\n\n"); } else if (oscl_strcmp(iSourceFind, "-leakinfo") == NULL) { aPrintDetailedMemLeakInfo = true; } } if (cmdline_iswchar) { delete[] iSourceFind; iSourceFind = NULL; } }
OSCL_EXPORT_REF oscl_wchar* oscl_strcat(oscl_wchar* dest, const oscl_wchar* src) { if (dest == NULL) { return NULL; } oscl_wchar* tmp = dest + oscl_strlen(dest); for (uint32 i = 0; *src != '\0'; i++) { *tmp++ = *src++; } *tmp = '\0'; return dest; }
OSCL_EXPORT_REF Oscl_Tag_Base::tag_base_type Oscl_Tag_Base::tag_ancestor(tag_base_type& dest, const tag_base_type& src) const { // dest and src can be the same for this call. // This is optimal in some cases when the src string can be modified to be the ancestor string. if (dest != src) { tag_copy(dest, src); } tag_base_type endptr = dest + oscl_strlen(dest); while (*endptr != '.' && endptr != dest) endptr--; *endptr = '\0'; return dest; }
OSCL_EXPORT_REF int extract_string(const char * in_ptr, char *outstring, int maxsize) { int len = 0; if (! outstring) { return 0; } in_ptr = skip_whitespace(in_ptr, in_ptr + oscl_strlen(in_ptr)); for (; in_ptr && *in_ptr ; ++in_ptr) { if (*in_ptr == ' ' || *in_ptr == '\t' || *in_ptr == '\n' || *in_ptr == '\r') { // whitespace so stop copying break; } if (len < maxsize) { *outstring++ = *in_ptr; } else if (len == maxsize) { // too long so just terminate the string *(outstring - 1) = '\0'; } ++len; } if (len < maxsize) { // terminate the string *outstring = '\0'; } return len; }
OSCL_EXPORT_REF bool compose_RTSP_string(char *str, unsigned int max_len, const RtspRangeType& range, int& len_used) { len_used = 0; // first verify that there is something to do if (range.format == RtspRangeType::UNKNOWN_RANGE || range.format == RtspRangeType::INVALID_RANGE) { // nothing to output but it is not an error return true; } const char *range_str = "Range: "; int length = oscl_strlen(range_str); // output the "Range: " string if ((int)max_len < length) { return false; } oscl_memcpy(str, range_str, length); str += length; len_used += length; max_len -= length; if (compose_range_string(str, max_len, range, length) != true) { len_used += length; return false; } len_used += length; return true; }
//============================================================================== // InitializeReporting PUBLIC STATIC //============================================================================== // OSCL_EXPORT_REF void UT::CM::InitializeReporting ( const char* a_pszTestname, OSCL_HeapString<OsclMemAllocator>& a_filename, FILE* a_pFileStreamParent, FILE*& a_pFileStreamChild ) { a_pFileStreamChild = a_pFileStreamParent; if (0 == a_pszTestname || 0 >= a_filename.get_size() || 0 == a_pFileStreamParent) return; Oscl_FileServer fs; fs.Connect(); Oscl_File f; if (0 == f.Open(a_filename.get_cstr(), Oscl_File::MODE_READWRITE | Oscl_File::MODE_TEXT, fs)) { _STRING xfr = xml_test_interpreter::unexpected_termination_interpretation(a_pszTestname); f.Write(xfr.c_str(), sizeof(char), oscl_strlen(xfr.c_str())); f.Close(); } else { fprintf(a_pFileStreamParent, "ERROR: Failed to open XML test summary log file (%s).\n", a_filename.get_cstr()); } fs.Close(); OSCL_HeapString<OsclMemAllocator> outFilename(a_filename); outFilename += ".out"; // open a new stream to file and return it to client a_pFileStreamChild = fopen(outFilename.get_cstr(), "w"); }
bool INetURI::parseURL(OSCL_String &aUrl8, OSCL_String &aSerAdd, int32 &aSerPort) { OSCL_HeapString<OsclMemAllocator> tmpUrl8(aUrl8); typedef char mbchar; mbchar* aUrl = tmpUrl8.get_str(); mbchar *server_ip_ptr = oscl_strstr(((mbchar*)aUrl), "//"); if (server_ip_ptr == NULL) return false; server_ip_ptr += 2; /* Locate the IP address. */ mbchar *server_port_ptr = oscl_strstr(server_ip_ptr, ":"); mbchar *tmp_ptr = server_port_ptr; if (tmp_ptr == NULL) tmp_ptr = server_ip_ptr; mbchar *clip_name = oscl_strstr(tmp_ptr, "/"); if (clip_name != NULL) *clip_name++ = '\0'; /* Locate the port number if provided. */ aSerPort = DEFAULT_HTTP_PORT_NUMBER; if ((server_port_ptr != NULL) && (*(server_port_ptr + 1) != '/')) { *(server_port_ptr++) = '\0'; uint32 atoi_tmp; if (PV_atoi(server_port_ptr, 'd', atoi_tmp)) aSerPort = atoi_tmp; else return false; } /* relocate the server IP address, either stop at ':' or '/' */ mbchar *server_end_ptr = oscl_strstr(server_ip_ptr, "/"); if (server_end_ptr) *server_end_ptr = '\0'; OSCL_HeapString<OsclMemAllocator> tmpServerName(server_ip_ptr, oscl_strlen(server_ip_ptr)); aSerAdd = tmpServerName; return true; }
void pv_metadata_engine_test::PrintSupportedMetaDataKeys() { uint32 i = 0; fprintf(file, "\n\nOutput for file: %s\n", iFileName); fprintf(file, "\nMetadata key list (count=%d):\n", iMetadataKeyList.size()); for (i = 0; i < iMetadataKeyList.size(); ++i) { fprintf(file, "Key %d: %s\n", (i + 1), iMetadataKeyList[i].get_cstr()); } fprintf(file, "\nMetadata value list (count=%d):\n", iMetadataValueList.size()); for (i = 0; i < iMetadataValueList.size(); ++i) { fprintf(file, "Value %d:\n Key string: %s\n", (i + 1), iMetadataValueList[i].key); switch (GetValTypeFromKeyString(iMetadataValueList[i].key)) { case PVMI_KVPVALTYPE_CHARPTR: fprintf(file, " Value:%s\n", iMetadataValueList[i].value.pChar_value); break; case PVMI_KVPVALTYPE_WCHARPTR: { // Assume string is in UCS-2 encoding so convert to UTF-8 char tmpstr[65]; oscl_UnicodeToUTF8(iMetadataValueList[i].value.pWChar_value, oscl_strlen(iMetadataValueList[i].value.pWChar_value), tmpstr, 65); tmpstr[64] = '\0'; fprintf(file, " Value(in UTF-8, first 64 chars):%s\n", tmpstr); } break; case PVMI_KVPVALTYPE_UINT32: fprintf(file, " Value:%d\n", iMetadataValueList[i].value.uint32_value); break; case PVMI_KVPVALTYPE_INT32: fprintf(file, " Value:%d\n", iMetadataValueList[i].value.int32_value); break; case PVMI_KVPVALTYPE_UINT8: fprintf(file, " Value:%d\n", iMetadataValueList[i].value.uint8_value); break; case PVMI_KVPVALTYPE_FLOAT: fprintf(file, " Value:%f\n", iMetadataValueList[i].value.float_value); break; case PVMI_KVPVALTYPE_DOUBLE: fprintf(file, " Value:%f\n", iMetadataValueList[i].value.double_value); break; case PVMI_KVPVALTYPE_BOOL: if (iMetadataValueList[i].value.bool_value) { fprintf(file, " Value:true(1)\n"); } else { fprintf(file, " Value:false(0)\n"); } break; default: fprintf(file, " Value: UNKNOWN VALUE TYPE\n"); break; } fprintf(file, " Length:%d Capacity:%d\n", iMetadataValueList[i].length, iMetadataValueList[i].capacity); } }
void pv_metadata_engine_test::ReadClipsFile() { char* iClip; char ClipsFileName[255]; int32 err = 0; Oscl_FileServer fileServer; err = fileServer.Connect(); if (0 == err) { Oscl_File *ClipsFile = new Oscl_File; // Full path of ClipsFile is: SOURCENAME_PREPEND_STRING + pvlogger.ini oscl_strncpy(ClipsFileName, SOURCENAME_PREPEND_STRING, oscl_strlen(SOURCENAME_PREPEND_STRING) + 1); oscl_strcat(ClipsFileName, "Clips.txt"); printf("\nPath for Clips File is %s\n", ClipsFileName); err = ClipsFile->Open(ClipsFileName, Oscl_File::MODE_READ, fileServer); if (0 == err) { int len = 0; if (0 == ClipsFile->Seek(0, Oscl_File::SEEKSET)) { while (!ClipsFile->EndOfFile()) { iClip = (char*)oscl_malloc(200); iClip[0] = '\0'; fgetline(ClipsFile, iClip, 127); len = oscl_strlen(iClip); if (len == 0 || iClip[0] == '\n' || (iClip[0] == '\r' && iClip[1] == '\n')) { numOfClips--; oscl_free(iClip); } else if (iClip[len-1] == '\n' && iClip[len-2] == '\r') { iClip[len-2] = '\0'; iClips.push_back(iClip); } else if (iClip[len-1] == '\n' && iClip[len-2] != '\r') { iClip[len-1] = '\0'; iClips.push_back(iClip); } else { iClip[len] = '\0'; iClips.push_back(iClip); } numOfClips++; } ClipsFile->Close(); printf("\nClips are\n"); for (it = iClips.begin(); it < iClips.end(); it++) { printf("\n%s\n", *it); } it = iClips.begin(); iClipFilePresent = true; } } delete(ClipsFile); } fileServer.Close(); }
void pv_metadata_engine_test::Run() { int error = 0; switch (iState) { case STATE_CREATE: { iPVMEContainer.iCmdStatusObserver = this; iPVMEContainer.iInfoEventObserver = this; iPVMEContainer.iErrorEventObserver = this; iPVMEContainer.iMode = iMode; if (iPVMEContainer.iMode == PV_METADATA_ENGINE_THREADED_MODE) { //Configure the threadsafe queues that are used for engine //thread callbacks. iThreadSafeCommandQueue.Configure(this); iThreadSafeErrorQueue.Configure(this); iThreadSafeInfoQueue.Configure(this); iPVMEContainer.iSem.Create(); iPVMEContainer.iAppenderType = iLoggerInfo.iAppenderType; iPVMEContainer.iLogfilename = iLoggerInfo.logfilename; iPVMEContainer.iLoggerConfigElements = iLoggerInfo.iLoggerConfigElements; } OSCL_TRY(error, PVMetadataEngineFactory::CreatePVMetadataEngine(iPVMEContainer)); PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::Create Called ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount()))); if (error || iPVMEContainer.iPVMEInterface == NULL) { PVMEATB_TEST_IS_TRUE(false); iObserver->TestCompleted(*iTestCase); } else { iState = STATE_INIT; RunIfNotReady(); } } break; case STATE_INIT: { PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::Init Issued ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount()))); iCurrentCmdId = iPVMEContainer.iPVMEInterface->Init((OsclAny*) & iContextObject); } break; case STATE_SETMETADATAKEYS: { ReadMetadataFile(); ReadClipsFile(); if (iClipFilePresent == false) { fprintf(file, "\nClip File Not Present \n"); iState = STATE_RESET; RunIfNotReady(); } else if (iMetadataKeyList.size() != 0) { PVMFStatus status; PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::SetMetadataKeys Issued ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount()))); status = iPVMEContainer.iPVMEInterface->SetMetaDataKeys(iMetadataKeyList); if (status == PVMFErrInvalidState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::SetMetadataKeys called in wrong state")); } else { iState = STATE_GETMETADATA; RunIfNotReady(); } } else { iState = STATE_GETMETADATA; RunIfNotReady(); } } break; case STATE_GETMETADATA: { //If GetMetadata is being called second time in MultipleGetMetadataTest, we don't want these statements to execute again if (iDataSource == NULL) { // Create a player data source and add it iDataSource = new PVPlayerDataSourceURL; } OSCL_wHeapString<OsclMemAllocator> inputfilename; // Convert the source file name to UCS2 and extract the filename part PVMFFormatType iFileType; iFileName = *it; it++; GetSourceFormatType(iFileName, iFileType); oscl_UTF8ToUnicode(iFileName, oscl_strlen(iFileName), iTempWCharBuf, 512); wFileName.set(iTempWCharBuf, oscl_strlen(iTempWCharBuf)); RetrieveFilename(wFileName.get_str(), inputfilename); printf("\nInput File Name is %s", iFileName); iDataSource->SetDataSourceURL(wFileName); iDataSource->SetDataSourceFormatType(iFileType); start_time = OsclTickCount::TicksToMsec(OsclTickCount::TickCount()); PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::GetMetadata Issued ClockInMS = (%d)", start_time)); OSCL_TRY(error, iCurrentCmdId = iPVMEContainer.iPVMEInterface->GetMetadata(*iDataSource, iMetadataValueList, (OsclAny*) & iContextObject)); OSCL_FIRST_CATCH_ANY(error, PVMEATB_TEST_IS_TRUE(false); iState = STATE_RESET; RunIfNotReady()); } break; case STATE_RESET: { PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::Reset Issued ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount()))); iCurrentCmdId = iPVMEContainer.iPVMEInterface->Reset((OsclAny*) & iContextObject); } break; case STATE_DELETE: { PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::Delete Called ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount()))); PVMFStatus status = PVMetadataEngineFactory::DeletePVMetadataEngine(iPVMEContainer); if (status != PVMFSuccess) { PVMEATB_TEST_IS_TRUE(false); } delete iDataSource; iDataSource = NULL; iFS.Close(); if (iPVMEContainer.iMode == PV_METADATA_ENGINE_THREADED_MODE) { iPVMEContainer.iSem.Close(); } PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::TotalNumClips=%d", numOfClips)); PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::AverageGetMetaDataTimeInMS=%d", (AverageGetMetaDataTimeInMS / numOfClips))); PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::MaxGetMetaDataTime=%d", MaxGetMetaDataTime)); PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO, (0, "PVMetadataEngineTest::MinGetMetaDataTime=%d", MinGetMetaDataTime)); iObserver->TestCompleted(*iTestCase); } break; default: break; } }
void pv_metadata_engine_test::ReadMetadataFile() { Oscl_File *MetadataFile = new Oscl_File; const int numKeys = 40; char arr[numKeys][MAX_LEN]; char *keys[numKeys]; int count = 0; char KeysFileName[255]; int32 err = 0; Oscl_FileServer fileServer; err = fileServer.Connect(); // Full path of MetadataFile is: SOURCENAME_PREPEND_STRING + pvlogger.ini oscl_strncpy(KeysFileName, SOURCENAME_PREPEND_STRING, oscl_strlen(SOURCENAME_PREPEND_STRING) + 1); oscl_strcat(KeysFileName, "MetadataKeys.txt"); printf("\nPath for Keys File is %s\n", KeysFileName); err = MetadataFile->Open(KeysFileName, Oscl_File::MODE_READ, fileServer); if (0 == err) { int ii = 0; int len = 0; if (0 == MetadataFile->Seek(0, Oscl_File::SEEKSET)) { while (!MetadataFile->EndOfFile()) { arr[ii][0] = '\0'; fgetline(MetadataFile, arr[ii], MAX_LEN); len = oscl_strlen(arr[ii]); if (len == 0 || arr[ii][0] == '\n' || (arr[ii][0] == '\r' && arr[ii][1] == '\n')) { ii--; } else if (arr[ii][len-1] == '\n' && arr[ii][len-2] == '\r') { arr[ii][len-2] = '\0'; keys[ii] = arr[ii]; } else if (arr[ii][len-1] == '\n' && arr[ii][len-2] != '\r') { arr[ii][len-1] = '\0'; keys[ii] = arr[ii]; } else { arr[ii][len] = '\0'; keys[ii] = arr[ii]; } ii++; } } MetadataFile->Close(); count = ii - 1; printf("\nKeys are\n"); for (int j = 0; j <= ii - 1; j++) { printf("\n%s", keys[j]); } for (int i = 0; i <= count; i++) { iMetadataKeyList.push_front(keys[i]); } } fileServer.Close(); delete(MetadataFile); }
//============================================================================== // FinalizeReporting PUBLIC STATIC //============================================================================== // OSCL_EXPORT_REF void UT::CM::FinalizeReporting ( const char* a_pszTestname, OSCL_HeapString<OsclMemAllocator> &a_filename, const test_result& a_tr, FILE* a_pFileStreamParent, FILE* a_pFileStreamChild ) { if (0 == a_pFileStreamChild) return; // report the textual representation of the test results text_test_interpreter interp; _STRING rs = interp.interpretation(a_tr); fprintf(a_pFileStreamChild, "%s", rs.c_str()); if (0 == a_pszTestname || 0 >= a_filename.get_size() || 0 == a_pFileStreamParent) return; _STRING strChild; fclose(a_pFileStreamChild); // close the stream OSCL_HeapString<OsclMemAllocator> outFilename(a_filename); outFilename += ".out"; FILE* pFile = fopen(outFilename.get_cstr(), "rb"); if (0 == pFile) fprintf(a_pFileStreamParent, "ERROR: Failed to open file (%s) for capturing test output!\n", outFilename.get_cstr()); else { fseek(pFile, 0, SEEK_END); long lSize = ftell(pFile); rewind(pFile); char* buffer = new char[lSize]; fread(buffer, 1, lSize, pFile); strChild = _STRING(buffer, lSize); fprintf(a_pFileStreamParent, "%s", strChild.c_str()); // send the captured output back out the parent stream delete [] buffer; fclose(pFile); } Oscl_FileServer fs; fs.Connect(); Oscl_File f; if (0 == f.Open(a_filename.get_str(), Oscl_File::MODE_READWRITE | Oscl_File::MODE_TEXT, fs)) { _STRING xfr = xml_test_interpreter::interpretation(a_tr, a_pszTestname, &strChild); fprintf(a_pFileStreamParent, "\nWrote xml-formatted test results to file: %s\n", a_filename.get_cstr()); f.Write(xfr.c_str(), sizeof(char), oscl_strlen(xfr.c_str())); f.Close(); } else { fprintf(a_pFileStreamParent, "\nERROR: Failed to open file (%s) for xml-formatted test results\n", a_filename.get_cstr()); } fs.Close(); }
/* ======================================================================== */ OSCL_EXPORT_REF bool PV_atoi(const char *buf, const char new_format, uint32& value) { return PV_atoi(buf, new_format, oscl_strlen(buf), value); }
PVMFStatus PVMFFileOutputNode::GetConfigParameter(PvmiKvp*& aParameters, int& aNumParamElements, int32 aIndex, PvmiKvpAttr aReqattr) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFFileOutputNode::GetConfigParameter() In")); aNumParamElements = 0; // Allocate memory for the KVP aParameters = (PvmiKvp*)oscl_malloc(sizeof(PvmiKvp)); if (aParameters == NULL) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::GetConfigParameter() Memory allocation for KVP failed")); return PVMFErrNoMemory; } oscl_memset(aParameters, 0, sizeof(PvmiKvp)); // Allocate memory for the key string in KVP PvmiKeyType memblock = (PvmiKeyType)oscl_malloc(FILEOUTPUTCONFIG_KEYSTRING_SIZE * sizeof(char)); if (NULL == memblock) { oscl_free(aParameters); PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::GetConfigParameter() Memory allocation for key string failed")); return PVMFErrNoMemory; } oscl_strset(memblock, 0, FILEOUTPUTCONFIG_KEYSTRING_SIZE * sizeof(char)); // Assign the key string buffer to KVP aParameters[0].key = memblock; // Copy the key string oscl_strncat(aParameters[0].key, _STRLIT_CHAR("x-pvmf/file/output/"), 21); oscl_strncat(aParameters[0].key, FileOutputNodeConfig_BaseKeys[aIndex].iString, oscl_strlen(FileOutputNodeConfig_BaseKeys[aIndex].iString)); oscl_strncat(aParameters[0].key, _STRLIT_CHAR(";type=value;valtype="), 20); switch (FileOutputNodeConfig_BaseKeys[aIndex].iValueType) { case PVMI_KVPVALTYPE_BITARRAY32: oscl_strncat(aParameters[0].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_BITARRAY32_STRING), oscl_strlen(PVMI_KVPVALTYPE_BITARRAY32_STRING)); break; case PVMI_KVPVALTYPE_KSV: oscl_strncat(aParameters[0].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_KSV_STRING), oscl_strlen(PVMI_KVPVALTYPE_KSV_STRING)); break; case PVMI_KVPVALTYPE_BOOL: oscl_strncat(aParameters[0].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_BOOL_STRING), oscl_strlen(PVMI_KVPVALTYPE_BOOL_STRING)); break; case PVMI_KVPVALTYPE_INT32: if (aReqattr == PVMI_KVPATTR_CUR) { oscl_strncat(aParameters[0].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_INT32_STRING), oscl_strlen(PVMI_KVPVALTYPE_RANGE_UINT32_STRING)); } break; case PVMI_KVPVALTYPE_UINT32: default: if (PVMI_KVPATTR_CAP == aReqattr) { oscl_strncat(aParameters[0].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_RANGE_UINT32_STRING), oscl_strlen(PVMI_KVPVALTYPE_RANGE_UINT32_STRING)); } else { oscl_strncat(aParameters[0].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_UINT32_STRING), oscl_strlen(PVMI_KVPVALTYPE_UINT32_STRING)); } break; } aParameters[0].key[FILEOUTPUTCONFIG_KEYSTRING_SIZE-1] = 0; // Copy the requested info switch (aIndex) { case PARAMETER1: // "parameter1" if (PVMI_KVPATTR_CUR == aReqattr) { // Return current value // get the parameter value here } else if (PVMI_KVPATTR_DEF == aReqattr) { // return default } else { // Return capability } break; case PARAMETER2: // "parameter2" if (PVMI_KVPATTR_CUR == aReqattr) { // Return current value // get the parameter value here } else if (PVMI_KVPATTR_DEF == aReqattr) { // return default } else { // Return capability } break; default: // Invalid index oscl_free(aParameters[0].key); oscl_free(aParameters); PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::GetConfigParameter() Invalid index to file output node parameter")); return PVMFErrNotSupported; } aNumParamElements = 1; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFFileOutputNode::GetConfigParameter() Out")); return PVMFSuccess; }
OSCL_EXPORT_REF bool RTSPOutgoingMessage::compose() { // compose the first line // switch (msgType) { case RTSPResponseMsg: { // RTSP version // oscl_memcpy(fullRequestBuffer, RTSPVersionString, RTSPVersionString_len); fullRequestBufferSpace += RTSPVersionString_len; *(fullRequestBufferSpace++) = ' '; // Status code // oscl_snprintf(fullRequestBufferSpace, RTSP_MAX_FULL_REQUEST_SIZE - 1, "%d", statusCode); // resync the pointer and size used fullRequestBufferSizeUsed = oscl_strlen(fullRequestBufferSpace); fullRequestBufferSpace += fullRequestBufferSizeUsed; *(fullRequestBufferSpace++) = ' '; fullRequestBufferSizeUsed += 1 + RTSPVersionString_len + 1; if (0 != reasonString.length()) { // user specified his own string // oscl_memcpy(fullRequestBufferSpace, reasonString.c_str(), reasonString.length()); fullRequestBufferSpace += reasonString.length(); fullRequestBufferSizeUsed += reasonString.length(); } else { StrPtrLen realReasonString ; // user wants the built-in default // switch (statusCode) { case CodeContinue: realReasonString = RtspReasonStringContinue; break; case CodeOK: realReasonString = RtspReasonStringOK; break; case CodeCreated: realReasonString = RtspReasonStringCreated; break; case CodeLowOnStorageSpace: realReasonString = RtspReasonStringLowOnStorageSpace; break; case CodeMultipleChoices: realReasonString = RtspReasonStringMultipleChoices; break; case CodeMovedPermanently: realReasonString = RtspReasonStringMovedPermanently; break; case CodeMovedTemporarily: realReasonString = RtspReasonStringMovedTemporarily; break; case CodeSeeOther: realReasonString = RtspReasonStringSeeOther; break; case CodeNotModified: realReasonString = RtspReasonStringNotModified; break; case CodeUseProxy: realReasonString = RtspReasonStringUseProxy; break; case CodeBadRequest: realReasonString = RtspReasonStringBadRequest; break; case CodeUnauthorized: realReasonString = RtspReasonStringUnauthorized; break; case CodePaymentRequired: realReasonString = RtspReasonStringPaymentRequired; break; case CodeForbidden: realReasonString = RtspReasonStringForbidden; break; case CodeNotFound: realReasonString = RtspReasonStringNotFound; break; case CodeMethodNotAllowed: realReasonString = RtspReasonStringMethodNotAllowed; break; case CodeNotAcceptable: realReasonString = RtspReasonStringNotAcceptable; break; case CodeProxyAuthenticationRequired: realReasonString = RtspReasonStringProxyAuthenticationRequired; break; case CodeRequestTimeOut: realReasonString = RtspReasonStringRequestTimeOut; break; case CodeGone: realReasonString = RtspReasonStringGone; break; case CodeLengthRequired: realReasonString = RtspReasonStringLengthRequired; break; case CodePreconditionFailed: realReasonString = RtspReasonStringPreconditionFailed; break; case CodeRequestEntityTooLarge: realReasonString = RtspReasonStringRequestEntityTooLarge; break; case CodeRequestURITooLarge: realReasonString = RtspReasonStringRequestURITooLarge; break; case CodeUnsupportedMediaType: realReasonString = RtspReasonStringUnsupportedMediaType; break; case CodeSessionNotFound: realReasonString = RtspReasonStringSessionNotFound; break; case CodeMethodNotValidInThisState: realReasonString = RtspReasonStringMethodNotValidInThisState; break; case CodeHeaderFieldNotValidForResource: realReasonString = RtspReasonStringHeaderFieldNotValidForResource; break; case CodeInvalidRange: realReasonString = RtspReasonStringInvalidRange; break; case CodeParameterIsReadOnly: realReasonString = RtspReasonStringParameterIsReadOnly; break; case CodeAggregateOperationNotAllowed: realReasonString = RtspReasonStringAggregateOperationNotAllowed; break; case CodeOnlyAggregateOperationAllowed: realReasonString = RtspReasonStringOnlyAggregateOperationAllowed; break; case CodeUnsupportedTransport: realReasonString = RtspReasonStringUnsupportedTransport; break; case CodeDestinationUnreachable: realReasonString = RtspReasonStringDestinationUnreachable; break; case CodeUnsupportedClient: realReasonString = RtspReasonStringUnsupportedClient; break; case CodeInternalServerError: realReasonString = RtspReasonStringInternalServerError; break; case CodeNotImplemented: realReasonString = RtspReasonStringNotImplemented; break; case CodeBadGateway: realReasonString = RtspReasonStringBadGateway; break; case CodeServiceUnavailable: realReasonString = RtspReasonStringServiceUnavailable; break; case CodeGatewayTimeout: realReasonString = RtspReasonStringGatewayTimeout; break; case CodeRTSPVersionNotSupported: realReasonString = RtspReasonStringRTSPVersionNotSupported; break; case CodeOptionNotSupported: realReasonString = RtspReasonStringOptionNotSupported; break; case CodeParameterNotUnderstood: realReasonString = RtspReasonStringParameterNotUnderstood; break; default: // no string was found, since code is unknown... ;;; } if (realReasonString.length()) { oscl_memcpy(fullRequestBufferSpace, realReasonString.c_str(), realReasonString.length()); fullRequestBufferSpace += realReasonString.length(); fullRequestBufferSizeUsed += realReasonString.length(); } } break; } case RTSPRequestMsg: { if (METHOD_BINARY_DATA == method) { // it's interleaved stuff // leading dollar *(fullRequestBufferSpace++) = CHAR_DOLLAR; // 8-bit channel-id from the content-type *(fullRequestBufferSpace++) = contentType.c_str()[0]; // 16-bit content length, in network byte order *(fullRequestBufferSpace++) = char((contentLength & 0xFF00) >> 8); *(fullRequestBufferSpace++) = char((contentLength & 0xFF)); *fullRequestBufferSpace = CHAR_NULL; fullRequestBufferSizeUsed = 4; fullRequestPLS = fullRequestBuffer; return true; } // okay, it's a normal request // do the method if (method < 0 || method >= METHOD_NUM_ENTRIES) { // method unknown return false; } uint32 method_strlen = oscl_strlen(RtspMethodStringPLSS[method]); oscl_memcpy(fullRequestBufferSpace, RtspMethodStringPLSS[method], method_strlen ); fullRequestBufferSpace += method_strlen; *(fullRequestBufferSpace++) = CHAR_SPACE; fullRequestBufferSizeUsed += method_strlen + 1; // do the URI oscl_memcpy(fullRequestBufferSpace, originalURI.c_str(), originalURI.length() ); fullRequestBufferSpace += originalURI.length(); *(fullRequestBufferSpace++) = CHAR_SPACE; fullRequestBufferSizeUsed += originalURI.length() + 1; // do the RTSP version #ifdef SIMPLE_HTTP_SUPPORT if ((method == METHOD_GET) || (method == METHOD_POST)) { oscl_memcpy(fullRequestBufferSpace, HTTPVersion_1_0_String, HTTPVersionString_len ); } else #endif oscl_memcpy(fullRequestBufferSpace, RTSPVersionString, RTSPVersionString_len ); fullRequestBufferSpace += RTSPVersionString_len; fullRequestBufferSizeUsed += RTSPVersionString_len; break; } default: { // cannot encode an unknown type of message return false; } }
/* ======================================================================== */ OSCL_EXPORT_REF bool PV_atof(const char *buf, OsclFloat& value) { return PV_atof(buf, oscl_strlen(buf), value); }