int sysInfoToCSV(FILE *f_csv) { char infoBuffer[256]; const IppLibraryVersion *verIppSC, *verIppSP; if(f_csv == NULL) return -1; #ifndef OSX32 infoBuffer[0] = '\0'; vm_sys_info_get_date((char*)infoBuffer,DDMMYY); vm_string_fprintf(f_csv,VM_STRING("Date,%s"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_time((char*)infoBuffer,HHMMSS); vm_string_fprintf(f_csv,VM_STRING(",Time,%s\n"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_cpu_name((char*)infoBuffer); vm_string_fprintf(f_csv,VM_STRING("CPU,%s\n"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_os_name((char*)infoBuffer); vm_string_fprintf(f_csv,VM_STRING("OS,%s\n"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_computer_name((char*)infoBuffer); vm_string_fprintf(f_csv,VM_STRING("Computer name,%s\n"),infoBuffer); #endif verIppSC = ippscGetLibVersion(); verIppSP = ippsGetLibVersion(); fprintf(f_csv,"IPPS library,%s,%s,%s\n", verIppSP->Name,verIppSP->Version,verIppSP->BuildDate); fprintf(f_csv,"IPPSC library,%s,%s,%s\n", verIppSC->Name,verIppSC->Version,verIppSC->BuildDate); fprintf(f_csv,"EC TYPE,alg type,adaptation,bits,sampling rate,rin file,sin file,speech in sec,speed in mHz\n"); return 0; }
void vm_sys_info_get_computer_name(vm_char *computer_name) { vm_char data[_MAX_LEN] = {0,}; /* it can be wchar variable */ DWORD dwSize = sizeof(data) / sizeof(data[0]); /* check error(s) */ if (NULL == computer_name) return; GetComputerName(data, &dwSize); vm_string_sprintf(computer_name, VM_STRING("%s"), data); }
void vm_sys_info_get_computer_name(vm_char *computer_name) { vm_char data[_MAX_LEN] = {0,}; /* it can be wchar variable */ Ipp32u dwSize = sizeof(data) / sizeof(data[0]); /* check error(s) */ if (NULL == computer_name) return; SystemParametersInfo(SPI_GETOEMINFO, dwSize, data, 0); vm_string_sprintf(computer_name, VM_STRING("%s"), data); }
void ReportLeak() { if(FILE *f = _tfopen(g_OutputFileName, VM_STRING("a"))) { fprintf(f, "Memory leak %d, %s, %s, %d\n", m_size, 0 == m_lpcBinaryName ? "UnknownBinary" : m_lpcBinaryName, 0 == m_lpcFileName ? "UnknownFile" : m_lpcFileName, m_iStringNumber); fclose(f); } }
void vm_sys_info_get_cpu_name(vm_char *cpu_name) { HKEY hKey; vm_char data[_MAX_LEN] = {0,}; /* it can be wchar variable */ DWORD dwSize = sizeof(data) / sizeof(data[0]); Ipp32s i = 0; LONG lErr; /* check error(s) */ if (NULL == cpu_name) return; lErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, VM_STRING("Hardware\\Description\\System\\CentralProcessor\\0"), 0, KEY_QUERY_VALUE, &hKey); if (ERROR_SUCCESS == lErr) { RegQueryValueEx(hKey, _T("ProcessorNameString"), NULL, NULL, (LPBYTE)&data, &dwSize); /* error protection */ data[sizeof(data) / sizeof(data[0]) - 1] = 0; while (data[i++] == ' '); vm_string_strcpy(cpu_name, (vm_char *)(data + i - 1)); RegCloseKey (hKey); } else vm_string_sprintf(cpu_name, VM_STRING("Unknown")); } /* void vm_sys_info_get_cpu_name(vm_char *cpu_name) */
/////////////////////////////////////////////////////////////////////////////// // freeLongTermRef // Mark the long-term reference frame with specified LongTermFrameIdx // as not used /////////////////////////////////////////////////////////////////////////////// H264DecoderFrame * H264DBPList::freeLongTermRefIdx(Ipp32s LongTermFrameIdx, H264DecoderFrame * pCurrentFrame) { H264DecoderFrame *pCurr = m_pHead; while (pCurr) { if (pCurr->m_PictureStructureForRef >= FRM_STRUCTURE) { if (pCurr->isLongTermRef() && (pCurr->LongTermFrameIdx() == LongTermFrameIdx )) { if (pCurrentFrame == pCurr) return 0; pCurr->unSetisLongTermRef(0); return pCurr; } } else { if (pCurr->isLongTermRef(0) && (pCurr->LongTermFrameIdx() == LongTermFrameIdx )) { if (pCurrentFrame == pCurr) return 0; pCurr->unSetisLongTermRef(0); pCurr->unSetisLongTermRef(1); return pCurr; } if (pCurr->isLongTermRef(1) && (pCurr->LongTermFrameIdx() == LongTermFrameIdx )) { if (pCurrentFrame == pCurr) return 0; pCurr->unSetisLongTermRef(0); pCurr->unSetisLongTermRef(1); return pCurr; } } pCurr = pCurr->future(); } // VM_ASSERT(false); vm_debug_trace2(VM_DEBUG_ERROR, VM_STRING("frame not found LongTermFrameIdx=%ld pCurrentFrame=%p"), LongTermFrameIdx, pCurrentFrame); return NULL; } // freeLongTermRefIdx
/////////////////////////////////////////////////////////////////////////////// // changeSTtoLTRef // Mark the short-term reference frame with specified PicNum as long-term // with specified long term idx. /////////////////////////////////////////////////////////////////////////////// void H264DBPList::changeSTtoLTRef(Ipp32s picNum, Ipp32s longTermFrameIdx) { H264DecoderFrame *pCurr = m_pHead; while (pCurr) { if (pCurr->m_PictureStructureForRef >= FRM_STRUCTURE) { if (pCurr->isShortTermRef() && (pCurr->PicNum(0) == picNum)) { pCurr->unSetisShortTermRef(0); pCurr->setLongTermFrameIdx(longTermFrameIdx); pCurr->SetisLongTermRef(0); pCurr->UpdateLongTermPicNum(2); return; } } else { if (pCurr->isShortTermRef(0) && (pCurr->PicNum(0) == picNum)) { pCurr->unSetisShortTermRef(0); pCurr->setLongTermFrameIdx(longTermFrameIdx); pCurr->SetisLongTermRef(0); pCurr->UpdateLongTermPicNum(pCurr->m_bottom_field_flag[0]); return; } if (pCurr->isShortTermRef(1) && (pCurr->PicNum(1) == picNum)) { pCurr->unSetisShortTermRef(1); pCurr->setLongTermFrameIdx(longTermFrameIdx); pCurr->SetisLongTermRef(1); pCurr->UpdateLongTermPicNum(pCurr->m_bottom_field_flag[1]); return; } } pCurr = pCurr->future(); } vm_debug_trace(VM_DEBUG_ERROR, VM_STRING("frame not found in changeSTtoLTRef")); // VM_ASSERT(false); // No match found, should not happen. return; } // changeSTtoLTRef
void vm_sys_info_get_vga_card(vm_char *vga_card) { SP_DEVINFO_DATA sp_dev_info; HDEVINFO DeviceInfoSet; vm_char string1[] = VM_STRING("Display"); Ipp32u dwIndex = 0; vm_char data[_MAX_LEN] = {0,}; /* check error(s) */ if (NULL == vga_card) return; ZeroMemory(&sp_dev_info, sizeof(SP_DEVINFO_DATA)); ZeroMemory(&DeviceInfoSet, sizeof(HDEVINFO)); DeviceInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT); sp_dev_info.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); while (SetupDiEnumDeviceInfo(DeviceInfoSet, dwIndex, &sp_dev_info)) { SetupDiGetDeviceRegistryProperty(DeviceInfoSet, &sp_dev_info, SPDRP_CLASS, NULL, (Ipp8u *) data, _MAX_LEN, NULL); if (!vm_string_strcmp((vm_char*)data, string1)) { SetupDiGetDeviceRegistryProperty(DeviceInfoSet, &sp_dev_info, SPDRP_DEVICEDESC, NULL, (PBYTE) vga_card, _MAX_LEN, NULL); break; } dwIndex++; } SetupDiDestroyDeviceInfoList(DeviceInfoSet); } /* void vm_sys_info_get_vga_card(vm_char *vga_card) */
/////////////////////////////////////////////////////////////////////////////// // freeLongTermRef // Mark the long-term reference frame with specified LongTermPicNum as not used /////////////////////////////////////////////////////////////////////////////// H264DecoderFrame * H264DBPList::freeLongTermRef(Ipp32s LongTermPicNum) { H264DecoderFrame *pCurr = m_pHead; bool found = false; while (pCurr) { if (pCurr->m_PictureStructureForRef>=FRM_STRUCTURE) { if (pCurr->isLongTermRef() && (pCurr->LongTermPicNum(0) == LongTermPicNum)) { pCurr->unSetisLongTermRef(0); return pCurr; } } else { if (pCurr->isLongTermRef(0) && (pCurr->LongTermPicNum(0) == LongTermPicNum)) { pCurr->unSetisLongTermRef(0); found = true; } if (pCurr->isLongTermRef(1) && (pCurr->LongTermPicNum(1) == LongTermPicNum)) { pCurr->unSetisLongTermRef(1); found = true; } if (found) return pCurr; } pCurr = pCurr->future(); } // VM_ASSERT(false); // No match found, should not happen. vm_debug_trace1(VM_DEBUG_ERROR, VM_STRING("frame not found LongTermPicNum=%ld"), LongTermPicNum); return NULL; } // freeLongTermRef
Ipp32u vm_sys_info_get_cpu_speed(void) { HKEY hKey; Ipp32u data = 0; DWORD dwSize = sizeof(Ipp32u); LONG lErr; lErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, VM_STRING("Hardware\\Description\\System\\CentralProcessor\\0"), 0, KEY_QUERY_VALUE, &hKey); if (ERROR_SUCCESS == lErr) { RegQueryValueEx (hKey, _T("~MHz"), NULL, NULL, (LPBYTE)&data, &dwSize); RegCloseKey(hKey); return data; } else return 0; }
/////////////////////////////////////////////////////////////////////////////// // freeShortTermRef // Mark the short-term reference frame with specified picNum as not used /////////////////////////////////////////////////////////////////////////////// H264DecoderFrame * H264DBPList::freeShortTermRef(Ipp32s picNum) { H264DecoderFrame *pCurr = m_pHead; bool found = false; while (pCurr) { if (pCurr->m_PictureStructureForRef >= FRM_STRUCTURE) { if (pCurr->isShortTermRef() && (pCurr->PicNum(0) == picNum)) { pCurr->unSetisShortTermRef(0); return pCurr; } } else { if (pCurr->isShortTermRef(0) && (pCurr->PicNum(0) == picNum)) { pCurr->unSetisShortTermRef(0); found = true; } if (pCurr->isShortTermRef(1) && (pCurr->PicNum(1) == picNum)) { pCurr->unSetisShortTermRef(1); found = true; } if (found) return pCurr; } pCurr = pCurr->future(); } //VM_ASSERT(false); vm_debug_trace1(VM_DEBUG_ERROR, VM_STRING("frame not found picNum=%ld"), picNum); return 0; } // freeShortTermRef
H264DecoderFrame *H264DBPList::findShortTermPic(Ipp32s picNum, Ipp32s * field) { H264DecoderFrame *pCurr = m_pHead; while (pCurr) { if (pCurr->m_PictureStructureForRef >= FRM_STRUCTURE) { if ((pCurr->isShortTermRef() == 3) && (pCurr->PicNum(0) == picNum)) { return pCurr; } } else { if (pCurr->isShortTermRef(0) && (pCurr->PicNum(0) == picNum)) { if (field) *field = 0; return pCurr; } if (pCurr->isShortTermRef(1) && (pCurr->PicNum(1) == picNum)) { if (field) *field = 1; return pCurr; } } pCurr = pCurr->future(); } throw h264_exception(UMC_ERR_INVALID_STREAM); //SB !!! VM_ASSERT(false); // No match found, should not happen. vm_debug_trace1(VM_DEBUG_ERROR, VM_STRING("frame not found in findShortTermPic(picNum=%ld)"), picNum); return NULL; } // findShortTermPic
void vm_sys_info_get_cpu_name(vm_char *cpu_name) { PROCESSOR_INFO pi; Ipp32u dwBytesReturned; Ipp32u dwSize = sizeof(PROCESSOR_INFO); BOOL bResult; /* check error(s) */ if (NULL == cpu_name) return; ZeroMemory(&pi, sizeof(PROCESSOR_INFO)); bResult = KernelIoControl(IOCTL_PROCESSOR_INFORMATION, NULL, 0, &pi, sizeof(PROCESSOR_INFO), &dwBytesReturned); vm_string_sprintf(cpu_name, VM_STRING("%s %s"), pi.szProcessCore, pi.szProcessorName); }
Ipp32s OutputSysInfo2CSVFile(vm_file *f_csv) { vm_char infoBuffer[256]; const IppLibraryVersion *verIppSC, *verIppSP; if(f_csv == NULL) return -1; infoBuffer[0] = '\0'; vm_sys_info_get_date(infoBuffer,DDMMYY); vm_string_fprintf(f_csv,VM_STRING("Date,%s"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_time(infoBuffer,HHMMSS); vm_string_fprintf(f_csv,VM_STRING(",Time,%s\n"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_cpu_name(infoBuffer); vm_string_fprintf(f_csv,VM_STRING("CPU,%s\n"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_os_name(infoBuffer); vm_string_fprintf(f_csv,VM_STRING("OS,%s\n"),infoBuffer); infoBuffer[0] = '\0'; vm_sys_info_get_computer_name(infoBuffer); vm_string_fprintf(f_csv,VM_STRING("Computer name,%s\n"),infoBuffer); verIppSC = ippscGetLibVersion(); verIppSP = ippsGetLibVersion(); vm_string_fprintf(f_csv,VM_STRING("IPPS library,%s,%s,%s\n"), verIppSP->Name,verIppSP->Version,verIppSP->BuildDate); vm_string_fprintf(f_csv,VM_STRING("IPPSC library,%s,%s,%s\n"), verIppSC->Name,verIppSC->Version,verIppSC->BuildDate); return 0; }
const vm_char* GetErrorStr(JERRCODE code) { const vm_char* str; switch(code) { case JPEG_OK: str = VM_STRING("no error"); break; case JPEG_NOT_IMPLEMENTED: str = VM_STRING("requested feature is not implemented"); break; case JPEG_ERR_INTERNAL: str = VM_STRING("internal error"); break; case JPEG_ERR_PARAMS: str = VM_STRING("wrong parameters"); break; case JPEG_ERR_BUFF: str = VM_STRING("buffer too small"); break; case JPEG_ERR_FILE: str = VM_STRING("file io operation failed"); break; case JPEG_ERR_ALLOC: str = VM_STRING("memory allocation failed"); break; case JPEG_ERR_BAD_DATA: str = VM_STRING("bad segment data"); break; case JPEG_ERR_DHT_DATA: str = VM_STRING("bad huffman table segment"); break; case JPEG_ERR_DQT_DATA: str = VM_STRING("bad quant table segment"); break; case JPEG_ERR_SOS_DATA: str = VM_STRING("bad scan segment"); break; case JPEG_ERR_SOF_DATA: str = VM_STRING("bad frame segment"); break; case JPEG_ERR_RST_DATA: str = VM_STRING("wrong restart marker"); break; default: str = VM_STRING("unknown code"); break; } return str; } // GetErrorStr()
void AddCodecTableHeader2CSVFile(vm_file *f_csv) { if(f_csv==NULL) return; vm_string_fprintf(f_csv,VM_STRING("Codec,Voice Activity Detection,Bitrate(bps),Audio file,Duration(sec),Encode(MHz),Decode(MHz),nChannels\n")); return; }
void vm_sys_info_get_time(vm_char *m_time, TimeFormat tf) { SYSTEMTIME SystemTime; /* check error(s) */ if (NULL == m_time) return; GetLocalTime(&SystemTime); switch (tf) { case HHMMSS: vm_string_sprintf(m_time, VM_STRING("%.2d:%.2d:%.2d"), SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond); break; case HHMM: vm_string_sprintf(m_time, VM_STRING("%.2d:%.2d"), SystemTime.wHour, SystemTime.wMinute); break; case HHMMSSMS1: vm_string_sprintf(m_time, VM_STRING("%.2d:%.2d:%.2d.%d"), SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMilliseconds / 100); break; case HHMMSSMS2: vm_string_sprintf(m_time, VM_STRING("%.2d:%.2d:%.2d.%d"), SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMilliseconds / 10); break; case HHMMSSMS3: vm_string_sprintf(m_time, VM_STRING("%.2d:%.2d:%.2d.%d"), SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMilliseconds); break; default: vm_string_sprintf(m_time, VM_STRING("%.2d:%.2d:%.2d"), SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond); break; } } /* void vm_sys_info_get_time(vm_char *m_time, TimeFormat tf) */
vm_status vm_sys_info_cpu_loading_avg(struct VM_SYSINFO_CPULOAD *dbuf, Ipp32u timeslice/* in msec */) { PDH_STATUS sts = ERROR_SUCCESS; HQUERY tmpq = 0; vm_status rtval = VM_NULL_PTR; vm_char scountername[MAX_COUNTER_NAME]; PDH_HCOUNTER cptr = NULL; BOOL isprepared = FALSE; DWORD t; PDH_FMT_COUNTERVALUE v; int i; /* we need 1 ms period to hold timeslice time correct */ timeBeginPeriod(ONEMILLISECOND); do { #ifdef VM_CHECK_CPU_CHECK_TIMESLICE if (timeslice < 10) { rtval = VM_NOT_ENOUGH_DATA; break; } #endif if (dbuf == NULL) { dbuf = (struct VM_SYSINFO_CPULOAD *)malloc(sizeof(struct VM_SYSINFO_CPULOAD)); if (dbuf != NULL) dbuf[0].cpudes = NULL; } if (dbuf == NULL) break; if (dbuf[0].ncpu == 0) break; if (dbuf[0].cpudes == NULL) { dbuf[0].ncpu = vm_sys_info_get_cpu_num(); dbuf[0].cpudes = (struct VM_SYSINFO_CPULOAD_ENTRY *)(malloc(sizeof(struct VM_SYSINFO_CPULOAD_ENTRY)*(dbuf[0].ncpu+1))); } if (dbuf[0].cpudes == NULL) break; /* if cpu description buffer was not NULL I hope it will be enough to hold all information about all the CPUs */ tmpq = dbuf[0].CpuLoadQuery; if ( tmpq == 0) {/* no more performance handle created yet */ PdhOpenQuery(NULL, 0, &tmpq); if (tmpq == 0) break; dbuf[0].CpuLoadQuery = tmpq; } if (dbuf[0].CpuPerfCounters[0] != 0) isprepared = TRUE; /* performance monitor already prepared */ if (dbuf[0].CpuLoadQuery == 0) break; if (!isprepared) { /* create buffers for counters */ rtval = VM_OK; for( i = 0; i < MAX_PERF_PARAMETERS; ++i ) { dbuf[0].CpuPerfCounters[i] = NULL; dbuf[0].CpuPerfCounters[i] = (PDH_HCOUNTER *)malloc((dbuf[0].ncpu+1/*for overall counter*/)*sizeof(PDH_HCOUNTER)); if (dbuf[0].CpuPerfCounters[i] == NULL) { rtval = VM_OPERATION_FAILED; break; } } if (rtval != VM_OK) { for( i = 0; i < MAX_PERF_PARAMETERS; ++i ) if (dbuf[0].CpuPerfCounters[i] != NULL) { free(dbuf[0].CpuPerfCounters[i]); dbuf[0].CpuPerfCounters[i] = NULL; } break; } /* add performance counters */ /* user time */ vm_string_strcpy(scountername, VM_STRING("\\Processor ")); for( i = 0; i < dbuf[0].ncpu; ++i ) { vm_string_sprintf(&scountername[10], VM_STRING("(%d)\\%% User Time"), i); cptr = dbuf[0].CpuPerfCounters[0] + i*sizeof(PDH_HCOUNTER); sts = PdhAddCounter(dbuf[0].CpuLoadQuery, scountername, 0, cptr); vm_string_sprintf(&scountername[10], VM_STRING("(%d)\\%% Privileged Time"), i); cptr = dbuf[0].CpuPerfCounters[1] + i*sizeof(PDH_HCOUNTER); sts = PdhAddCounter(dbuf[0].CpuLoadQuery, scountername, 0, cptr); vm_string_sprintf(&scountername[10], VM_STRING("(%d)\\%% Interrupt Time"), i); cptr = dbuf[0].CpuPerfCounters[2] + i*sizeof(PDH_HCOUNTER); sts = PdhAddCounter(dbuf[0].CpuLoadQuery, scountername, 0, cptr); } } vm_time_sleep(timeslice); if ((sts = PdhCollectQueryData(dbuf[0].CpuLoadQuery)) != ERROR_SUCCESS) break; /* fill in output data structure */ for(i = 0; i < dbuf[0].ncpu; ++i) { sts = PdhGetFormattedCounterValue(dbuf[0].CpuPerfCounters[0][i], PDH_FMT_LONG, &t, &v); dbuf[0].cpudes[i].usrload = AVGFLOAT(v.longValue); sts = PdhGetFormattedCounterValue(dbuf[0].CpuPerfCounters[1][i], PDH_FMT_LONG, &t, &v); dbuf[0].cpudes[i].sysload = AVGFLOAT(v.longValue); dbuf[0].cpudes[i].idleload = (float)1. - dbuf[0].cpudes[i].usrload - dbuf[0].cpudes[i].sysload; dbuf[0].cpudes[i].idleload = (dbuf[0].cpudes[i].idleload < 0) ? 0 : dbuf[0].cpudes[i].idleload; sts = PdhGetFormattedCounterValue(dbuf[0].CpuPerfCounters[2][i], PDH_FMT_LONG, &t, &v); dbuf[0].cpudes[i].irqsrvload = AVGFLOAT(v.longValue); /* clear other parameters for each processor */ dbuf[0].cpudes[i].iowaitsload = dbuf[0].cpudes[i].softirqsrvload = 0.; dbuf[0].cpudes[i].usrniceload = dbuf[0].cpudes[i].vmstalled = 0.; } rtval = VM_OK; } while (0); if ((NULL != dbuf) && (ticks_on_avg_call != 0)) dbuf[0].tickspassed = (vm_tick)((vm_time_get_tick() - ticks_on_avg_call)*1000/vm_time_get_frequency()); ticks_on_avg_call = vm_time_get_tick(); timeEndPeriod(ONEMILLISECOND); return rtval; }
Ipp32s WINAPI WinMain( HINSTANCE hinst, HINSTANCE xxx, LPWSTR lpCmdLine, Ipp32s yyy ) { Ipp8s line[WINCE_CMDLINE_SIZE]; /* to copy command line */ Ipp8s* argvv[WINCE_NCMD_PARAMS]; Ipp8s** argv=argvv; wchar_t wexename[WINCE_EXENAME_SIZE]; Ipp8s exename[WINCE_EXENAME_SIZE]; Ipp8s cmdline[WINCE_CMDLINE_SIZE]; /* simulate argc and argv parameters */ Ipp32s argc; #else /*Other OS*/ Ipp32s main(Ipp32s argc, Ipp8s *argv[]) { #endif /*_WIN32_WCE*/ CommandLineParams clParams; USC_EC_Params ecParams; USC_Status USCStatus; MeasureIt measure; FILE *fp_rin = NULL; FILE *fp_sin = NULL; FILE *fp_sout = NULL; FILE *f_log = NULL; vm_file *f_csv = NULL; /* csv File */ Ipp8u *in1_buff_cur, *in2_buff_cur, *out_buff_cur; Ipp8u *in1_buff=NULL, *in2_buff=NULL, *out_buff=NULL; Ipp32s flen, in_len, lCallResult; Ipp32s i, frameNum, tailNum; Ipp32s usage=0, n_repeat=1; double speech_sec; Ipp32s delay=0; Ipp8s* appName=argv[0]; Ipp8s pString[MAX_LEN_STRING]; const IppLibraryVersion *ver = NULL; #if defined( _WIN32_WCE ) GetModuleFileName( hinst, wexename, WINCE_EXENAME_SIZE ); sprintf( exename, "%ls", wexename ); sprintf( cmdline, "%ls", lpCmdLine ); argc = parseCmndLine( exename, cmdline, line, WINCE_CMDLINE_SIZE, argv, WINCE_NCMD_PARAMS ); #endif ippStaticInit(); SetCommandLineByDefault(&clParams); strcpy(clParams.csvFileName, "ec_speed.csv"); usage = ReadCommandLine(&clParams, argc, argv); if(clParams.puttolog == 1) { if((f_log = fopen(clParams.logFileName, "a")) == NULL) return FOPEN_FAIL; } else f_log = NULL; if(usage) { if(clParams.enumerate == 1) { EnumerateStaticLinkedEC(f_log); if(f_log) fclose(f_log); return 0; } else { PrintUsage((const Ipp8s *)appName, f_log); return USAGE; } } lCallResult = LoadECByName((const Ipp8s *)clParams.ECName, &ecParams, f_log); if(lCallResult < 0) { sprintf(pString, "Cannot find %s echo canceller.\n", clParams.ECName); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return LOAD_EC_FAIL; } ecParams.pUSC_EC_Fxns->std.GetInfo((USC_Handle)NULL, &ecParams.pInfo); ecParams.objEC = NULL; ecParams.pBanks = NULL; ecParams.nBanks = 0; if((fp_rin = fopen(clParams.rinFileName,"rb")) == NULL) { sprintf(pString, "echo canceller: File %s [r-in] could not be open.\n", clParams.rinFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return FOPEN_FAIL; } if((fp_sin = fopen(clParams.sinFileName,"rb")) == NULL) { sprintf(pString, "echo canceller: File %s [s-in] could not be open.\n", clParams.sinFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return FOPEN_FAIL; } if((fp_sout = fopen(clParams.soutFileName,"wb")) == NULL) { sprintf(pString, "echo canceller: File %s [s-out] could not be open.\n", clParams.soutFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return FOPEN_FAIL; } if(clParams.puttocsv) { /* open the csv file */ if((f_csv = vm_file_open(clParams.csvFileName, "a")) == NULL) { sprintf(pString, "\nFile %s could not be open.\n", clParams.csvFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return FOPEN_FAIL; } } if(clParams.printSysInfo){ OutputInfoString(0, f_log,"The Intel(R) echo canceller conformant to ITU G167 and G168,\n"); ver = ippscGetLibVersion(); sprintf(pString, "The Intel(R) IPPSC library used: %d.%d.%d Build %d, name %s\n", ver->major,ver->minor,ver->majorBuild,ver->build,ver->Name); OutputInfoString(0, f_log, (const Ipp8s*)pString); ver = ippsGetLibVersion(); sprintf(pString, "The Intel(R) IPPSP library used: %d.%d.%d Build %d, name %s\n", ver->major,ver->minor,ver->majorBuild,ver->build,ver->Name); OutputInfoString(0, f_log, (const Ipp8s*)pString); } sprintf(pString, "Input rin file: %s\n", clParams.rinFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); sprintf(pString, "Input sin file: %s\n", clParams.sinFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); sprintf(pString, "Output sout file: %s\n", clParams.soutFileName); OutputInfoString(1, f_log, (const Ipp8s*)pString); switch(clParams.nlp) { case 0: sprintf(pString, "NLP disabled\n"); break; case 1: sprintf(pString, "NLP type 1 enabled\n"); break; default: sprintf(pString, "NLP type 2 enabled\n"); } switch(clParams.alg) { case EC_FULLBAND: ecParams.pInfo.params.algType = EC_FULLBAND; sprintf(pString, "mode : fullband \n"); break; case EC_SUBBAND: ecParams.pInfo.params.algType = EC_SUBBAND; sprintf(pString, "mode : subband \n"); break; case EC_AFFINESUBBAND: ecParams.pInfo.params.algType = EC_AFFINESUBBAND; sprintf(pString, "mode : subband affine projection \n"); break; case EC_FASTSUBBAND: ecParams.pInfo.params.algType = EC_FASTSUBBAND; sprintf(pString, "mode : fast subband \n"); break; default: return UNKNOWN_FORMAT; } OutputInfoString(1, f_log, (const Ipp8s*)pString); switch(clParams.adapt) { case 0: sprintf(pString, "adaptation : disable \n"); ecParams.pInfo.params.modes.adapt = AD_OFF; break; case 2: sprintf(pString, "adaptation : lite \n"); ecParams.pInfo.params.modes.adapt = AD_LITEADAPT; break; default: ecParams.pInfo.params.modes.adapt = AD_FULLADAPT; sprintf(pString, "adaptation : full \n"); } OutputInfoString(1, f_log, (const Ipp8s*)pString); sprintf(pString, "echo tail length : %d\n", clParams.tail); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(clParams.puttocsv) { if(clParams.printSysInfo){ sysInfoToCSV(f_csv); } } ecParams.pInfo.params.pcmType.sample_frequency = clParams.freq; ecParams.pInfo.params.pcmType.bitPerSample = 16; ecParams.pInfo.params.echotail = clParams.tail; ecParams.pInfo.params.modes.zeroCoeff = 1;///??? ecParams.pInfo.params.modes.nlp = clParams.nlp; ecParams.pInfo.params.modes.cng = clParams.cng; ecParams.pInfo.params.modes.td = 1; ecParams.pInfo.params.modes.ah = clParams.ah_mode; ecParams.pUSC_EC_Fxns->std.NumAlloc((const USC_EC_Option *)&ecParams.pInfo.params, &ecParams.nBanks); ecParams.pBanks = (USC_MemBank*)ippsMalloc_8u(sizeof(USC_MemBank)*ecParams.nBanks); if(!ecParams.pBanks) { sprintf(pString, "\nLow memory: %d bytes not allocated\n", (int)(sizeof(USC_MemBank)*ecParams.nBanks)); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(fp_rin) fclose(fp_rin); if(fp_sin) fclose(fp_sin); if(fp_sout) fclose(fp_sout); if(clParams.puttocsv) { if(f_csv) vm_file_fclose(f_csv); } if(f_log) fclose(f_log); return MEMORY_FAIL; } ecParams.pUSC_EC_Fxns->std.MemAlloc((const USC_EC_Option *)&ecParams.pInfo.params, ecParams.pBanks); for(i=0;i<ecParams.nBanks;i++) { ecParams.pBanks[i].pMem = (Ipp8s *)ippsMalloc_8u(ecParams.pBanks[i].nbytes);//375d60,377420 if(!ecParams.pBanks[i].pMem) { sprintf(pString, "\nLow memory: %d bytes not allocated\n", ecParams.pBanks[i].nbytes); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(ecParams.pBanks) ippsFree(ecParams.pBanks); if(fp_rin) fclose(fp_rin); if(fp_sin) fclose(fp_sin); if(fp_sout) fclose(fp_sout); if(clParams.puttocsv) { if(f_csv) vm_file_fclose(f_csv); } if(f_log) fclose(f_log); return MEMORY_FAIL; } } flen = PrepareInput(fp_rin, " receive-in input ", &in1_buff, f_log); in_len = PrepareInput(fp_sin, " send-in input ", &in2_buff, f_log); if(ecParams.pInfo.params.pcmType.sample_frequency == 8000){ /* 8 KHz */ delay = (Ipp32s) (clParams.fdelay * 8000 * 2/1000); }else{ /* 16 KHz */ delay = (Ipp32s) (clParams.fdelay * 16000 * 2/1000); } flen -= delay; if(flen < 0) flen = 0; if (flen < in_len) in_len = flen; out_buff=(Ipp8u*)ippsMalloc_8u(in_len);/* allocate output buffer */ if(!out_buff){ /* allocate output buffer */ sprintf(pString, "\nNo memory for buffering of %d output bytes", in_len); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return MEMORY_FAIL; } /* time stamp prior to threads creation, creation and running time may overlap. */ measure_start(&measure); n_repeat = clParams.nRepeat; while(n_repeat--) { USCStatus = ecParams.pUSC_EC_Fxns->std.Init((const USC_EC_Option *)&ecParams.pInfo.params, ecParams.pBanks, &ecParams.objEC); if(USCStatus!=USC_NoError) { OutputInfoString(1, f_log,"\nCan not initialize the EC object!"); if(ecParams.pBanks) ippsFree(ecParams.pBanks); if(fp_rin) fclose(fp_rin); if(fp_sin) fclose(fp_sin); if(fp_sout) fclose(fp_sout); if(clParams.puttocsv) { if(f_csv) vm_file_fclose(f_csv); } if(f_log) fclose(f_log); return ERROR_INIT; } ecParams.pUSC_EC_Fxns->std.GetInfo(ecParams.objEC, (USC_EC_Info *)&ecParams.pInfo); frameNum = in_len/ecParams.pInfo.params.framesize; tailNum = (in_len/sizeof(Ipp16s)) - (ecParams.pInfo.params.framesize/sizeof(Ipp16s))*frameNum; out_buff_cur = out_buff; in1_buff_cur = in1_buff; in2_buff_cur = in2_buff+ delay; /* shift forward the sin at delay */ for (i = 0; i < frameNum; i++) { ecParams.pUSC_EC_Fxns->CancelEcho(ecParams.objEC, (Ipp16s *)in2_buff_cur, (Ipp16s *)in1_buff_cur, (Ipp16s *)out_buff_cur);//4,6,9,11,14,19,21,26,29,31,34,36,39,41,44,46,49,51 in1_buff_cur += ecParams.pInfo.params.framesize; in2_buff_cur += ecParams.pInfo.params.framesize; out_buff_cur += ecParams.pInfo.params.framesize; } for (i = 0; i < tailNum; i++) { ippsZero_16s((Ipp16s *)out_buff_cur, tailNum); } } measure_end(&measure); if (PostProcessPCMstream((Ipp8s *)out_buff, in_len)) { sprintf(pString, "No memory for load of %d bytes convert from linear PCM to special pack value.",in_len); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(f_log) fclose(f_log); return MEMORY_FAIL; } /* Write output PCM to the output file */ fwrite(out_buff, 1, in_len, fp_sout); for(i=0; i<ecParams.nBanks;i++){ if(ecParams.pBanks[i].pMem) ippsFree(ecParams.pBanks[i].pMem); ecParams.pBanks[i].pMem = NULL; } if(ecParams.pBanks) { ippsFree(ecParams.pBanks); ecParams.pBanks = NULL; } ippsFree(out_buff); speech_sec = (in_len / 2 * clParams.nRepeat)/(double)ecParams.pInfo.params.pcmType.sample_frequency; measure_output(f_log, &measure, speech_sec); sprintf(pString, "Done %d samples of %d Hz PCM wave file (%g sec)\n", (in_len>>1) * clParams.nRepeat, ecParams.pInfo.params.pcmType.sample_frequency, speech_sec); OutputInfoString(1, f_log, (const Ipp8s*)pString); if(clParams.puttocsv) { Ipp8s* rinFile; Ipp8s* sinFile; if ((rinFile = strrchr(clParams.rinFileName, '/')) != NULL) { rinFile += 1; } else if ((rinFile = strrchr(clParams.rinFileName, '\\')) != NULL) { rinFile += 1; } else rinFile = clParams.rinFileName; if ((sinFile = strrchr(clParams.sinFileName, '/')) != NULL) { sinFile += 1; } else if ((sinFile = strrchr(clParams.sinFileName, '\\')) != NULL) { sinFile += 1; } else sinFile = clParams.sinFileName; i=sprintf(pString, clParams.ECName); i += sprintf(pString + i,","); switch(clParams.alg) { case EC_FULLBAND: i += sprintf(pString + i,"fullband,"); break; case EC_SUBBAND: i += sprintf(pString + i,"subband,"); break; case EC_FASTSUBBAND: i += sprintf(pString + i,"fast subband,"); break; default: i += sprintf(pString + i,"subband,"); } switch(clParams.adapt) { case 2: i += sprintf(pString + i,"lite,"); break; default: i += sprintf(pString + i,"full,"); } i += sprintf(pString + i,"%d,",clParams.tail); i += sprintf(pString + i,"%d,%s,%s,%4.2f,%4.2f", ecParams.pInfo.params.pcmType.sample_frequency, rinFile, sinFile, speech_sec, measure.speed_in_mhz); vm_string_fprintf(f_csv,VM_STRING("%s\n"),pString); vm_file_fclose(f_csv); } ippsFree(in1_buff); ippsFree(in2_buff); fclose(fp_rin); fclose(fp_sin); fclose(fp_sout); OutputInfoString(1, f_log,"Completed !\n"); if(f_log) fclose(f_log); return 0; }
void vm_sys_info_get_os_name(vm_char *os_name) { OSVERSIONINFO osvi; BOOL bOsVersionInfo; /* check error(s) */ if (NULL == os_name) return; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); bOsVersionInfo = GetVersionEx((OSVERSIONINFO *) &osvi); if (!bOsVersionInfo) { osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (!GetVersionEx((OSVERSIONINFO *) &osvi)) { vm_string_sprintf(os_name, VM_STRING("Unknown")); return; } } switch (osvi.dwPlatformId) { case 2: /* test for the specific product family. */ if ((5 == osvi.dwMajorVersion) && (2 == osvi.dwMinorVersion)) vm_string_sprintf(os_name, VM_STRING("Win2003")); if ((6 == osvi.dwMajorVersion) && (0 == osvi.dwMinorVersion)) vm_string_sprintf(os_name, VM_STRING("WinVista")); if ((5 == osvi.dwMajorVersion) && (1 == osvi.dwMinorVersion)) vm_string_sprintf(os_name, VM_STRING("WinXP")); if ((5 == osvi.dwMajorVersion) && (0 == osvi.dwMinorVersion)) vm_string_sprintf(os_name, VM_STRING("Win2000")); if (4 >= osvi.dwMajorVersion) vm_string_sprintf(os_name, VM_STRING("WinNT")); break; /* test for the Windows 95 product family. */ case 1: if ((4 == osvi.dwMajorVersion) && (0 == osvi.dwMinorVersion)) { vm_string_sprintf(os_name, VM_STRING("Win95")); if (('C' == osvi.szCSDVersion[1]) || ('B' == osvi.szCSDVersion[1])) vm_string_strcat(os_name, VM_STRING("OSR2" )); } if ((4 == osvi.dwMajorVersion) && (10 == osvi.dwMinorVersion)) { vm_string_sprintf(os_name, VM_STRING("Win98")); if ('A' == osvi.szCSDVersion[1]) vm_string_strcat(os_name, VM_STRING("SE")); } if ((4 == osvi.dwMajorVersion) && (90 == osvi.dwMinorVersion)) { vm_string_sprintf(os_name,VM_STRING("WinME")); } break; case 3: /* get platform string */ /* SystemParametersInfo(257, MAX_PATH, os_name, 0); */ if ((4 == osvi.dwMajorVersion) && (20 == osvi.dwMinorVersion)) { vm_string_sprintf(os_name, VM_STRING("PocketPC 2003")); } if ((4 == osvi.dwMajorVersion) && (21 == osvi.dwMinorVersion)) { vm_string_sprintf(os_name, VM_STRING("WinMobile2003SE")); } if ((5 == osvi.dwMajorVersion) && (0 == osvi.dwMinorVersion)) { vm_string_sprintf(os_name, VM_STRING("WinCE 5.0")); } break; /* Something else */ default: vm_string_sprintf(os_name, VM_STRING("Win...")); break; } } /* void vm_sys_info_get_os_name(vm_char *os_name) */