/*
** CZT計算用構造体の数表データを消去してそのメモリ領域を開放する。
**
** cztp = CZT計算用構造体へのポインタ
*/
void czt_end(czt_struct *cztp)
{
if (cztp->wr != NULL) { free(cztp->wr); cztp->wr = NULL; }
if (cztp->vr != NULL) { free(cztp->vr); cztp->vr = NULL; }
if (cztp->tr != NULL) { free(cztp->tr); cztp->tr = NULL; }
cztp->samples = 0;
cztp->samples_out = 0;
cztp->samples_ex = 0;
fft_end(&cztp->fft);
}
int
main ()
{
int i;
int N, n;
int nTimes;
float secs;
float *results = malloc ((MAXPOW2 - MINPOW2) * sizeof (float));
timestamp_t t0, t1;
for (N = (1 << MINPOW2), n = 0; N < (1 << MAXPOW2); N = N << 1, n++)
{
complex *in = malloc ((N) * sizeof (complex));
complex *out = malloc ((N) * sizeof (complex));
for (i = 0; i < N; i++)
in[i].r = i, in[i].i = 0;
fft_init (N);
nTimes = (int) ceil ((MFLOPS * 1e6F) / (float) flops_fft (N));
t0 = get_timestamp();
for (i = 0; i < nTimes; i++)
{
memcpy (out, in, (N) * sizeof (complex));
fft_exec (N, out);
}
t1 = get_timestamp();
secs = (t1 - t0) / 1000000.0L;
free (in);
free (out);
fft_end ();
fprintf (stderr, "nTimes=%d N=%d: (flops %f : time:%g us)\n", nTimes,
N, (flops_fft (N) * nTimes) / secs * 1e-6F, secs);
results[n] = (flops_fft (N) * nTimes) / secs * 1e-6F;
}
for (n = 0; n < (MAXPOW2 - MINPOW2); ++n)
printf ("%d, %f\n", 1 << (MINPOW2 + n), results[n]);
free (results);
}
int main(int argc, char **argv)
{
FFTComplex *tab, *tab1, *tab_ref;
FFTSample *tabtmp, *tab2;
int it, i, c;
int do_speed = 0;
int do_mdct = 0;
int do_inverse = 0;
FFTContext s1, *s = &s1;
MDCTContext m1, *m = &m1;
int fft_nbits, fft_size;
mm_flags = 0;
fft_nbits = 9;
for(;;) {
c = getopt(argc, argv, "hsimn:");
if (c == -1)
break;
switch(c) {
case 'h':
help();
break;
case 's':
do_speed = 1;
break;
case 'i':
do_inverse = 1;
break;
case 'm':
do_mdct = 1;
break;
case 'n':
fft_nbits = atoi(optarg);
break;
}
}
fft_size = 1 << fft_nbits;
tab = av_malloc(fft_size * sizeof(FFTComplex));
tab1 = av_malloc(fft_size * sizeof(FFTComplex));
tab_ref = av_malloc(fft_size * sizeof(FFTComplex));
tabtmp = av_malloc(fft_size / 2 * sizeof(FFTSample));
tab2 = av_malloc(fft_size * sizeof(FFTSample));
if (do_mdct) {
if (do_inverse)
printf("IMDCT");
else
printf("MDCT");
ff_mdct_init(m, fft_nbits, do_inverse);
} else {
if (do_inverse)
printf("IFFT");
else
printf("FFT");
fft_init(s, fft_nbits, do_inverse);
fft_ref_init(fft_nbits, do_inverse);
}
printf(" %d test\n", fft_size);
/* generate random data */
for(i=0;i<fft_size;i++) {
tab1[i].re = frandom();
tab1[i].im = frandom();
}
/* checking result */
printf("Checking...\n");
if (do_mdct) {
if (do_inverse) {
imdct_ref((float *)tab_ref, (float *)tab1, fft_size);
ff_imdct_calc(m, tab2, (float *)tab1, tabtmp);
check_diff((float *)tab_ref, tab2, fft_size);
} else {
mdct_ref((float *)tab_ref, (float *)tab1, fft_size);
ff_mdct_calc(m, tab2, (float *)tab1, tabtmp);
check_diff((float *)tab_ref, tab2, fft_size / 2);
}
} else {
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
fft_permute(s, tab);
fft_calc(s, tab);
fft_ref(tab_ref, tab1, fft_nbits);
check_diff((float *)tab_ref, (float *)tab, fft_size * 2);
}
/* do a speed test */
if (do_speed) {
int64_t time_start, duration;
int nb_its;
printf("Speed test...\n");
/* we measure during about 1 seconds */
nb_its = 1;
for(;;) {
time_start = gettime();
for(it=0;it<nb_its;it++) {
if (do_mdct) {
if (do_inverse) {
ff_imdct_calc(m, (float *)tab, (float *)tab1, tabtmp);
} else {
ff_mdct_calc(m, (float *)tab, (float *)tab1, tabtmp);
}
} else {
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
fft_calc(s, tab);
}
}
duration = gettime() - time_start;
if (duration >= 1000000)
break;
nb_its *= 2;
}
printf("time: %0.1f us/transform [total time=%0.2f s its=%d]\n",
(double)duration / nb_its,
(double)duration / 1000000.0,
nb_its);
}
if (do_mdct) {
ff_mdct_end(m);
} else {
fft_end(s);
}
return 0;
}
void ff_mdct_end(MDCTContext *s)
{
av_freep(&s->tcos);
av_freep(&s->tsin);
fft_end(&s->fft);
}
/*
Manage the whole stuff.
*/
void makeit()
{
checkstruct *check;
picstruct *dfield, *field,*pffield[MAXFLAG], *wfield,*dwfield;
catstruct *imacat;
tabstruct *imatab;
patternstruct *pattern;
static time_t thetime1, thetime2;
struct tm *tm;
unsigned int modeltype;
int nflag[MAXFLAG], nparam2[2],
i, nok, ntab, next, ntabmax, forcextflag,
nima0,nima1, nweight0,nweight1, npsf0,npsf1, npat,npat0;
next = 0;
nok = 1;
/* Processing start date and time */
dtime = counter_seconds();
thetimet = time(NULL);
tm = localtime(&thetimet);
sprintf(prefs.sdate_start,"%04d-%02d-%02d",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
sprintf(prefs.stime_start,"%02d:%02d:%02d",
tm->tm_hour, tm->tm_min, tm->tm_sec);
NFPRINTF(OUTPUT, "");
QPRINTF(OUTPUT, "----- %s %s started on %s at %s with %d thread%s\n\n",
BANNER,
MYVERSION,
prefs.sdate_start,
prefs.stime_start,
prefs.nthreads,
prefs.nthreads>1? "s":"");
/* Initialize globals variables */
initglob();
NFPRINTF(OUTPUT, "Setting catalog parameters");
readcatparams(prefs.param_name);
useprefs(); /* update things accor. to prefs parameters */
/* Check if a specific extension should be loaded */
/* Never true for an NDF, although we could through all NDFs in a container, */
/* so we make selectext go away. */
nima0 = -1;
forcextflag = 0;
/* Do the same for other data (but do not force single extension mode) */
nima1 = -1; /* selectext(prefs.image_name[1]) */
nweight0 = -1; /* selectext(prefs.wimage_name[0]) */
nweight1 = -1; /* selectext(prefs.wimage_name[1]) */
if (prefs.dpsf_flag)
{
npsf0 = -1; /* selectext(prefs.psf_name[0]) */
npsf1 = -1; /* selectext(prefs.psf_name[1]) */
}
else
npsf0 = -1; /* selectext(prefs.psf_name[0]) */
for (i=0; i<prefs.nfimage_name; i++)
nflag[i] = -1; /* selectext(prefs.fimage_name[i]) */
if (prefs.psf_flag)
{
/*-- Read the first PSF extension to set up stuff such as context parameters */
NFPRINTF(OUTPUT, "Reading PSF information");
if (prefs.dpsf_flag)
{
thedpsf = psf_load(prefs.psf_name[0],nima0<0? 1 :(npsf0<0? 1:npsf0));
thepsf = psf_load(prefs.psf_name[1], nima1<0? 1 :(npsf1<0? 1:npsf1));
}
else
thepsf = psf_load(prefs.psf_name[0], nima0<0? 1 :(npsf0<0? 1:npsf0));
/*-- Need to check things up because of PSF context parameters */
updateparamflags();
useprefs();
}
if (prefs.prof_flag)
{
#ifdef USE_MODEL
fft_init(prefs.nthreads);
/* Create profiles at full resolution */
NFPRINTF(OUTPUT, "Preparing profile models");
modeltype = (FLAG(obj2.prof_offset_flux)? MODEL_BACK : MODEL_NONE)
|(FLAG(obj2.prof_dirac_flux)? MODEL_DIRAC : MODEL_NONE)
|(FLAG(obj2.prof_spheroid_flux)?
(FLAG(obj2.prof_spheroid_sersicn)?
MODEL_SERSIC : MODEL_DEVAUCOULEURS) : MODEL_NONE)
|(FLAG(obj2.prof_disk_flux)? MODEL_EXPONENTIAL : MODEL_NONE)
|(FLAG(obj2.prof_bar_flux)? MODEL_BAR : MODEL_NONE)
|(FLAG(obj2.prof_arms_flux)? MODEL_ARMS : MODEL_NONE);
theprofit = profit_init(thepsf, modeltype);
changecatparamarrays("VECTOR_MODEL", &theprofit->nparam, 1);
changecatparamarrays("VECTOR_MODELERR", &theprofit->nparam, 1);
nparam2[0] = nparam2[1] = theprofit->nparam;
changecatparamarrays("MATRIX_MODELERR", nparam2, 2);
if (prefs.dprof_flag)
thedprofit = profit_init(thedpsf, modeltype);
if (prefs.pattern_flag)
{
npat0 = prefs.prof_disk_patternvectorsize;
if (npat0<prefs.prof_disk_patternmodvectorsize)
npat0 = prefs.prof_disk_patternmodvectorsize;
if (npat0<prefs.prof_disk_patternargvectorsize)
npat0 = prefs.prof_disk_patternargvectorsize;
/*---- Do a copy of the original number of pattern components */
prefs.prof_disk_patternncomp = npat0;
pattern = pattern_init(theprofit, prefs.pattern_type, npat0);
if (FLAG(obj2.prof_disk_patternvector))
{
npat = pattern->size[2];
changecatparamarrays("DISK_PATTERN_VECTOR", &npat, 1);
}
if (FLAG(obj2.prof_disk_patternmodvector))
{
npat = pattern->ncomp*pattern->nfreq;
changecatparamarrays("DISK_PATTERNMOD_VECTOR", &npat, 1);
}
if (FLAG(obj2.prof_disk_patternargvector))
{
npat = pattern->ncomp*pattern->nfreq;
changecatparamarrays("DISK_PATTERNARG_VECTOR", &npat, 1);
}
pattern_end(pattern);
}
QPRINTF(OUTPUT, "Fitting model: ");
for (i=0; i<theprofit->nprof; i++)
{
if (i)
QPRINTF(OUTPUT, "+");
QPRINTF(OUTPUT, "%s", theprofit->prof[i]->name);
}
QPRINTF(OUTPUT, "\n");
if (FLAG(obj2.prof_concentration)|FLAG(obj2.prof_concentration))
{
thepprofit = profit_init(thepsf, MODEL_DIRAC);
theqprofit = profit_init(thepsf, MODEL_EXPONENTIAL);
}
#else
error(EXIT_FAILURE,
"*Error*: model-fitting is not supported in this build.\n",
" Please check your configure options");
#endif
}
if (prefs.filter_flag)
{
NFPRINTF(OUTPUT, "Reading detection filter");
getfilter(prefs.filter_name); /* get the detection filter */
}
if (FLAG(obj2.sprob))
{
NFPRINTF(OUTPUT, "Initializing Neural Network");
neurinit();
NFPRINTF(OUTPUT, "Reading Neural Network Weights");
getnnw();
}
if (prefs.somfit_flag)
{
int margin;
thesom = som_load(prefs.som_name);
if ((margin=(thesom->inputsize[1]+1)/2) > prefs.cleanmargin)
prefs.cleanmargin = margin;
if (prefs.somfit_vectorsize>thesom->neurdim)
{
prefs.somfit_vectorsize = thesom->neurdim;
sprintf(gstr,"%d", prefs.somfit_vectorsize);
warning("Dimensionality of the SOM-fit vector limited to ", gstr);
}
}
/* Prepare growth-curve buffer */
if (prefs.growth_flag)
initgrowth();
/* Allocate memory for multidimensional catalog parameter arrays */
alloccatparams();
useprefs();
/*-- Init the CHECK-images */
if (prefs.check_flag)
{
checkenum c;
NFPRINTF(OUTPUT, "Initializing check-image(s)");
for (i=0; i<prefs.ncheck_type; i++)
if ((c=prefs.check_type[i]) != CHECK_NONE)
{
if (prefs.check[c])
error(EXIT_FAILURE,"*Error*: 2 CHECK_IMAGEs cannot have the same ",
" CHECK_IMAGE_TYPE");
prefs.check[c] = initcheck(prefs.check_name[i], prefs.check_type[i],
next);
free(prefs.check_name[i]);
}
}
NFPRINTF(OUTPUT, "Initializing catalog");
initcat();
/* Initialize XML data */
if (prefs.xml_flag || prefs.cat_type==ASCII_VO)
init_xml(next);
/* Go through all images */
/* for all images in an MEF */
/*---- Initial time measurement*/
time(&thetime1);
thecat.currext = nok+1;
dfield = field = wfield = dwfield = NULL;
/*---- Init the Detection and Measurement-images */
if (prefs.dimage_flag)
{
dfield = newfield(prefs.image_name[0], DETECT_FIELD, nok);
field = newfield(prefs.image_name[1], MEASURE_FIELD, nok);
if ((field->width!=dfield->width) || (field->height!=dfield->height))
error(EXIT_FAILURE, "*Error*: Frames have different sizes","");
/*---- Prepare interpolation */
if (prefs.dweight_flag && prefs.interp_type[0] == INTERP_ALL)
init_interpolate(dfield, -1, -1);
if (prefs.interp_type[1] == INTERP_ALL)
init_interpolate(field, -1, -1);
}
else
{
field = newfield(prefs.image_name[0], DETECT_FIELD | MEASURE_FIELD, nok);
/*-- Prepare interpolation */
if ((prefs.dweight_flag || prefs.weight_flag)
&& prefs.interp_type[0] == INTERP_ALL)
init_interpolate(field, -1, -1); /* 0.0 or anything else */
}
/*-- Init the WEIGHT-images */
if (prefs.dweight_flag || prefs.weight_flag)
{
weightenum wtype;
PIXTYPE interpthresh;
if (prefs.nweight_type>1)
{
/*------ Double-weight-map mode */
if (prefs.weight_type[1] != WEIGHT_NONE)
{
/*-------- First: the "measurement" weights */
wfield = newweight(prefs.wimage_name[1],field,prefs.weight_type[1],
nok);
wtype = prefs.weight_type[1];
interpthresh = prefs.weight_thresh[1];
/*-------- Convert the interpolation threshold to variance units */
weight_to_var(wfield, &interpthresh, 1);
wfield->weight_thresh = interpthresh;
if (prefs.interp_type[1] != INTERP_NONE)
init_interpolate(wfield,
prefs.interp_xtimeout[1], prefs.interp_ytimeout[1]);
}
/*------ The "detection" weights */
if (prefs.weight_type[0] != WEIGHT_NONE)
{
interpthresh = prefs.weight_thresh[0];
if (prefs.weight_type[0] == WEIGHT_FROMINTERP)
{
dwfield=newweight(prefs.wimage_name[0],wfield,prefs.weight_type[0],
nok);
weight_to_var(wfield, &interpthresh, 1);
}
else
{
dwfield = newweight(prefs.wimage_name[0], dfield?dfield:field,
prefs.weight_type[0], nok);
weight_to_var(dwfield, &interpthresh, 1);
}
dwfield->weight_thresh = interpthresh;
if (prefs.interp_type[0] != INTERP_NONE)
init_interpolate(dwfield,
prefs.interp_xtimeout[0], prefs.interp_ytimeout[0]);
}
}
else
{
/*------ Single-weight-map mode */
wfield = newweight(prefs.wimage_name[0], dfield?dfield:field,
prefs.weight_type[0], nok);
wtype = prefs.weight_type[0];
interpthresh = prefs.weight_thresh[0];
/*------ Convert the interpolation threshold to variance units */
weight_to_var(wfield, &interpthresh, 1);
wfield->weight_thresh = interpthresh;
if (prefs.interp_type[0] != INTERP_NONE)
init_interpolate(wfield,
prefs.interp_xtimeout[0], prefs.interp_ytimeout[0]);
}
}
/*-- Init the FLAG-images */
for (i=0; i<prefs.nimaflag; i++)
{
pffield[i] = newfield(prefs.fimage_name[i], FLAG_FIELD, nok);
if ((pffield[i]->width!=field->width)
|| (pffield[i]->height!=field->height))
error(EXIT_FAILURE,
"*Error*: Incompatible FLAG-map size in ", prefs.fimage_name[i]);
}
/*-- Compute background maps for `standard' fields */
QPRINTF(OUTPUT, dfield? "Measurement image:"
: "Detection+Measurement image: ");
makeback(field, wfield, prefs.wscale_flag[1]);
QPRINTF(OUTPUT, (dfield || (dwfield&&dwfield->flags^INTERP_FIELD))? "(M) "
"Background: %-10g RMS: %-10g / Threshold: %-10g \n"
: "(M+D) "
"Background: %-10g RMS: %-10g / Threshold: %-10g \n",
field->backmean, field->backsig, (field->flags & DETECT_FIELD)?
field->dthresh: field->thresh);
if (dfield)
{
QPRINTF(OUTPUT, "Detection image: ");
makeback(dfield, dwfield? dwfield
: (prefs.weight_type[0] == WEIGHT_NONE?NULL:wfield),
prefs.wscale_flag[0]);
QPRINTF(OUTPUT, "(D) "
"Background: %-10g RMS: %-10g / Threshold: %-10g \n",
dfield->backmean, dfield->backsig, dfield->dthresh);
}
else if (dwfield && dwfield->flags^INTERP_FIELD)
{
makeback(field, dwfield, prefs.wscale_flag[0]);
QPRINTF(OUTPUT, "(D) "
"Background: %-10g RMS: %-10g / Threshold: %-10g \n",
field->backmean, field->backsig, field->dthresh);
}
/*-- For interpolated weight-maps, copy the background structure */
if (dwfield && dwfield->flags&(INTERP_FIELD|BACKRMS_FIELD))
copyback(dwfield->reffield, dwfield);
if (wfield && wfield->flags&(INTERP_FIELD|BACKRMS_FIELD))
copyback(wfield->reffield, wfield);
/*-- Prepare learn and/or associations */
if (prefs.assoc_flag)
init_assoc(field); /* initialize assoc tasks */
/*-- Update the CHECK-images */
if (prefs.check_flag)
for (i=0; i<MAXCHECK; i++)
if ((check=prefs.check[i]))
reinitcheck(field, check);
if (!forcextflag && nok>1)
{
if (prefs.psf_flag)
{
/*------ Read other PSF extensions */
NFPRINTF(OUTPUT, "Reading PSF information");
psf_end(thepsf, thepsfit);
if (prefs.dpsf_flag)
{
psf_end(thedpsf, thedpsfit);
thedpsf = psf_load(prefs.psf_name[0], nok);
thepsf = psf_load(prefs.psf_name[1], nok);
}
else
thepsf = psf_load(prefs.psf_name[0], nok);
}
#ifdef USE_MODEL
if (prefs.prof_flag)
{
/*------ Create profiles at full resolution */
profit_end(theprofit);
theprofit = profit_init(thepsf, modeltype);
if (prefs.dprof_flag)
{
profit_end(thedprofit);
thedprofit = profit_init(thedpsf, modeltype);
}
if (prefs.pattern_flag)
{
pattern = pattern_init(theprofit, prefs.pattern_type, npat0);
pattern_end(pattern);
}
if (FLAG(obj2.prof_concentration)|FLAG(obj2.prof_concentration))
{
profit_end(thepprofit);
profit_end(theqprofit);
thepprofit = profit_init(thepsf, MODEL_DIRAC);
theqprofit = profit_init(thepsf, MODEL_EXPONENTIAL);
}
}
#endif
}
/*-- Initialize PSF contexts and workspace */
if (prefs.psf_flag)
{
psf_readcontext(thepsf, field);
psf_init();
if (prefs.dpsf_flag)
{
psf_readcontext(thepsf, dfield);
psf_init();
}
}
/*-- Copy field structures to static ones (for catalog info) */
if (dfield)
{
thefield1 = *field;
thefield2 = *dfield;
}
else
thefield1 = thefield2 = *field;
if (wfield)
{
thewfield1 = *wfield;
thewfield2 = dwfield? *dwfield: *wfield;
}
else if (dwfield)
thewfield2 = *dwfield;
reinitcat(field);
/*-- Start the extraction pipeline */
NFPRINTF(OUTPUT, "Scanning image");
scanimage(field, dfield, pffield, prefs.nimaflag, wfield, dwfield);
NFPRINTF(OUTPUT, "Closing files");
/*-- Finish the current CHECK-image processing */
if (prefs.check_flag)
for (i=0; i<MAXCHECK; i++)
if ((check=prefs.check[i]))
reendcheck(field, check);
/*-- Final time measurements*/
if (time(&thetime2)!=-1)
{
if (!strftime(thecat.ext_date, 12, "%d/%m/%Y", localtime(&thetime2)))
error(EXIT_FAILURE, "*Internal Error*: Date string too long ","");
if (!strftime(thecat.ext_time, 10, "%H:%M:%S", localtime(&thetime2)))
error(EXIT_FAILURE, "*Internal Error*: Time/date string too long ","");
thecat.ext_elapsed = difftime(thetime2, thetime1);
}
reendcat();
/* Update XML data */
if (prefs.xml_flag || prefs.cat_type==ASCII_VO)
update_xml(&thecat, dfield? dfield:field, field,
dwfield? dwfield:wfield, wfield);
/*-- Close ASSOC routines */
end_assoc(field);
for (i=0; i<prefs.nimaflag; i++)
endfield(pffield[i]);
endfield(field);
if (dfield)
endfield(dfield);
if (wfield)
endfield(wfield);
if (dwfield)
endfield(dwfield);
QPRINTF(OUTPUT, " Objects: detected %-8d / sextracted %-8d \n\n",
thecat.ndetect, thecat.ntotal);
/* End look around all images in an MEF */
if (nok<0)
error(EXIT_FAILURE, "Not enough valid FITS image extensions in ",
prefs.image_name[0]);
NFPRINTF(OUTPUT, "Closing files");
/* End CHECK-image processing */
if (prefs.check_flag)
for (i=0; i<MAXCHECK; i++)
{
if ((check=prefs.check[i]))
endcheck(check);
prefs.check[i] = NULL;
}
if (prefs.filter_flag)
endfilter();
if (prefs.somfit_flag)
som_end(thesom);
if (prefs.growth_flag)
endgrowth();
#ifdef USE_MODEL
if (prefs.prof_flag)
{
profit_end(theprofit);
if (prefs.dprof_flag)
profit_end(thedprofit);
if (FLAG(obj2.prof_concentration)|FLAG(obj2.prof_concentration))
{
profit_end(thepprofit);
profit_end(theqprofit);
}
fft_end();
}
#endif
if (prefs.psf_flag)
psf_end(thepsf, thepsfit);
if (prefs.dpsf_flag)
psf_end(thedpsf, thedpsfit);
if (FLAG(obj2.sprob))
neurclose();
/* Processing end date and time */
thetimet2 = time(NULL);
tm = localtime(&thetimet2);
sprintf(prefs.sdate_end,"%04d-%02d-%02d",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
sprintf(prefs.stime_end,"%02d:%02d:%02d",
tm->tm_hour, tm->tm_min, tm->tm_sec);
prefs.time_diff = counter_seconds() - dtime;
/* Write XML */
if (prefs.xml_flag)
write_xml(prefs.xml_name);
endcat((char *)NULL);
if (prefs.xml_flag || prefs.cat_type==ASCII_VO)
end_xml();
/* Free FITS headers (now catalogues are closed). */
if (field->fitsheadsize > 0) {
free(field->fitshead);
}
return;
}
int main(int argc, char **argv)
{
FFTComplex *tab, *tab1, *tab_ref;
FFTSample *tab2;
enum tf_transform transform = TRANSFORM_FFT;
FFTContext *m, *s;
#if FFT_FLOAT
RDFTContext *r;
DCTContext *d;
#endif /* FFT_FLOAT */
int it, i, err = 1;
int do_speed = 0, do_inverse = 0;
int fft_nbits = 9, fft_size;
double scale = 1.0;
AVLFG prng;
#if !AVFFT
s = av_mallocz(sizeof(*s));
m = av_mallocz(sizeof(*m));
#endif
#if !AVFFT && FFT_FLOAT
r = av_mallocz(sizeof(*r));
d = av_mallocz(sizeof(*d));
#endif
av_lfg_init(&prng, 1);
for (;;) {
int c = getopt(argc, argv, "hsimrdn:f:c:");
if (c == -1)
break;
switch (c) {
case 'h':
help();
return 1;
case 's':
do_speed = 1;
break;
case 'i':
do_inverse = 1;
break;
case 'm':
transform = TRANSFORM_MDCT;
break;
case 'r':
transform = TRANSFORM_RDFT;
break;
case 'd':
transform = TRANSFORM_DCT;
break;
case 'n':
fft_nbits = atoi(optarg);
break;
case 'f':
scale = atof(optarg);
break;
case 'c':
{
unsigned cpuflags = av_get_cpu_flags();
if (av_parse_cpu_caps(&cpuflags, optarg) < 0)
return 1;
av_force_cpu_flags(cpuflags);
break;
}
}
}
fft_size = 1 << fft_nbits;
tab = av_malloc_array(fft_size, sizeof(FFTComplex));
tab1 = av_malloc_array(fft_size, sizeof(FFTComplex));
tab_ref = av_malloc_array(fft_size, sizeof(FFTComplex));
tab2 = av_malloc_array(fft_size, sizeof(FFTSample));
if (!(tab && tab1 && tab_ref && tab2))
goto cleanup;
switch (transform) {
#if CONFIG_MDCT
case TRANSFORM_MDCT:
av_log(NULL, AV_LOG_INFO, "Scale factor is set to %f\n", scale);
if (do_inverse)
av_log(NULL, AV_LOG_INFO, "IMDCT");
else
av_log(NULL, AV_LOG_INFO, "MDCT");
mdct_init(&m, fft_nbits, do_inverse, scale);
break;
#endif /* CONFIG_MDCT */
case TRANSFORM_FFT:
if (do_inverse)
av_log(NULL, AV_LOG_INFO, "IFFT");
else
av_log(NULL, AV_LOG_INFO, "FFT");
fft_init(&s, fft_nbits, do_inverse);
if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
goto cleanup;
break;
#if FFT_FLOAT
# if CONFIG_RDFT
case TRANSFORM_RDFT:
if (do_inverse)
av_log(NULL, AV_LOG_INFO, "IDFT_C2R");
else
av_log(NULL, AV_LOG_INFO, "DFT_R2C");
rdft_init(&r, fft_nbits, do_inverse ? IDFT_C2R : DFT_R2C);
if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
goto cleanup;
break;
# endif /* CONFIG_RDFT */
# if CONFIG_DCT
case TRANSFORM_DCT:
if (do_inverse)
av_log(NULL, AV_LOG_INFO, "DCT_III");
else
av_log(NULL, AV_LOG_INFO, "DCT_II");
dct_init(&d, fft_nbits, do_inverse ? DCT_III : DCT_II);
break;
# endif /* CONFIG_DCT */
#endif /* FFT_FLOAT */
default:
av_log(NULL, AV_LOG_ERROR, "Requested transform not supported\n");
goto cleanup;
}
av_log(NULL, AV_LOG_INFO, " %d test\n", fft_size);
/* generate random data */
for (i = 0; i < fft_size; i++) {
tab1[i].re = frandom(&prng);
tab1[i].im = frandom(&prng);
}
/* checking result */
av_log(NULL, AV_LOG_INFO, "Checking...\n");
switch (transform) {
#if CONFIG_MDCT
case TRANSFORM_MDCT:
if (do_inverse) {
imdct_ref(&tab_ref->re, &tab1->re, fft_nbits);
imdct_calc(m, tab2, &tab1->re);
err = check_diff(&tab_ref->re, tab2, fft_size, scale);
} else {
mdct_ref(&tab_ref->re, &tab1->re, fft_nbits);
mdct_calc(m, tab2, &tab1->re);
err = check_diff(&tab_ref->re, tab2, fft_size / 2, scale);
}
break;
#endif /* CONFIG_MDCT */
case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
fft_permute(s, tab);
fft_calc(s, tab);
fft_ref(tab_ref, tab1, fft_nbits);
err = check_diff(&tab_ref->re, &tab->re, fft_size * 2, 1.0);
break;
#if FFT_FLOAT
#if CONFIG_RDFT
case TRANSFORM_RDFT:
{
int fft_size_2 = fft_size >> 1;
if (do_inverse) {
tab1[0].im = 0;
tab1[fft_size_2].im = 0;
for (i = 1; i < fft_size_2; i++) {
tab1[fft_size_2 + i].re = tab1[fft_size_2 - i].re;
tab1[fft_size_2 + i].im = -tab1[fft_size_2 - i].im;
}
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
tab2[1] = tab1[fft_size_2].re;
rdft_calc(r, tab2);
fft_ref(tab_ref, tab1, fft_nbits);
for (i = 0; i < fft_size; i++) {
tab[i].re = tab2[i];
tab[i].im = 0;
}
err = check_diff(&tab_ref->re, &tab->re, fft_size * 2, 0.5);
} else {
for (i = 0; i < fft_size; i++) {
tab2[i] = tab1[i].re;
tab1[i].im = 0;
}
rdft_calc(r, tab2);
fft_ref(tab_ref, tab1, fft_nbits);
tab_ref[0].im = tab_ref[fft_size_2].re;
err = check_diff(&tab_ref->re, tab2, fft_size, 1.0);
}
break;
}
#endif /* CONFIG_RDFT */
#if CONFIG_DCT
case TRANSFORM_DCT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
dct_calc(d, &tab->re);
if (do_inverse)
idct_ref(&tab_ref->re, &tab1->re, fft_nbits);
else
dct_ref(&tab_ref->re, &tab1->re, fft_nbits);
err = check_diff(&tab_ref->re, &tab->re, fft_size, 1.0);
break;
#endif /* CONFIG_DCT */
#endif /* FFT_FLOAT */
}
/* do a speed test */
if (do_speed) {
int64_t time_start, duration;
int nb_its;
av_log(NULL, AV_LOG_INFO, "Speed test...\n");
/* we measure during about 1 seconds */
nb_its = 1;
for (;;) {
time_start = av_gettime_relative();
for (it = 0; it < nb_its; it++) {
switch (transform) {
case TRANSFORM_MDCT:
if (do_inverse)
imdct_calc(m, &tab->re, &tab1->re);
else
mdct_calc(m, &tab->re, &tab1->re);
break;
case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
fft_calc(s, tab);
break;
#if FFT_FLOAT
case TRANSFORM_RDFT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
rdft_calc(r, tab2);
break;
case TRANSFORM_DCT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
dct_calc(d, tab2);
break;
#endif /* FFT_FLOAT */
}
}
duration = av_gettime_relative() - time_start;
if (duration >= 1000000)
break;
nb_its *= 2;
}
av_log(NULL, AV_LOG_INFO,
"time: %0.1f us/transform [total time=%0.2f s its=%d]\n",
(double) duration / nb_its,
(double) duration / 1000000.0,
nb_its);
}
switch (transform) {
#if CONFIG_MDCT
case TRANSFORM_MDCT:
mdct_end(m);
break;
#endif /* CONFIG_MDCT */
case TRANSFORM_FFT:
fft_end(s);
break;
#if FFT_FLOAT
# if CONFIG_RDFT
case TRANSFORM_RDFT:
rdft_end(r);
break;
# endif /* CONFIG_RDFT */
# if CONFIG_DCT
case TRANSFORM_DCT:
dct_end(d);
break;
# endif /* CONFIG_DCT */
#endif /* FFT_FLOAT */
}
cleanup:
av_free(tab);
av_free(tab1);
av_free(tab2);
av_free(tab_ref);
av_free(exptab);
#if !AVFFT
av_free(s);
av_free(m);
#endif
#if !AVFFT && FFT_FLOAT
av_free(r);
av_free(d);
#endif
if (err)
printf("Error: %d.\n", err);
return !!err;
}
