int main(int argc,char *argv[])
{
/* Reads command line arguments into the CommandLineArgs struct.
In the absence of command line arguments it sets some defaults */
if (ReadCommandLine(argc,argv,&CommandLineArgs)) return 1;
/* Reads in SFT directory for filenames and total number of files */
fprintf(stderr,"\n");
fprintf(stderr,"Reading SFT directory: ");
if (ReadSFTDirectory(CommandLineArgs)) return 2;
fprintf(stderr," Done\n");
fprintf(stderr,"Computing power spectral desnsity: ");
if (ComputePSD(CommandLineArgs)) return 2;
fprintf(stderr," Done\n");
/* Free memory*/
fprintf(stderr,"Freeing allocated memory: ");
if (Freemem()) return 8;
fprintf(stderr," Done\n \n");
return 0;
}
static void CreateProgramName() {
const ssize_t nr = ReadCommandLine(s_cmdline, sizeof(s_cmdline) - 1, false);
if (nr > 0) {
s_cmdline[nr] = '\0';
s_program_name = s_cmdline;
}
}
void PProfService::cmdline(::google::protobuf::RpcController* controller_base,
const ::brpc::ProfileRequest* /*request*/,
::brpc::ProfileResponse* /*response*/,
::google::protobuf::Closure* done) {
ClosureGuard done_guard(done);
Controller* cntl = static_cast<Controller*>(controller_base);
cntl->http_response().set_content_type("text/plain" /*FIXME*/);
char buf[1024]; // should be enough?
const ssize_t nr = ReadCommandLine(buf, sizeof(buf), true);
if (nr < 0) {
cntl->SetFailed(ENOENT, "Fail to read /proc/self/cmdline");
return;
}
cntl->response_attachment().append(buf, nr);
}
static Status wutil_Init()
{
InitLocks();
ForciblyLoadUser32Dll();
EnableLowFragmentationHeap();
ReadCommandLine();
GetDirectories();
ImportWow64Functions();
DetectWow64();
return INFO::OK;
}
bool
MyApp::OnInit()
{
m_frame = NULL;
wxLogDebug(_T("Starting App"));
SetReturnCode(0);
m_isTimerRunning = false;
// Seed random number generator (for grid scrambling)
srand( time(NULL) );
SetupConfig();
SetupPrinting();
return ReadCommandLine();
}
void Debugger::RunDebuggerShell() {
if (IsDebuggerRunning()) {
if (steps_ > 0) {
// Finish stepping first.
--steps_;
return;
}
printf("Next: ");
PrintInstructions(pc());
bool done = false;
while (!done) {
char buffer[kMaxDebugShellLine];
char* line = ReadCommandLine("vixl> ", buffer, kMaxDebugShellLine);
if (line == NULL) continue; // An error occurred.
DebugCommand* command = DebugCommand::Parse(line);
if (command != NULL) {
last_command_ = command;
}
if (last_command_ != NULL) {
done = last_command_->Run(this);
} else {
printf("No previous command to run!\n");
}
}
if ((debug_parameters_ & DBG_BREAK) != 0) {
// The break request has now been handled, move to next instruction.
debug_parameters_ &= ~DBG_BREAK;
increment_pc();
}
}
}
int main( int argc, char *argv[] )
{
/* parameters of strings */
double Gamma = LOOP_RAD_POWER; /* power radiated by loops */
double c = CUSPS_PER_LOOP; /* cusps per loop */
double p,epsilon,f,Gmu,alpha;
double gammaAverage = 0, gammaMin = 0, gammaMax =0;
char filename[FILENAME_MAX];
FILE *fp;
int i,j,k,l;
/* read the command line */
if (ReadCommandLine(argc,argv,&CLA)) return 1;
f=CLA.f;
/* read efficiency function */
if (ReadEfficiencyFile(CLA)) return 2;
snprintf( filename, sizeof( filename ), "gamma.dat");
fp = fopen( filename, "w" );
fprintf( fp,"%% p n epsilon Gmu gammaAverage gammaMin gammaMax\n");
for ( i = 0; i < CLA.nepsilon; i++ )
{
epsilon=pow(10.0,CLA.logepsilonstart+i*(CLA.logepsilonend-CLA.logepsilonstart)/(CLA.nepsilon-1));
for ( j = 0; j < CLA.nGmu; j++ )
{
Gmu=pow(10.0,CLA.logGmustart+j*(CLA.logGmuend-CLA.logGmustart)/(CLA.nGmu-1));
alpha = epsilon * pow( Gamma * Gmu, CLA.n );
/* find the z's corresponding to those A's */
if(findzofA(Gmu, alpha)) return 3;
/* compute the rate derivative at those z's */
if(finddRdz(Gmu, alpha, f, Gamma)) return 4;
for ( k = 0; k < CLA.np; k++ )
{
p=pow(10.0, CLA.logpstart+k*(CLA.logpend-CLA.logpstart)/(CLA.np));
fprintf(stdout,"%%Computing effective rate for Gmu=%e, epsilon=%e, p=%e\n ",Gmu, epsilon, p);
/* Compute the rate of bursts */
gammaAverage=0.0;
gammaMin = 0.0;
gammaMax = 0.0;
for (l = 0; l < Namp-1; l++)
{
Dlnz = (-log(zofA[l+1])+log(zofA[l]));
gammaAverage += eff[l] * zofA[l] * dRdz[l] * Dlnz;
gammaMin += fmaxf((eff[l]-Deff[l]),0.0) * zofA[l] * dRdz[l] * Dlnz;
gammaMax += fminf((eff[l]+Deff[l]),1.0) * zofA[l] * dRdz[l] * Dlnz;
}
gammaAverage *= c/p;
gammaMin *= c/p;
gammaMax *= c/p;
fprintf( fp,"%e %e %e %e %e %e %e\n", p,CLA.n,epsilon,Gmu,gammaAverage,gammaMin,gammaMax);
}
}
}
fclose( fp );
free(amp);
free(lnamp);
free(eff);
free(Deff);
free(zofA);
free(dzdA);
free(dRdz);
return 0;
}
int main(int argc,char *argv[])
{
int i=0,t1,t2,k;
FILE *fsft1,*fsft2;
size_t ecode;
/* Reads command line arguments into the CommandLineArgs struct.
In the absence of command line arguments it sets some defaults */
if (ReadCommandLine(argc,argv,&CommandLineArgs)) return 1;
/* Sets global variables and sticks them into the GlobalVariables struct */
if (CreateFileList(CommandLineArgs)) return 2;
if (AllocateMem(CommandLineArgs)) return 3;
while(i<filenumber)
{
fsft1=fopen(filelist[i],"r");
/* read in the header from the file */
ecode=fread((void*)&header,sizeof(header),1,fsft1);
if (ecode!=1)
{
fprintf(stderr,"No header in data file %s\n",filelist[i]);
return 1;
}
/* check that data is correct endian order */
if (header.endian!=1.0)
{
fprintf(stderr,"First object in file %s is not (double)1.0!\n",filelist[i]);
fprintf(stderr,"It could be a file format error (big/little\n");
fprintf(stderr,"endian) or the file might be corrupted\n\n");
return 2;
}
fclose(fsft1);
t1=header.gps_sec;
timestamps.gpsSeconds=header.gps_sec;
timestamps.gpsNanoSeconds=header.gps_nsec;
fsft2=fopen(filelist[i+CommandLineArgs.number-1],"r");
/* read in the header from the file */
ecode=fread((void*)&header,sizeof(header),1,fsft2);
if (ecode!=1)
{
fprintf(stderr,"No header in data file %s\n",filelist[i]);
return 1;
}
/* check that data is correct endian order */
if (header.endian!=1.0)
{
fprintf(stderr,"First object in file %s is not (double)1.0!\n",filelist[i]);
fprintf(stderr,"It could be a file format error (big/little\n");
fprintf(stderr,"endian) or the file might be corrupted\n\n");
return 2;
}
fclose(fsft2);
t2=header.gps_sec+sTsft;
/* if( (int)((t2-t1)/lTsft +0.5) == 1) */
/* { */
fprintf(stdout,"Combining SFTs %d thru %d\n",i,i+CommandLineArgs.number-1);
/* Have CommandLineArgs.number consecutive SFTs */
if (ReadSFTs(CommandLineArgs,i)) return 3;
if (CSFTs(CommandLineArgs)) return 4;
i += CommandLineArgs.number;
/* } */
/* else i++; */
}
/* Free the SFT data */
for (k=0;k<CommandLineArgs.number;k++)
{
LALFree(SFTData[k]->fft->data->data);
LALFree(SFTData[k]->fft->data);
LALFree(SFTData[k]->fft);
LALFree(SFTData[k]);
}
LALFree(SFTData);
LALFree(sinVal);
LALFree(cosVal);
LALCheckMemoryLeaks();
return 0;
}
int main(int argc,char *argv[])
{
LALFrStreamPos pos;
int i,j,k;
if (ReadCommandLine(argc,argv,&CommandLineArgs)) return 1;
if (ReadFiles(CommandLineArgs)) return 3;
if (GetChannelNames(CommandLineArgs)) return 4;
for(i=0;i<numsegs;i++)
{
for(j=0;j<SL[i].nseg;j++)
{
REAL4 magexc, magdarm, magasq;
REAL8 t=SL[i].tgps+j*SL[i].seglength;
FloatToTime(&epoch, &t);
LALFrSeek(&status,&epoch,framestream);
LALFrGetPos(&status,&pos,framestream);
LALFrGetREAL4TimeSeries(&status,&exc,&chanin_exc,framestream);
LALFrSetPos(&status,&pos,framestream);
LALFrGetREAL4TimeSeries(&status,&darm,&chanin_darm,framestream);
LALFrSetPos(&status,&pos,framestream);
LALFrGetREAL4TimeSeries(&status,&asq,&chanin_asq,framestream);
LALFrSetPos(&status,&pos,framestream);
/*Windowing*/
for(k=0;k<(INT4)(SL[i].seglength/asq.deltaT +0.5);k++)
{
asq.data->data[k] *= 2.0*asqwin->data[k];
}
for(k=0;k<(INT4)(SL[i].seglength/darm.deltaT +0.5);k++)
{
darm.data->data[k] *= 2.0*darmwin->data[k];
}
for(k=0;k<(INT4)(SL[i].seglength/exc.deltaT +0.5);k++)
{
exc.data->data[k] *= 2.0*excwin->data[k];
}
/* set params to call LALComputeCalibrationFactors */
params.darmCtrl = &darm;
params.asQ = &asq;
params.exc = &exc;
params.lineFrequency = CommandLineArgs.f;
params.outputMatrix = CommandLineArgs.k;
params.actuationFactor.re = Af0.re/4000.0; /*ACHTUNG: HARDWIRED !!*/
params.actuationFactor.im = Af0.im/4000.0; /*ACHTUNG: HARDWIRED !!*/
params.responseFactor = Rf0;
params.sensingFactor = Cf0;
LALComputeCalibrationFactors(&status,&factors,¶ms);
magexc=sqrt(factors.exc.re*factors.exc.re+factors.exc.im*factors.exc.im)*2/SL[i].seglength;
magasq=sqrt(factors.asq.re*factors.asq.re+factors.asq.im*factors.asq.im)*2/SL[i].seglength;
magdarm=sqrt(factors.darm.re*factors.darm.re+factors.darm.im*factors.darm.im)*2/SL[i].seglength;
fprintf(stdout,"%20.15f %20.15f %20.15f %20.15f %20.15f %20.15f %20.15f %20.15f\n",t,
factors.alpha.re,factors.alpha.im,factors.alphabeta.re,
factors.alphabeta.im,magexc,magdarm,magasq);
fflush(stdout);
}
}
if(FreeMem()) return 4;
return 0;
}
BOOL DoCgiWork(int & argc, LPTSTR* &argv, Buf &lpszMessage,
Buf & lpszCgiSuccessUrl, Buf &lpszCgiFailureUrl,
Buf & lpszFirstReceivedData, Buf &lpszOtherHeader)
{
Buf lpszMethod;
Buf lpszPost;
Buf lpszParamCgi;
Buf lpszQueryString;
Buf lpszPathTranslated;
Buf lpszCmdBlat;
lpszMessage.Clear();
lpszFirstReceivedData.Clear();
lpszOtherHeader.Clear();
GetEnv(__T("REQUEST_METHOD"), lpszMethod);
lpszPost=__T("");
if ( lstrcmpi(lpszMethod.Get(),__T("POST")) == 0)
ReadPostData(lpszPost);
GetEnv(__T("QUERY_STRING"), lpszQueryString);
// lpszParamCgi.AllocExact(lpszQueryString.Length()+lpszPost.Length()+10);
lpszParamCgi.Add( lpszQueryString );
if (lpszQueryString.Length() && lpszPost.Length())
lpszParamCgi.Add( __T('&') );
lpszParamCgi.Add( lpszPost );
GetEnv(__T("PATH_TRANSLATED"), lpszPathTranslated);
BuildMessageAndCmdLine(lpszParamCgi,lpszPathTranslated.Get(),lpszCmdBlat,lpszMessage);
SearchVar(lpszParamCgi, __T("BLAT_SUCCESS"), TRUE, lpszCgiSuccessUrl);
SearchVar(lpszParamCgi, __T("BLAT_FAILURE"), TRUE, lpszCgiFailureUrl);
// now replace %__% by var
DWORD dwPos = 0;
DWORD dwLineLen = (DWORD)lpszCmdBlat.Length();
while ( dwPos < dwLineLen ) {
if ( *(lpszCmdBlat.Get()+dwPos) == __T('%') ) {
Buf lpVarNameForSearch;
Buf lpContentVar;
DWORD dwEnd;
dwEnd = (SearchNextPercent(lpszCmdBlat.Get()+dwPos+1));
if ( *(lpszCmdBlat.Get()+dwPos+1+dwEnd) == __T('\0') ) {
lpContentVar.Free();
break;
}
lpVarNameForSearch.Alloc(dwEnd+0x10);
lpVarNameForSearch.Clear();
memcpy(lpVarNameForSearch.Get(),lpszCmdBlat.Get()+dwPos+1,dwEnd*sizeof(_TCHAR));
lpVarNameForSearch.SetLength(dwEnd);
*lpVarNameForSearch.GetTail() = __T('\0');
SearchVar(lpszParamCgi, lpVarNameForSearch.Get(), TRUE, lpContentVar);
if ( lpContentVar.Length() ) {
DWORD dwLenContentVar;
dwLenContentVar = (DWORD)lpContentVar.Length();
lpszCmdBlat.Alloc(dwLineLen+dwLenContentVar+0x10);
memmove(lpszCmdBlat.Get()+dwPos+dwLenContentVar,lpszCmdBlat.Get()+dwPos+dwEnd+2,(dwLineLen-(dwPos+dwEnd+1))*sizeof(_TCHAR));
memcpy(lpszCmdBlat.Get()+dwPos,lpContentVar.Get(),dwLenContentVar*sizeof(_TCHAR));
lpszCmdBlat.SetLength();
dwLineLen = (DWORD)lpszCmdBlat.Length();
dwPos += dwLenContentVar;
} else
dwPos += dwEnd + 1;
lpVarNameForSearch.Free();
lpContentVar.Free();
} else
dwPos++;
}
ReadCommandLine(lpszCmdBlat.Get(),argc,argv);
lpszCmdBlat.Clear();
lpszParamCgi.Clear();
//LPTSTR lpszRemoteHost=GetEnv(__T("REMOTE_HOST"));
Buf lpszRemoteAddr; GetEnv(__T("REMOTE_ADDR"), lpszRemoteAddr);
Buf lpszServerName; GetEnv(__T("SERVER_NAME"), lpszServerName);
Buf lpszHttpVia; GetEnv(__T("HTTP_VIA"), lpszHttpVia);
Buf lpszHttpForwarded; GetEnv(__T("HTTP_FORWARDED"), lpszHttpForwarded);
Buf lpszHttpForwardedFor; GetEnv(__T("HTTP_X_FORWARDED_FOR"), lpszHttpForwardedFor);
Buf lpszHttpUserAgent; GetEnv(__T("HTTP_USER_AGENT"), lpszHttpUserAgent);
Buf lpszHttpReferer; GetEnv(__T("HTTP_REFERER"), lpszHttpReferer);
_TCHAR tmpBuf[0x2000];
if ( *lpszHttpUserAgent.Get() ) {
_stprintf(tmpBuf, __T("X-Web-Browser: Send using %s\r\n"), lpszHttpUserAgent.Get());
lpszOtherHeader.Add(tmpBuf);
}
if ( *lpszHttpForwarded.Get() ) {
_stprintf(tmpBuf, __T("X-Forwarded: %s\r\n"), lpszHttpForwarded.Get());
lpszOtherHeader.Add(tmpBuf);
}
if ( *lpszHttpForwardedFor.Get() ) {
_stprintf(tmpBuf, __T("X-X-Forwarded-For: %s\r\n"), lpszHttpForwardedFor.Get());
lpszOtherHeader.Add(tmpBuf);
}
if ( *lpszHttpVia.Get() ) {
_stprintf(tmpBuf, __T("X-Via: %s\r\n"), lpszHttpVia.Get());
lpszOtherHeader.Add(tmpBuf);
}
if ( *lpszHttpReferer.Get() ) {
_stprintf(tmpBuf, __T("X-Referer: %s\r\n"), lpszHttpReferer.Get());
lpszOtherHeader.Add(tmpBuf);
}
_stprintf(tmpBuf, __T("Received: from %s by %s with HTTP; "),
lpszRemoteAddr.Get(), lpszServerName.Get());
lpszFirstReceivedData.Add(tmpBuf);
lpszRemoteAddr.Free();
lpszServerName.Free();
lpszHttpVia.Free();
lpszHttpForwarded.Free();
lpszHttpForwardedFor.Free();
lpszHttpUserAgent.Free();
lpszHttpReferer.Free();
lpszMethod.Free();
lpszPost.Free();
lpszParamCgi.Free();
lpszQueryString.Free();
lpszPathTranslated.Free();
lpszCmdBlat.Free();
return TRUE;
}
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;
}
int main(int argc, char **argv)
{
int arg, len;
char *output_filename;
int output_file_found = 0;
Options options;
options.shrink = 1;
options.rotate = False;
options.compress = True;
memset(&b.name, 0, MAX_BITMAPNAME);
/* Parse options */
for (arg = 1; arg < argc; arg++)
{
len = strlen(argv[arg]);
if (len == 0)
break;
// Look for command file
if (argv[arg][0] == '@')
{
CommandFileLoad(argv[arg] + 1, &argc, &argv, arg);
arg--; // Need to reparse this argument next time through; it's been changed
continue;
}
if (argv[arg][0] != '-')
break;
if (len < 2)
{
printf("Ignoring unknown option -\n");
continue;
}
switch(argv[arg][1])
{
case 'o':
arg++;
if (arg >= argc)
{
printf("Missing output filename\n");
break;
}
output_filename = argv[arg];
output_file_found = 1;
break;
case 'n':
arg++;
if (arg >= argc)
{
printf("Missing bitmap name\n");
break;
}
strncpy(b.name, argv[arg], MAX_BITMAPNAME);
b.name[MAX_BITMAPNAME - 1] = 0;
break;
case 's':
arg++;
if (arg >= argc)
{
printf("Missing shrink factor; assuming 1\n");
break;
}
options.shrink = atoi(argv[arg]);
if (options.shrink == 0)
{
printf("Illegal shrink factor value %d; assuming 1\n", options.shrink);
options.shrink = 1;
}
break;
case 'r':
options.rotate = True;
break;
case 'x':
options.compress = False;
break;
case '?':
Usage();
exit(0);
default:
printf("Ignoring unknown option %c\n", argv[arg][1]);
}
}
if (!output_file_found)
Error("No output file specified");
if (arg >= argc)
Error("Missing bitmap description list");
ReadCommandLine(argc - arg, argv + arg, &options);
if (!VerifyArguments(&b, &options))
exit(1);
WrapInit();
if (!WriteBGFFile(&b, &options, output_filename))
Error("Error writing output file");
WrapShutdown();
return 0;
}
