void g729_init_lib(){
#ifdef IPPCORE_STATIC_INIT
ippStaticInit();
#endif
apiG729Decoder_Alloc(G729A_CODEC, &decoder_size);
apiG729Encoder_Alloc(G729A_CODEC, &encoder_size);
apiG729Codec_ScratchMemoryAlloc(&coder_size_scratch);
}
int main(int argc, char* argv[])
{
int r;
ippStaticInit();
QApplication app(argc, argv);
MainWindow mw;
r = mw.Init();
if(0 != r)
return -1;
mw.show();
return app.exec();
} // main()
OsStatus MpeIPPG729::initEncode(void)
{
int lCallResult;
ippStaticInit();
strcpy((char*)codec->codecName, "IPP_G729A");
codec->lIsVad = 1;
// Load codec by name from command line
lCallResult = LoadUSCCodecByName(codec, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
// Get USC codec params
lCallResult = USCCodecAllocInfo(&codec->uscParams, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
lCallResult = USCCodecGetInfo(&codec->uscParams, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
// Get its supported format details
lCallResult = GetUSCCodecParamsByFormat(codec, BY_NAME, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
// Set params for encode
USC_PCMType streamType;
streamType.bitPerSample = getInfo()->getNumBitsPerSample();
streamType.nChannels = getInfo()->getNumChannels();
streamType.sample_frequency = getInfo()->getSamplingRate();
lCallResult = SetUSCEncoderPCMType(&codec->uscParams, LINEAR_PCM, &streamType, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
// instead of SetUSCEncoderParams(...)
codec->uscParams.pInfo->params.direction = USC_ENCODE;
codec->uscParams.pInfo->params.law = 0;
codec->uscParams.pInfo->params.modes.vad = ms_bEnableVAD ? 1 : 0;
// Alloc memory for the codec
lCallResult = USCCodecAlloc(&codec->uscParams, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
// Init decoder
lCallResult = USCEncoderInit(&codec->uscParams, NULL, NULL);
if (lCallResult < 0)
{
return OS_FAILED;
}
// Allocate memory for the output buffer. Size of output buffer is equal
// to the size of 1 frame
inputBuffer =
(Ipp8s *)ippsMalloc_8s(codec->uscParams.pInfo->params.framesize);
outputBuffer =
(Ipp8u *)ippsMalloc_8u(codec->uscParams.pInfo->maxbitsize + 10);
return OS_SUCCESS;
}
int seti_analyze (ANALYSIS_STATE& state) {
sah_complex* DataIn = state.savedWUData;
int NumDataPoints = state.npoints;
sah_complex* ChirpedData = NULL;
sah_complex* WorkData = NULL;
float* PowerSpectrum = NULL;
float* tPowerSpectrum; // Transposed power spectra if used.
float* AutoCorrelation = NULL;
use_transposed_pot= (!notranspose_flag) &&
((app_init_data.host_info.m_nbytes != 0) &&
(app_init_data.host_info.m_nbytes >= (double)(96*1024*1024)));
int num_cfft = 0;
float chirprate;
int last_chirp_ind = - 1 << 20, chirprateind;
double progress_diff, progress_in_cfft, cputime0=0;
int retval=0;
if (swi.analysis_cfg.credit_rate != 0) LOAD_STORE_ADJUSTMENT=swi.analysis_cfg.credit_rate;
#ifndef DEBUG
int icfft;
#endif
int NumFfts, ifft, fftlen;
int CurrentSub;
int FftNum, need_transpose;
unsigned long bitfield=swi.analysis_cfg.analysis_fft_lengths;
unsigned long FftLen;
unsigned long ac_fft_len=swi.analysis_cfg.autocorr_fftlen;
#ifdef USE_IPP
IppsFFTSpec_C_32fc* FftSpec[MAX_NUM_FFTS];
int BufSize;
ippStaticInit(); // initialization of IPP library
#elif defined(USE_FFTWF)
// plan space for fftw
fftwf_plan analysis_plans[MAX_NUM_FFTS];
fftwf_plan autocorr_plan;
#else
// fields need by the ooura fft logic
int * BitRevTab[MAX_NUM_FFTS];
float * CoeffTab[MAX_NUM_FFTS];
#endif
// Allocate data array and work area arrays.
ChirpedData = state.data;
PowerSpectrum = (float*) calloc_a(NumDataPoints, sizeof(float), MEM_ALIGN);
if (PowerSpectrum == NULL) SETIERROR(MALLOC_FAILED, "PowerSpectrum == NULL");
if (use_transposed_pot) {
tPowerSpectrum = (float*) calloc_a(NumDataPoints, sizeof(float), MEM_ALIGN);
if (tPowerSpectrum == NULL) SETIERROR(MALLOC_FAILED, "tPowerSpectrum == NULL");
} else {
tPowerSpectrum=PowerSpectrum;
}
AutoCorrelation = (float*)calloc_a(ac_fft_len, sizeof(float), MEM_ALIGN);
if (AutoCorrelation == NULL) SETIERROR(MALLOC_FAILED, "AutoCorrelation == NULL");
// boinc_worker_timer();
FftNum=0;
FftLen=1;
#ifdef USE_FFTWF
double sz;
FILE *wisdom;
if ((wisdom=boinc_fopen("wisdom.sah","r"))) {
char *wiz=(char *)calloc_a(1024,64,MEM_ALIGN);
int n=0;
while (wiz && n<64*1024 && !feof(wisdom)) {
n+=fread(wiz+n,1,80,wisdom);
}
fftwf_import_wisdom_from_string(wiz);
free_a(wiz);
fclose(wisdom);
}
#endif
#ifdef BOINC_APP_GRAPHICS
if (sah_graphics) strcpy(sah_graphics->status, "Generating FFT Coefficients");
#endif
while (bitfield != 0) {
if (bitfield & 1) {
swi.analysis_fft_lengths[FftNum]=FftLen;
#ifdef USE_IPP
int order = 0;
for (int tmp = FftLen; !(tmp & 1); order++) tmp >>= 1;
if (ippsFFTInitAlloc_C_32fc(&FftSpec[FftNum], order,
IPP_FFT_NODIV_BY_ANY, ippAlgHintFast)) {
SETIERROR (MALLOC_FAILED, "ippsFFTInitAlloc failed");
}
#elif !defined(USE_FFTWF)
// See docs in fft8g.C for sizing guidelines for BitRevTab and CoeffTab.
BitRevTab[FftNum] = (int*) calloc_a(3+(int)sqrt((float)swi.analysis_fft_lengths[FftNum]), sizeof(int), MEM_ALIGN);
if (BitRevTab[FftNum] == NULL) SETIERROR(MALLOC_FAILED, "BitRevTab[FftNum] == NULL");
BitRevTab[FftNum][0] = 0;
#else
WorkData = (sah_complex *)malloc_a(FftLen * sizeof(sah_complex),MEM_ALIGN);
sah_complex *scratch=(sah_complex *)malloc_a(FftLen*sizeof(sah_complex),MEM_ALIGN);
if ((WorkData == NULL) || (scratch==NULL)) {
SETIERROR(MALLOC_FAILED, "WorkData == NULL || scratch == NULL");
}
// TODO: Deallocate these at the end of the function
analysis_plans[FftNum] = fftwf_plan_dft_1d(FftLen, scratch, WorkData, FFTW_BACKWARD, FFTW_MEASURE|FFTW_PRESERVE_INPUT);
#endif
FftNum++;
#ifdef USE_FFTWF
free_a(scratch);
free_a(WorkData);
#endif /* USE_FFTWF */
}
FftLen*=2;
bitfield>>=1;
}
SInt32 CAVectorUnit_Examine()
{
int result = kVecNone;
#if TARGET_OS_WIN32
#if HAS_IPP
// Initialize the static IPP library! This needs to be done before
// any IPP function calls, otherwise we may have a performance penalty
int status = ippStaticInit();
if ( status == ippStsNonIntelCpu )
{
IppCpuType cpuType = ippGetCpuType();
if ( cpuType >= ippCpuSSE || cpuType <= ippCpuSSE42 )
ippStaticInitCpu( cpuType );
}
#endif
{
// On Windows we use cpuid to detect the vector unit because it works on Intel and AMD.
// The IPP library does not detect SSE on AMD processors.
if (IsCpuidAvailable())
{
if(IsSSE3Available())
{
result = kVecSSE3;
}
else if(IsSSE2Available())
{
result = kVecSSE2;
}
}
}
#elif TARGET_OS_MAC
#if DEBUG
if (getenv("CA_NoVector")) {
fprintf(stderr, "CA_NoVector set; Vector unit optimized routines will be bypassed\n");
return result;
}
else
#endif
{
#if (TARGET_CPU_PPC || TARGET_CPU_PPC64)
int sels[2] = { CTL_HW, HW_VECTORUNIT };
int vType = 0; //0 == scalar only
size_t length = sizeof(vType);
int error = sysctl(sels, 2, &vType, &length, NULL, 0);
if (!error && vType > 0)
result = kVecAltivec;
#elif (TARGET_CPU_X86 || TARGET_CPU_X86_64)
int answer = 0;
size_t length = sizeof(answer);
int error = sysctlbyname("hw.optional.sse3", &answer, &length, NULL, 0);
if (!error && answer)
result = kVecSSE3;
else {
answer = 0;
length = sizeof(answer);
error = sysctlbyname("hw.optional.sse2", &answer, &length, NULL, 0);
if (!error && answer)
result = kVecSSE2;
}
#elif (TARGET_CPU_ARM) && defined(_ARM_ARCH_7)
result = kVecNeon;
#endif
}
#endif
gCAVectorUnitType = result;
return result;
}
int
main (int argc, char **argv)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
cjpeg_source_ptr src_mgr;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
#ifdef __ENABLE_TIMING__
Ipp64u clk0;
Ipp64u clk1;
#endif
if(ippStsNoErr > ippStaticInit())
{
fprintf(stderr,"Can't initialize IPP library\n");
exit(EXIT_FAILURE);
}
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "cjpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG compression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
/* Initialize JPEG parameters.
* Much of this may be overridden later.
* In particular, we don't yet know the input file's color space,
* but we need to provide some value for jpeg_set_defaults() to work.
*/
cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
jpeg_set_defaults(&cinfo);
/* Scan command line to find file names.
* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Figure out the input file format, and set up to read it. */
src_mgr = select_file_type(&cinfo, input_file);
src_mgr->input_file = input_file;
/* Read the input file header to obtain file size & colorspace. */
(*src_mgr->start_input) (&cinfo, src_mgr);
/* Now that we know input colorspace, fix colorspace-dependent defaults */
jpeg_default_colorspace(&cinfo);
/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Specify data destination for compression */
jpeg_stdio_dest(&cinfo, output_file);
#ifdef __ENABLE_TIMING__
clk0 = get_pentium_counter();
#endif
/* Start compressor */
jpeg_start_compress(&cinfo, TRUE);
/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
(void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
}
/* Finish compression and release memory */
(*src_mgr->finish_input) (&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
#ifdef __ENABLE_TIMING__
clk1 = get_pentium_counter();
#endif
jpeg_destroy_compress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
#ifdef __ENABLE_TIMING__
fprintf(stderr,"cpu clock per operation - %u\n",(unsigned int)(clk1 - clk0));
#endif
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
EXPORT void mumble_speex_init()
{
#ifdef USE_INTEL_IPP
ippStaticInit();
#endif
}
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;
}
