void phase(double *p, const int mp, double *z, const int mz, double *ph,
const int flng, const int unlap)
{
static double *x;
static int fsize = 0;
double *y, *xx, *yy, *py;
int no, i, offset;
double pi;
pi = atan(1.) * 4.;
no = flng / 2 + 1;
if (flng > fsize) {
if (x != NULL)
free(x);
fsize = flng;
x = dgetmem(4 * flng + no);
}
y = &x[flng];
xx = &y[flng];
yy = &xx[flng];
py = &yy[flng];
fillz(x, sizeof(*x), flng);
fillz(xx, sizeof(*xx), flng);
movem(z, x, mz + 1, sizeof(*z));
movem(p, xx, mp + 1, sizeof(*p));
fftr(x, y, flng);
xx[0] = 1;
fftr(xx, yy, flng);
for (i = 0; i < no; i++) {
ph[i] = x[i] * xx[i] + y[i] * yy[i];
py[i] = y[i] * xx[i] - x[i] * yy[i];
}
offset = 0;
i = 0;
ph[i] = atan2(py[i], ph[i]) / pi;
i++;
for (; i < no; i++) {
ph[i] = atan2(py[i], ph[i]) / pi;
if (unlap) {
if (ph[i - 1] - ph[i] - offset > 1)
offset += 2;
else if (ph[i] + offset - ph[i - 1] > 1)
offset -= 2;
ph[i] += offset;
}
}
return;
}
void frqtr(double *c1, int m1, double *c2, int m2, const double a)
{
int i, j;
static double *d = NULL, *g;
static int size;
if (d == NULL) {
size = m2;
d = dgetmem(size + size + 2);
g = d + size + 1;
}
if (m2 > size) {
free(d);
size = m2;
d = dgetmem(size + size + 2);
g = d + size + 1;
}
fillz(g, sizeof(*g), m2 + 1);
for (i = -m1; i <= 0; i++) {
if (0 <= m2) {
d[0] = g[0];
g[0] = c1[-i];
}
for (j = 1; j <= m2; j++)
g[j] = d[j - 1] + a * ((d[j] = g[j]) - g[j - 1]);
}
movem(g, c2, sizeof(*g), m2 + 1);
return;
}
int histogram(double *x, const int size, const double min, const double max,
const double step, double *h)
{
int k, ii, flg = 0;
int jj;
k = (int) ((max - min) / step + 1.0);
fillz(h, sizeof(*h), k);
for (ii = 0; ii < size; ii++) {
if ((x[ii] < min) || (x[ii] > max)) {
flg = 1;
} else {
for (jj = 0; jj < k; jj++) {
if (x[ii] < min + (jj + 1) * step) {
h[jj] += 1.0;
break;
}
}
}
}
return (flg);
}
int toeplitz(double *t, double *a, double *b, const int n, double eps)
{
int l, k;
static double *c = NULL, *cc;
static int size;
double rmd, mue, mue2;
if (c == NULL) {
c = dgetmem(n + n + 2);
cc = c + n;
size = n;
}
if (n > size) {
free(c);
c = dgetmem(n + n + 2);
cc = c + n;
size = n;
}
if (eps < 0.0)
eps = 1.0e-6;
fillz(c, sizeof(*c), n + 1);
rmd = t[0];
if (((rmd < 0.0) ? -rmd : rmd) <= eps)
return (-1);
a[0] = b[0] / rmd;
for (l = 1; l < n; l++) {
mue = -t[l];
for (k = 1; k < l; k++)
mue -= c[k] * t[l - k];
mue /= rmd;
for (k = 1; k < l; k++)
cc[k] = c[k] + mue * c[l - k];
cc[l] = mue;
rmd = (1.0 - mue * mue) * rmd;
if (((rmd < 0.0) ? -rmd : rmd) <= eps)
return (-1);
for (k = 1; k <= l; k++)
c[k] = cc[k];
mue2 = b[l];
for (k = 0; k <= l - 1; k++)
mue2 += c[l - k] * b[k];
mue2 /= rmd;
for (k = 0; k < l; k++)
a[k] += mue2 * c[l - k];
a[l] = mue2;
}
return (0);
}
void c2sp(double *c, const int m, double *x, double *y, const int l)
{
int m1;
m1 = m + 1;
movem(c, x, sizeof(*c), m1);
fillz(x + m1, sizeof(*x), l - m1);
fftr(x, y, l);
}
void vaverage(double *x, const int l, const int num, double *ave)
{
int i, j;
fillz(ave, sizeof(*ave), l);
for (i = 0; i < num; i++)
for (j = 0; j < l; j++)
ave[j] += *x++;
for (j = 0; j < l; j++)
ave[j] /= (double) num;
return;
}
void c2ndps(double *c, const int m, double *n, const int l)
{
int i;
double *tmp;
fillz(n, sizeof(*n), l);
tmp = dgetmem(l);
// generate mc(m)
for (i = 1; i < m + 1; i++) {
n[i] = c[i] * i / 2.0;
n[l - i] = n[i];
}
fftr(n, tmp, l);
free(tmp);
}
void freqt(double *c1, const int m1, double *c2, const int m2, const double a)
{
int i, j;
double b;
static double *d = NULL, *g;
static int size;
if (d == NULL) {
size = m2;
d = dgetmem(size + size + 2);
g = d + size + 1;
}
if (m2 > size) {
free(d);
size = m2;
d = dgetmem(size + size + 2);
g = d + size + 1;
}
b = 1 - a * a;
fillz(g, sizeof(*g), m2 + 1);
for (i = -m1; i <= 0; i++) {
if (0 <= m2)
g[0] = c1[-i] + a * (d[0] = g[0]);
if (1 <= m2)
g[1] = b * d[0] + a * (d[1] = g[1]);
for (j = 2; j <= m2; j++)
g[j] = d[j - 1] + a * ((d[j] = g[j]) - g[j - 1]);
}
movem(g, c2, sizeof(*g), m2 + 1);
return;
}
int main(int argc, char *argv[])
{
FILE *fp;
char *s, *infile = NULL, c;
int size = SIZE, size2, k, nd = -1, out = ' ';
double *x, *y;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc) {
if (*(s = *++argv) == '-') {
c = *++s;
switch (c) {
case 'l':
size = atoi(*++argv);
argc--;
break;
case 'm':
nd = atoi(*++argv) + 1;
argc--;
break;
case 'i':
case 'p':
case 'r':
c -= ('a' - 'A');
case 'A':
case 'I':
case 'P':
case 'R':
out = c;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, c);
usage(1);
}
} else
infile = s;
}
if (nd == -1)
nd = size;
if (nd > size) {
fprintf(stderr,
"%s : Order of sequence %d should be less than the FFT size %d!\n",
cmnd, nd, size);
return (1);
}
fp = stdin;
if (infile) {
fp = getfp(infile, "rb");
}
x = dgetmem(size2 = size + size);
y = x + size;
while (!feof(fp)) {
fillz(x, size2, sizeof(double));
if (freadf(x, sizeof(*x), nd, fp) == 0)
break;
if (freadf(y, sizeof(*y), nd, fp) == 0)
break;
fft(x, y, size);
if (out == 'P')
for (k = 0; k < size; k++)
x[k] = x[k] * x[k] + y[k] * y[k];
else if (out == 'A')
for (k = 0; k < size; k++)
x[k] = sqrt(x[k] * x[k] + y[k] * y[k]);
if (out != 'I')
fwritef(x, sizeof(*x), size, stdout);
if (out == ' ' || out == 'I')
fwritef(y, sizeof(*y), size, stdout);
}
if (infile) {
fclose(fp);
}
return (0);
}
void mlsacheck(double *mcep, int m, int fftlen, int frame,
double a, double r, int c)
{
int i;
double gain, *x, *y, *mag = NULL, max = 0.0;
x = dgetmem(fftlen);
y = dgetmem(fftlen);
fillz(x, sizeof(*x), fftlen);
fillz(y, sizeof(*y), fftlen);
/* calculate gain factor */
for (i = 0, gain = 0.0; i <= m; i++) {
x[i] = mcep[i];
gain += x[i] * pow(-a, i);
}
/* gain normalization */
x[0] -= gain;
/* check stability */
if (c == 0 || c == 2 || c == 3) { /* usual mode */
mag = dgetmem(fftlen);
fillz(mag, sizeof(*mag), fftlen);
fftr(x, y, fftlen);
for (i = 0; i < fftlen; i++) {
mag[i] = sqrt(x[i] * x[i] + y[i] * y[i]);
if (mag[i] > max)
max = mag[i];
}
} else { /* fast mode */
for (i = 0; i <= m; i++)
max += x[i];
}
/* modification MLSA filter coefficients */
if (max > r) {
/* output ascii report */
fprintf(stderr,
"[No. %d] is unstable frame (maximum = %f, threshold = %f)\n",
frame, max, r);
/* modification */
if (c == 2) { /* clipping */
for (i = 0; i < fftlen; i++) {
if (mag[i] > r) {
x[i] *= r / mag[i];
y[i] *= r / mag[i];
}
}
} else if (c == 3) { /* scaling */
for (i = 0; i < fftlen; i++) {
x[i] *= r / max;
y[i] *= r / max;
}
} else if (c == 4) { /* fast mode */
for (i = 0; i <= m; i++)
x[i] *= r / max;
}
}
/* output MLSA filter coefficients */
if (c == 0 || c == 1 || max <= r) { /* no modification */
fwritef(mcep, sizeof(*mcep), m + 1, stdout);
} else {
if (c == 2 || c == 3)
ifft(x, y, fftlen);
x[0] += gain;
fwritef(x, sizeof(*x), m + 1, stdout);
}
free(x);
free(y);
if (c == 0 || c == 2 || c == 3)
free(mag);
}
int main(int argc, char **argv)
{
FILE *fp = stdin;
GMM gmm, tgmm, floor;
double E = DEF_E, V = DEF_V, W = DEF_W,
*dat, *pd, *cb, *icb, *logwgd, logb, *sum, *sum_m, **sum_v, diff, sum_w,
ave_logp0, ave_logp1, change = MAXVALUE, tmp1, tmp2;
int ispipe, l, ll, L = DEF_L, m, M = DEF_M, N, t, T = DEF_T, S =
DEF_S, full = FULL, n1, i, j, Imin = DEF_IMIN, Imax =
DEF_IMAX, *tindex, *cntcb;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
/* -- Check options -- */
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'h':
usage(0);
break;
case 'l':
L = atoi(*++argv);
--argc;
break;
case 'm':
M = atoi(*++argv);
--argc;
break;
case 't':
T = atoi(*++argv);
--argc;
break;
case 's':
S = atoi(*++argv);
--argc;
break;
case 'a':
Imin = atoi(*++argv);
--argc;
break;
case 'b':
Imax = atoi(*++argv);
--argc;
break;
case 'e':
E = atof(*++argv);
--argc;
break;
case 'v':
V = atof(*++argv);
--argc;
break;
case 'w':
W = atof(*++argv);
--argc;
break;
case 'f':
full = 1 - full;
break;
default:
fprintf(stderr, "%s: Illegal option \"%s\".\n", cmnd, *argv);
usage(1);
}
} else
fp = getfp(*argv, "rb");
/* -- Count number of training vectors -- */
if (T == -1) {
ispipe = fseek(fp, 0L, SEEK_END);
T = (int) (ftell(fp) / (double) L / (double) sizeof(float));
rewind(fp);
if (ispipe == -1) { /* training data is from standard input via pipe */
fprintf(stderr,
"\n %s (Error) -t option must be specified for the standard input via pipe.\n",
cmnd);
usage(1);
}
}
/* Memory allocation */
/* Training data */
dat = dgetmem(T * L);
/* for VQ */
N = 1;
while (N < M)
N *= 2;
cb = dgetmem(N * L);
icb = dgetmem(L);
tindex = (int *) getmem(T, sizeof(int));
cntcb = (int *) getmem(M, sizeof(int));
/* GMM */
gmm.weight = dgetmem(M);
gmm.gauss = (Gauss *) getmem(M, sizeof(Gauss));
for (m = 0; m < M; m++) {
gmm.gauss[m].mean = dgetmem(L);
gmm.gauss[m].var = dgetmem(L);
if (full == 1) {
gmm.gauss[m].cov = (double **) malloc(sizeof(double *) * L);
gmm.gauss[m].inv = (double **) malloc(sizeof(double *) * L);
for (l = 0; l < L; l++) {
gmm.gauss[m].cov[l] = dgetmem(L);
gmm.gauss[m].inv[l] = dgetmem(L);
}
}
}
if (full == 1) {
floor.gauss = (Gauss *) getmem(1, sizeof(Gauss));
floor.gauss[0].cov = (double **) malloc(sizeof(double *) * L);
for (l = 0; l < L; l++)
floor.gauss[0].cov[l] = dgetmem(L);
sum_m = dgetmem(L);
sum_v = (double **) malloc(sizeof(double *) * L);
}
/* temporary */
tgmm.weight = dgetmem(M);
tgmm.gauss = (Gauss *) getmem(M, sizeof(Gauss));
for (m = 0; m < M; m++) {
tgmm.gauss[m].mean = dgetmem(L);
tgmm.gauss[m].var = dgetmem(L);
if (full == 1) {
tgmm.gauss[m].cov = (double **) malloc(sizeof(double *) * L);
tgmm.gauss[m].inv = (double **) malloc(sizeof(double *) * L);
for (l = 0; l < L; l++) {
tgmm.gauss[m].cov[l] = dgetmem(L);
tgmm.gauss[m].inv[l] = dgetmem(L);
}
}
}
logwgd = dgetmem(M);
sum = dgetmem(M);
/* Read training data */
freadf(dat, sizeof(*dat), T * L, fp);
/* Initialization of GMM parameters */
/* LBG */
vaverage(dat, L, T, icb);
lbg(dat, L, T, icb, 1, cb, N, ITER, MINTRAIN, S, CENTUP, DELTA, END);
for (t = 0, pd = dat; t < T; t++, pd += L) {
tindex[t] = vq(pd, cb, L, M);
cntcb[tindex[t]]++;
}
for (m = 0; m < M; m++)
if (cntcb[m] == 0) {
fprintf(stderr, "Error: No data for mixture No.%d\n", m);
usage(1);
}
fprintf(stderr, "T = %d L = %d M = %d\n", T, L, M);
/* flooring value for weights */
W = 1.0 / (double) M *(double) W;
/* weights */
for (m = 0, sum_w = 0.0; m < M; m++) {
gmm.weight[m] = (double) cntcb[m] / (double) T;
if (gmm.weight[m] < W)
gmm.weight[m] = W;
sum_w += gmm.weight[m];
}
if (sum_w != 1.0)
for (m = 0; m < M; m++)
gmm.weight[m] /= sum_w;
/* mean */
for (m = 0, pd = cb; m < M; m++, pd += L)
movem(pd, gmm.gauss[m].mean, sizeof(double), L);
/* variance */
if (full != 1) {
for (t = 0, pd = dat; t < T; t++, pd += L)
for (l = 0; l < L; l++) {
diff = gmm.gauss[tindex[t]].mean[l] - pd[l];
gmm.gauss[tindex[t]].var[l] += sq(diff);
}
for (m = 0; m < M; m++)
for (l = 0; l < L; l++) {
gmm.gauss[m].var[l] /= (double) cntcb[m];
if (gmm.gauss[m].var[l] < V)
gmm.gauss[m].var[l] = V;
}
for (m = 0; m < M; m++)
gmm.gauss[m].gconst = cal_gconst(gmm.gauss[m].var, L);
}
/* full covariance */
else {
for (t = 0, pd = dat; t < T; t++, pd += L) {
for (l = 0; l < L; l++) {
for (i = 0; i <= l; i++) {
if (l == i) {
diff =
(gmm.gauss[tindex[t]].mean[l] -
pd[l]) * (gmm.gauss[tindex[t]].mean[i] - pd[i]);
floor.gauss[0].cov[l][i] += diff;
}
}
}
}
for (l = 0; l < L; l++) {
for (i = 0; i <= l; i++) {
if (l == i) {
floor.gauss[0].cov[l][i] /= T;
floor.gauss[0].cov[l][i] *= V;
}
}
}
for (t = 0, pd = dat; t < T; t++, pd += L) {
for (l = 0; l < L; l++) {
for (i = 0; i <= l; i++) {
diff =
(gmm.gauss[tindex[t]].mean[l] -
pd[l]) * (gmm.gauss[tindex[t]].mean[i] - pd[i]);
gmm.gauss[tindex[t]].cov[l][i] += diff;
}
}
}
for (m = 0; m < M; m++)
for (l = 0; l < L; l++)
for (i = 0; i <= l; i++) {
gmm.gauss[m].cov[l][i] /= (double) cntcb[m];
}
}
/* EM training of GMM parameters */
for (i = 0; (i <= Imax) && ((i <= Imin) || (fabs(change) > E)); i++) {
if (full != 1)
fillz_gmm(&tgmm, M, L);
else
fillz_gmmf(&tgmm, M, L);
fillz(sum, sizeof(double), M);
if (full != 1) {
for (m = 0; m < M; m++)
gmm.gauss[m].gconst = cal_gconst(gmm.gauss[m].var, L);
} else {
for (m = 0, n1 = 0; m < M; m++) {
gmm.gauss[m].gconst = cal_gconstf(gmm.gauss[m].cov, L);
if (gmm.gauss[m].gconst == 0) {
n1++;
for (l = 0; l < L; l++)
gmm.gauss[m].cov[l][l] += floor.gauss[0].cov[l][l];
gmm.gauss[m].gconst = cal_gconstf(gmm.gauss[m].cov, L);
}
if (gmm.gauss[m].gconst == 0) {
fprintf(stderr, "ERROR : Can't caluculate covdet");
exit(EXIT_FAILURE);
}
/* calculate inv */
cal_inv(gmm.gauss[m].cov, gmm.gauss[m].inv, L);
}
}
if (full == 1)
fprintf(stderr, "%d cov can't caluculate covdet\n", n1);
for (t = 0, ave_logp1 = 0.0, pd = dat; t < T; t++, pd += L) {
for (m = 0, logb = LZERO; m < M; m++) {
if (full != 1) {
logwgd[m] = log_wgd(&gmm, m, pd, L);
logb = log_add(logb, logwgd[m]);
}
/* full */
else {
logwgd[m] = log_wgdf(&gmm, m, pd, L);
logb = log_add(logb, logwgd[m]);
}
}
ave_logp1 += logb;
for (m = 0; m < M; m++) {
tmp1 = exp(logwgd[m] - logb);
sum[m] += tmp1;
for (l = 0; l < L; l++) {
tmp2 = tmp1 * pd[l];
tgmm.gauss[m].mean[l] += tmp2;
if (full != 1)
tgmm.gauss[m].var[l] += tmp2 * pd[l];
else {
for (j = 0; j <= l; j++) {
tgmm.gauss[m].cov[l][j] +=
tmp1 * (pd[l] - gmm.gauss[m].mean[l]) * (pd[j] -
gmm.
gauss[m].mean
[j]);
}
}
}
}
}
/* Output average log likelihood at each iteration */
ave_logp1 /= (double) T;
if (i == 1 && m == 1)
ave_logp0 = ave_logp1;
fprintf(stderr, "iter %3d : ", i);
fprintf(stderr, "ave_logprob = %g", ave_logp1);
if (i) {
change = ave_logp1 - ave_logp0;
fprintf(stderr, " change = %g", change);
}
fprintf(stderr, "\n");
ave_logp0 = ave_logp1;
/* Update perameters */
/* weights */
for (m = 0; m < M; m++)
gmm.weight[m] = sum[m] / (double) T;
/* mean, variance */
for (m = 0; m < M; m++) {
for (l = 0; l < L; l++)
gmm.gauss[m].mean[l] = tgmm.gauss[m].mean[l] / sum[m];
if (full != 1) {
for (l = 0; l < L; l++) {
gmm.gauss[m].var[l] =
tgmm.gauss[m].var[l] / sum[m] - sq(gmm.gauss[m].mean[l]);
if (gmm.gauss[m].var[l] < V)
gmm.gauss[m].var[l] = V;
}
}
/* full */
else {
for (l = 0; l < L; l++) {
for (j = 0; j <= l; j++) {
gmm.gauss[m].cov[l][j] = tgmm.gauss[m].cov[l][j] / sum[m];
}
}
}
}
}
/* Output GMM parameters */
fwritef(gmm.weight, sizeof(double), M, stdout);
if (full != 1) {
for (m = 0; m < M; m++) {
fwritef(gmm.gauss[m].mean, sizeof(double), L, stdout);
fwritef(gmm.gauss[m].var, sizeof(double), L, stdout);
}
} else {
for (m = 0; m < M; m++) {
fwritef(gmm.gauss[m].mean, sizeof(double), L, stdout);
for (i = 0; i < L; i++)
for (j = 0; j < i; j++)
gmm.gauss[m].cov[j][i] = gmm.gauss[m].cov[i][j];
for (l = 0; l < L; l++)
fwritef(gmm.gauss[m].cov[l], sizeof(double), L, stdout);
}
}
return (0);
}
int smcep(double *xw, const int flng, double *mc, const int m, const int fftsz,
const double a, const double t, const int itr1, const int itr2,
const double dd, const int etype, const double e, const double f,
const int itype)
{
int i, j;
int flag = 0, f2, m2;
double u, s, eps = 0.0, min, max;
static double *x = NULL, *y, *c, *d, *al, *b;
static int size_x, size_d;
if (etype == 1 && e < 0.0) {
fprintf(stderr, "smcep : value of e must be e>=0!\n");
exit(1);
}
if (etype == 2 && e >= 0.0) {
fprintf(stderr, "smcep : value of E must be E<0!\n");
exit(1);
}
if (etype == 1) {
eps = e;
}
if (x == NULL) {
x = dgetmem(3 * flng);
y = x + flng;
c = y + flng;
size_x = flng;
d = dgetmem(3 * m + 3);
al = d + (m + 1);
b = al + (m + 1);
size_d = m;
}
if (flng > size_x) {
free(x);
x = dgetmem(3 * flng);
y = x + flng;
c = y + flng;
size_x = flng;
}
if (m > size_d) {
free(d);
d = dgetmem(3 * m + 3);
al = d + (m + 1);
b = al + (m + 1);
size_d = m;
}
f2 = flng / 2.;
m2 = m + m;
movem(xw, x, sizeof(*x), flng);
switch (itype) {
case 0: /* windowed data sequence */
fftr(x, y, flng);
for (i = 0; i < flng; i++) {
x[i] = x[i] * x[i] + y[i] * y[i] + eps; /* periodogram */
}
break;
case 1: /* dB */
for (i = 0; i <= flng / 2; i++) {
x[i] = exp((x[i] / 20.0) * log(10.0)); /* dB -> amplitude spectrum */
x[i] = x[i] * x[i] + eps; /* amplitude -> periodogram */
}
break;
case 2: /* log */
for (i = 0; i <= flng / 2; i++) {
x[i] = exp(x[i]); /* log -> amplitude spectrum */
x[i] = x[i] * x[i] + eps; /* amplitude -> periodogram */
}
break;
case 3: /* amplitude */
for (i = 0; i <= flng / 2; i++) {
x[i] = x[i] * x[i] + eps; /* amplitude -> periodogram */
}
break;
case 4: /* periodogram */
for (i = 0; i <= flng / 2; i++) {
x[i] = x[i] + eps;
}
break;
default:
fprintf(stderr, "smcep : Input type %d is not supported!\n", itype);
exit(1);
}
if (itype > 0) {
for (i = 1; i < flng / 2; i++)
x[flng - i] = x[i];
}
if (etype == 2 && e < 0.0) {
max = x[0];
for (i = 1; i < flng; i++) {
if (max < x[i])
max = x[i];
}
max = sqrt(max);
min = max * pow(10.0, e / 20.0); /* floor is 20*log10(min/max) */
min = min * min;
for (i = 0; i < flng; i++) {
if (x[i] < min)
x[i] = min;
}
}
for (i = 0; i < flng; i++)
c[i] = log(x[i]);
/* 1, (-a), (-a)^2, ..., (-a)^M */
al[0] = 1.0;
for (i = 1; i <= m; i++)
al[i] = 0.0;
frqt_a(al, m, fftsz, a, t);
/* initial value of cepstrum */
ifftr(c, y, flng); /* c : IFFT[x] */
c[0] /= 2.0;
c[flng / 2] /= 2.0;
freqt2(c, f2, mc, m, fftsz, a, t); /* mc : mel cep. */
s = c[0];
/* Newton Raphson method */
for (j = 1; j <= itr2; j++) {
fillz(c, sizeof(*c), flng);
ifreqt2(mc, m, c, f2, fftsz, a, t); /* mc : mel cep. */
fftr(c, y, flng); /* c, y : FFT[mc] */
for (i = 0; i < flng; i++)
c[i] = x[i] / exp(c[i] + c[i]);
ifftr(c, y, flng);
frqtr2(c, f2, c, m2, fftsz, a, t); /* c : r(k) */
u = c[0];
if (j >= itr1) {
if (fabs((u - s) / u) < dd) {
flag = 1;
break;
}
s = u;
}
for (i = 0; i <= m; i++)
b[i] = c[i] - al[i];
for (i = 0; i <= m2; i++)
y[i] = c[i];
for (i = 0; i <= m2; i += 2)
y[i] -= c[0];
for (i = 2; i <= m; i += 2)
c[i] += c[0];
c[0] += c[0];
if (theq(c, y, d, b, m + 1, f)) {
fprintf(stderr, "smcep : Error in theq() at %dth iteration!\n", j);
exit(1);
}
for (i = 0; i <= m; i++)
mc[i] += d[i];
}
if (flag)
return (0);
else
return (-1);
}
int main(int argc, char *argv[])
{
char *s, *infile = NULL, c;
int i, j, k, n, iter, size2;
double *x, *y, *pReal, *pImag;
FILE *fp;
Boolean comp = COMPLEX;
if ((cmnd = strrchr(argv[0], '/')) == NULL) {
cmnd = argv[0];
} else {
cmnd++;
}
while (--argc) {
if (*(s = *++argv) == '-') {
c = *++s;
if ((c == 'l') && (*++s == '\0')) {
s = *++argv;
--argc;
}
switch (c) {
case 'l': /* IDCT size */
size = atoi(s);
break;
case 'c': /* use complex number */
comp = 1 - COMPLEX;
break;
case 'd': /* IDCT without FFT (DFT) */
dftmode = 1 - dftmode;
break;
case 'h':
default:
usage();
}
} else {
infile = s;
}
}
if (infile) {
fp = getfp(infile, "rb");
} else {
fp = stdin;
}
/* memory allocation */
x = dgetmem(size2 = size + size);
y = x + size;
pReal = dgetmem(size2);
pImag = pReal + size;
while (!feof(fp)) {
fillz(x, size2, sizeof(*x));
if (freadf(x, sizeof(*x), size, fp) == 0) {
break;
}
if (comp) {
if (freadf(y, sizeof(*y), size, fp) == 0) {
break;
}
}
/* decide wheather 'size' is a power of 2 or not */
for (iter = 0, i = size; (i /= 2) != 0; iter++);
for (i = 1, j = 1; i <= iter; i++, j *= 2);
/* IDCT-II (DCT-III) routine */
idct_create_table(size);
idct(pReal, pImag, (const double *) x, (const double *) y, j);
/* output IDCT sequence */
fwritef(pReal, sizeof(*pReal), size, stdout);
if (comp) {
fwritef(pImag, sizeof(*pImag), size, stdout);
}
}
if (infile) {
fclose(fp);
}
return (0);
}
int main(int argc, char *argv[])
{
FILE *fp;
char *s, *infile = NULL, c;
FILE *getfp();
Boolean dftmode = DFTMODE;
Boolean compmode = COMPMODE;
double *x, *y, *pReal2, *pImag2, *dgetmem();
int size2;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc) {
if (*(s = *++argv) == '-') {
c = *++s;
if ((c == 'l') && (*++s == '\0')) {
s = *++argv;
--argc;
}
switch (c) {
case 'l':
size = atoi(s);
break;
case 'I':
out = c;
compmode = 1 - compmode;
break;
case 'd':
dftmode = 1 - dftmode;
break;
case 'h':
default:
usage();
}
} else
infile = s;
}
if (infile)
fp = getfp(infile, "rb");
else
fp = stdin;
x = dgetmem(size2 = size + size);
pReal2 = dgetmem(size2 = size + size);
y = x + size;
pImag2 = pReal2 + size;
while (!feof(fp)) {
fillz(x, size2, sizeof(double));
fillz(y, size, sizeof(double));
if (freadf(x, sizeof(*x), size, fp) == 0)
break;
if (out == 'I') {
if (freadf(y, sizeof(*y), size, fp) == 0)
break;
}
dct(x, pReal2, size, size, dftmode, compmode);
fwritef(pReal2, sizeof(*pReal2), size, stdout);
if (out == 'I')
fwritef(pImag2, sizeof(*pReal2), size, stdout);
}
if (infile)
fclose(fp);
return (0);
}
int main(int argc, char *argv[])
{
FILE *fp;
char *s, *infile = NULL, c;
double *x, *y;
double *xp, *yp;
void trans(double *p);
int size2;
int i, k;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc) {
if (*(s = *++argv) == '-') {
c = *++s;
if ((c == 'l' || c == 'm') && (*++s == '\0')) {
s = *++argv;
--argc;
}
switch (c) {
case 'l':
size = atoi(s);
break;
case 'm':
n1 = atoi(s);
if (argc == 1) {
n2 = n1;
} else {
s = *++argv;
argc--;
if ((*s >= '0') && (*s <= '9')) {
n2 = atoi(s);
} else {
n2 = n1;
s = *--argv;
argc++;
}
}
break;
case 't':
case 'c':
case 'q':
if ((c == 't') || (*++s == 't'))
outopt = 1;
if ((c == 'c') || (*s == 'c'))
outopt = 2;
if (c == 'q')
outopt = -1;
break;
case 'a':
case 'i':
case 'p':
case 'r':
c -= ('a' - 'A');
case 'A':
case 'P':
case 'I':
case 'R':
out = c;
break;
case 'h':
default:
usage();
}
} else
infile = s;
}
if (n1 > size) {
fprintf(stderr,
"%s : Region size %d should be less than the FFT size %d!\n",
cmnd, n1, size);
return (1);
}
if (n2 > size) {
fprintf(stderr,
"%s : Region size %d should be less than the FFT size %d!\n",
cmnd, n2, size);
return (1);
}
if (infile)
fp = getfp(infile, "rb");
else
fp = stdin;
size2 = size * size;
x = dgetmem(2 * size2);
y = x + size2;
while (!feof(fp)) {
if (n1) {
for (xp = x, k = n2; --k >= 0; xp += size) {
if (freadf(xp, sizeof(*x), n1, fp) != n1)
return (-1);
if (n1 < size)
fillz(xp + n1, sizeof(*x), size - n1);
}
for (yp = y, k = n2; --k >= 0; yp += size) {
if (freadf(yp, sizeof(*y), n1, fp) != n1)
return (-1);
if (n1 < size)
fillz(yp + n1, sizeof(*x), size - n1);
}
} else {
if ((k = freadf(x, sizeof(*x), 2 * size2, fp)) == 0)
break;
n2 = n1 = sqrt((double) k / 2);
if (k != n1 * n1 * 2) {
fprintf(stderr, "%s : Region of support is not square!\n", cmnd);
return (-1);
}
if (n1 < size) {
fillz(yp = y + size * n1, sizeof(*x), size * (size - n1));
yp -= (size - n1);
xp = x + k;
for (k = n1; --k >= 0; yp -= (size - n1)) {
fillz(yp, sizeof(*x), size - n1);
for (i = n1; --i >= 0;)
*--yp = *--xp;
}
fillz(yp = x + size * n1, sizeof(*x), size * (size - n1));
yp -= (size - n1);
for (k = n1; --k >= 0; yp -= (size - n1)) {
fillz(yp, sizeof(*x), size - n1);
for (i = n1; --i >= 0;)
*--yp = *--xp;
}
}
}
fft2(x, y, size);
if (out == 'P')
for (k = 0; k < size2; k++)
x[k] = x[k] * x[k] + y[k] * y[k];
else if (out == 'A')
for (k = 0; k < size2; k++)
x[k] = sqrt(x[k] * x[k] + y[k] * y[k]);
if (out != 'I') {
if (outopt)
trans(x);
else
fwritef(x, sizeof(*x), size2, stdout);
}
if ((out == ' ') || (out == 'I')) {
if (outopt)
trans(y);
else
fwritef(y, sizeof(*y), size2, stdout);
}
}
free(x);
return 0;
}
void lsp2lpc(double *lsp, double *a, const int m)
{
int i, k, mh1, mh2, flag_odd;
double xx, xf, xff;
static double *f = NULL, *p, *q, *a0, *a1, *a2, *b0, *b1, *b2;
static int size;
flag_odd = 0;
if (m % 2 == 0)
mh1 = mh2 = m / 2;
else {
mh1 = (m + 1) / 2;
mh2 = (m - 1) / 2;
flag_odd = 1;
}
if (f == NULL) {
f = dgetmem(5 * m + 6);
p = f + m;
q = p + mh1;
a0 = q + mh2;
a1 = a0 + (mh1 + 1);
a2 = a1 + (mh1 + 1);
b0 = a2 + (mh1 + 1);
b1 = b0 + (mh2 + 1);
b2 = b1 + (mh2 + 1);
size = m;
}
if (m > size) {
free(f);
f = dgetmem(5 * m + 6);
p = f + m;
q = p + mh1;
a0 = q + mh2;
a1 = a0 + (mh1 + 1);
a2 = a1 + (mh1 + 1);
b0 = a2 + (mh1 + 1);
b1 = b0 + (mh2 + 1);
b2 = b1 + (mh2 + 1);
size = m;
}
movem(lsp, f, sizeof(*lsp), m);
fillz(a0, sizeof(*a0), mh1 + 1);
fillz(b0, sizeof(*b0), mh2 + 1);
fillz(a1, sizeof(*a1), mh1 + 1);
fillz(b1, sizeof(*b1), mh2 + 1);
fillz(a2, sizeof(*a2), mh1 + 1);
fillz(b2, sizeof(*b2), mh2 + 1);
/* lsp filter parameters */
for (i = k = 0; i < mh1; i++, k += 2)
p[i] = -2.0 * cos(PI2 * f[k]);
for (i = k = 0; i < mh2; i++, k += 2)
q[i] = -2.0 * cos(PI2 * f[k + 1]);
/* impulse response of analysis filter */
xx = 1.0;
xf = xff = 0.0;
for (k = 0; k <= m; k++) {
if (flag_odd) {
a0[0] = xx;
b0[0] = xx - xff;
xff = xf;
xf = xx;
} else {
a0[0] = xx + xf;
b0[0] = xx - xf;
xf = xx;
}
for (i = 0; i < mh1; i++) {
a0[i + 1] = a0[i] + p[i] * a1[i] + a2[i];
a2[i] = a1[i];
a1[i] = a0[i];
}
for (i = 0; i < mh2; i++) {
b0[i + 1] = b0[i] + q[i] * b1[i] + b2[i];
b2[i] = b1[i];
b1[i] = b0[i];
}
if (k != 0)
a[k - 1] = -0.5 * (a0[mh1] + b0[mh2]);
xx = 0.0;
}
for (i = m - 1; i >= 0; i--)
a[i + 1] = -a[i];
a[0] = 1.0;
return;
}
int main(int argc, char **argv)
{
int m = ORDER, period = PERIOD, i, j, pd = PADEORD;
FILE *fp = stdin, *fpe = NULL;
Boolean aveflag = AVEFLAG;
double lambda = LAMBDA, step = STEP, tau = TAU, eps = EPS,
*c, *e, *ep, *cc, *d, *avec, x, ll, gg, tt, mu, ttx;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
lambda = atof(*++argv);
--argc;
break;
case 't':
tau = atof(*++argv);
--argc;
break;
case 'k':
step = atof(*++argv);
--argc;
break;
case 'm':
m = atoi(*++argv);
--argc;
break;
case 'p':
period = atoi(*++argv);
--argc;
break;
case 's':
aveflag = 1 - aveflag;
break;
case 'P':
pd = atoi(*++argv);
--argc;
break;
case 'e':
eps = atof(*++argv);
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fpe = getfp(*argv, "wb");
if ((pd < 4) || (pd > 5)) {
fprintf(stderr, "%s : Order of Pade approximation should be 4 or 5!\n",
cmnd);
return (1);
}
c = dgetmem(5 * (m + 1) + (m + 1) * pd * 2);
cc = c + m + 1;
e = cc + m + 1;
ep = e + m + 1;
avec = ep + m + 1;
d = avec + m + 1;
j = period;
ll = 1.0 - lambda;
gg = 1.0;
step /= (double) m;
tt = 2 * (1.0 - tau);
while (freadf(&x, sizeof(x), 1, fp) == 1) {
for (i = 1; i <= m; i++)
cc[i] = -c[i];
x = lmadf(x, cc, m, pd, d);
for (i = m; i >= 1; i--)
e[i] = e[i - 1];
e[0] = x;
gg = gg * lambda + ll * e[0] * e[0];
c[0] = 0.5 * log(gg);
gg = (gg < eps) ? eps : gg;
mu = step / gg;
ttx = tt * e[0];
for (i = 1; i <= m; i++) {
ep[i] = tau * ep[i] - ttx * e[i];
c[i] -= mu * ep[i];
}
if (aveflag)
for (i = 0; i <= m; i++)
avec[i] += c[i];
if (fpe != NULL)
fwritef(&x, sizeof(x), 1, fpe);
if (--j == 0) {
j = period;
if (aveflag) {
for (i = 0; i <= m; i++)
avec[i] /= period;
fwritef(avec, sizeof(*avec), m + 1, stdout);
fillz(avec, sizeof(*avec), m + 1);
} else
fwritef(c, sizeof(*c), m + 1, stdout);
}
}
return (0);
}
void lbg(double *x, const int l, const int tnum, double *icb, int icbsize,
double *cb, const int ecbsize, const int iter, const int mintnum,
const int seed, const int centup, const double delta, const double end)
{
int i, j, k, it, maxindex, tnum1, tnum2;
static int *cntcb, *tindex, size, sizex, sizecb;
unsigned long next = SEED;
double d0, d1, dl, err, tmp, rand;
static double *cb1 = NULL;
double *p, *q, *r;
if (cb1 == NULL) {
cb1 = dgetmem(ecbsize * l);
tindex = (int *) dgetmem(tnum);
cntcb = (int *) dgetmem(ecbsize);
size = l;
sizex = tnum;
sizecb = ecbsize;
}
if (l > size) {
free(cb1);
cb1 = dgetmem(ecbsize * l);
size = l;
}
if (tnum > sizex) {
free(tindex);
tindex = (int *) dgetmem(tnum);
sizex = tnum;
}
if (sizecb > ecbsize) {
free(cb1);
free(cntcb);
cb1 = dgetmem(ecbsize * l);
cntcb = (int *) dgetmem(ecbsize);
}
movem(icb, cb, sizeof(*icb), icbsize * l);
if (seed != 1)
next = srnd((unsigned int) seed);
for (; icbsize * 2 <= ecbsize;) {
q = cb;
r = cb + icbsize * l;
for (i = 0; i < icbsize; i++) {
for (j = 0; j < l; j++) {
dl = delta * nrandom(&next);
*r = *q - dl;
r++;
*q = *q + dl;
q++;
}
}
icbsize *= 2;
d0 = MAXVALUE;
for (it = 1; it <= iter; it++) {
fillz((double *) cntcb, sizeof(*cntcb), icbsize);
d1 = 0.0;
p = x;
for (i = 0; i < tnum; i++, p += l) {
tindex[i] = vq(p, cb, l, icbsize);
cntcb[tindex[i]]++;
q = cb + tindex[i] * l;
d1 += edist(p, q, l);
}
d1 /= tnum;
err = abs((d0 - d1) / d1);
if (err < end)
break;
d0 = d1;
fillz(cb1, sizeof(*cb), icbsize * l);
p = x;
for (i = 0; i < tnum; i++) {
q = cb1 + tindex[i] * l;
for (j = 0; j < l; j++)
*q++ += *p++;
}
k = maxindex = 0;
for (i = 0; i < icbsize; i++)
if (cntcb[i] > k) {
k = cntcb[i];
maxindex = i;
}
q = cb;
r = cb1;
for (i = 0; i < icbsize; i++, r += l, q += l)
if (cntcb[i] >= mintnum)
for (j = 0; j < l; j++)
q[j] = r[j] / (double) cntcb[i];
else {
if (centup == 1) {
p = cb + maxindex * l;
for (j = 0; j < l; j++) {
rand = nrandom(&next);
q[j] = p[j] + delta * rand;
p[j] = p[j] - delta * rand;
}
} else if (centup == 2) {
if (i < icbsize / 2) {
p = q + icbsize / 2 * l;
tnum1 = cntcb[i];
tnum2 = cntcb[i + icbsize / 2];
for (j = 0; j < l; j++) {
tmp = (tnum2 * q[j] + tnum1 * p[j]) / (tnum1 + tnum2);
rand = nrandom(&next);
q[j] = tmp + delta * rand;
p[j] = tmp - delta * rand;
}
} else {
p = q - icbsize / 2 * l;
tnum1 = cntcb[i];
tnum2 = cntcb[i - icbsize / 2];
for (j = 0; j < l; j++) {
tmp = (tnum2 * q[j] + tnum1 * p[j]) / (tnum1 + tnum2);
rand = nrandom(&next);
q[j] = tmp + delta * rand;
p[j] = tmp - delta * rand;
}
}
}
}
}
if (icbsize == ecbsize)
break;
}
return;
}
double mlsacheck(double *in, double *out, int m, int fftlen,
double a, double r, int c)
{
int i;
double gain, *x, *y, *mag = NULL, max = 0.0;
x = dgetmem(fftlen);
y = dgetmem(fftlen);
fillz(x, sizeof(*x), fftlen);
fillz(y, sizeof(*y), fftlen);
/* calculate gain factor */
for (i = 0, gain = 0.0; i <= m; i++) {
x[i] = in[i];
gain += x[i] * pow(-a, i);
}
/* gain normalization */
x[0] -= gain;
/* check stability */
if (c != 1 && c != 4) { /* usual mode */
mag = dgetmem(fftlen);
fillz(mag, sizeof(*mag), fftlen);
fftr(x, y, fftlen);
for (i = 0; i < fftlen; i++) {
mag[i] = sqrt(x[i] * x[i] + y[i] * y[i]);
if (mag[i] > max)
max = mag[i];
}
} else { /* fast mode */
for (i = 0; i <= m; i++)
max += x[i];
}
/* modify MLSA filter coefficients */
if (c == 0 || c == 1 || max <= r) {
memcpy(out, in, sizeof(*out) * (m + 1));
} else {
if (c == 2) { /* clipping */
for (i = 0; i < fftlen; i++) {
if (mag[i] > r) {
x[i] *= r / mag[i];
y[i] *= r / mag[i];
}
}
ifft(x, y, fftlen);
x[0] += gain;
memcpy(out, x, sizeof(*out) * (m + 1));
} else if (c == 3) { /* scaling */
for (i = 0; i < fftlen; i++) {
x[i] *= r / max;
y[i] *= r / max;
}
ifft(x, y, fftlen);
x[0] += gain;
memcpy(out, x, sizeof(*out) * (m + 1));
} else if (c == 4) { /* fast mode */
for (i = 0; i <= m; i++)
x[i] *= r / max;
x[0] += gain;
memcpy(out, x, sizeof(*out) * (m + 1));
}
}
free(x);
free(y);
if (c != 1 && c != 4) {
free(mag);
}
return max;
}
int main(int argc, char **argv)
{
int m = ORDER, period = PERIOD, stage = STAGE, i, j;
FILE *fp = stdin, *fpe = NULL;
Boolean ave = AVERAGE, norm = NORM;
double lambda = LAMBDA, step = STEP, eps = EPS,
*c, *cc, *eg, *ep, *d, *avec, tau = TAU,
x, ee, ll, gg, mu, gamma, tt, ttx;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
lambda = atof(*++argv);
--argc;
break;
case 't':
tau = atof(*++argv);
--argc;
break;
case 'k':
step = atof(*++argv);
--argc;
break;
case 'm':
m = atoi(*++argv);
--argc;
break;
case 'c':
stage = atoi(*++argv);
--argc;
break;
case 'p':
period = atoi(*++argv);
--argc;
break;
case 's':
ave = 1 - ave;
break;
case 'n':
norm = 1 - norm;
break;
case 'e':
eps = atof(*++argv);
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fpe = getfp(*argv, "wb");
if (stage == 0) {
fprintf(stderr, "%s : gamma should not equal to 0!\n", cmnd);
usage(1);
}
gamma = -1.0 / (double) stage;
c = dgetmem(5 * (m + 1) + m * stage);
cc = c + m + 1;
eg = cc + m + 1;
ep = eg + m + 1;
avec = ep + m + 1;
d = avec + m + 1;
j = period;
ll = 1.0 - lambda;
gg = 1.0;
ee = 1.0;
step /= (double) m;
tt = 2 * (1.0 - tau);
while (freadf(&x, sizeof(x), 1, fp) == 1) {
eg[m] = d[stage * m - 1];
x = iglsadf1(x, c, m, stage, d);
movem(d + (stage - 1) * m, eg, sizeof(*d), m);
gg = lambda * gg + ll * eg[0] * eg[0];
gg = (gg < eps) ? eps : gg;
mu = step / gg;
ttx = tt * x;
for (i = 1; i <= m; i++) {
ep[i] = tau * ep[i] - ttx * eg[i];
c[i] -= mu * ep[i];
}
ee = lambda * ee + ll * x * x;
c[0] = sqrt(ee);
if (ave)
for (i = 0; i <= m; i++)
avec[i] += c[i];
if (fpe != NULL)
fwritef(&x, sizeof(x), 1, fpe);
if (--j == 0) {
j = period;
if (ave) {
for (i = 0; i <= m; i++)
avec[i] /= period;
if (!norm)
ignorm(avec, cc, m, gamma);
fwritef(cc, sizeof(*cc), m + 1, stdout);
fillz(avec, sizeof(*avec), m + 1);
} else if (!norm) {
ignorm(c, cc, m, gamma);
fwritef(cc, sizeof(*cc), m + 1, stdout);
} else
fwritef(c, sizeof(*c), m + 1, stdout);
}
}
return (0);
}
int main(int argc, char **argv)
{
int leng = LENG, m = ORDER, start = 0, end = 0, otype = OTYPE, i, no;
FILE *fp = stdin;
char phase = PHASE;
double logk, *x, *y, *c;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'm':
m = atoi(*++argv);
--argc;
break;
case 'l':
leng = atoi(*++argv);
--argc;
break;
case 'p':
phase = 1 - phase;
break;
case 'o':
otype = atoi(*++argv);
--argc;
break;
case 's':
start = atoi(*++argv);
--argc;
break;
case 'e':
end = atoi(*++argv);
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
if (end == 0)
end = m;
x = dgetmem(leng * 2);
y = x + leng;
c = dgetmem(m + 1);
no = leng / 2 + 1;
logk = 20.0 / log(10.0);
while (freadf(c, sizeof(*c), m + 1, fp) == m + 1) {
fillz(c, sizeof(*c), start);
for (i = end + 1; i <= m; i++)
c[i] = 0.0;
c2sp(c, m, x, y, leng);
if (phase)
switch (otype) {
case 1:
for (i = no; i--;)
x[i] = y[i];
break;
case 2:
for (i = no; i--;)
x[i] = y[i] * 180 / PI;
break;
default:
for (i = no; i--;)
x[i] = y[i] / PI;
break;
} else
switch (otype) {
case 1:
break;
case 2:
for (i = no; i--;)
x[i] = exp(x[i]);
break;
default:
for (i = no; i--;)
x[i] *= logk;
break;
}
fwritef(x, sizeof(*x), no, stdout);
}
return (0);
}
int main(int argc, char **argv)
{
int freq = FREQ, n = ILNG, l, L = LOW, H = HIGH, m, itr1 = MINITR, itr2 =
MAXITR, low, high;
double *x, eps = EPS, p, thresh = THRESH, end = END;
FILE *fp = stdin;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 's':
freq = atoi(*++argv);
--argc;
break;
case 'l':
n = atoi(*++argv);
--argc;
break;
case 't':
thresh = atof(*++argv);
--argc;
break;
case 'L':
L = atoi(*++argv);
--argc;
break;
case 'H':
H = atoi(*++argv);
--argc;
break;
case 'e':
eps = atof(*++argv);
--argc;
break;
case 'i':
itr1 = atoi(*++argv);
--argc;
case 'j':
itr2 = atoi(*++argv);
--argc;
case 'd':
end = atof(*++argv);
--argc;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
low = freq * 1000 / H;
high = freq * 1000 / L;
m = (freq * 25) / 10;
l = 1;
while (l < n)
l += l;
x = dgetmem(l);
while (freadf(x, sizeof(*x), n, fp) == n) {
fillz(x + n, l - n, sizeof(double));
p = pitch(x, l, thresh, low, high, eps, m, itr1, itr2, end);
fwritef(&p, sizeof(p), 1, stdout);
}
return (0);
}
int gcep(double *xw, const int flng, double *gc, const int m, const double g,
const int itr1, const int itr2, const double d, const double e,
const double f, const int itype)
{
int i, j, flag = 0;
double t, s, dd = 0.0;
static double *x = NULL, *y, *cr, *ci, *rr, *hr, *hi, *er, *ei;
static int size;
if (x == NULL) {
x = dgetmem(9 * flng);
size = flng;
y = x + flng;
cr = y + flng;
ci = cr + flng;
rr = ci + flng;
hr = rr + flng;
hi = hr + flng;
er = hi + flng;
ei = er + flng;
}
if (flng > size) {
free(x);
x = dgetmem(9 * flng);
size = flng;
y = x + flng;
cr = y + flng;
ci = cr + flng;
rr = ci + flng;
hr = rr + flng;
hi = hr + flng;
er = hi + flng;
ei = er + flng;
}
movem(xw, x, sizeof(*x), flng);
switch (itype) {
case 0: /* windowed data sequence */
fftr(x, y, flng);
for (i = 0; i < flng; i++) {
x[i] = x[i] * x[i] + y[i] * y[i] + e; /* periodegram */
}
break;
case 1: /* dB */
for (i = 0; i <= flng / 2; i++) {
x[i] /= 20.0 / log(10.0); /* dB -> amplitude spectrum */
x[i] = x[i] * x[i] + e; /* amplitude -> periodgram */
}
break;
case 2: /* log */
for (i = 0; i <= flng / 2; i++) {
x[i] = exp(x[i]); /* log -> amplitude spectrum */
x[i] = x[i] * x[i] + e; /* amplitude -> periodgram */
}
break;
case 3: /* amplitude */
for (i = 0; i <= flng / 2; i++) {
x[i] = x[i] * x[i] + e; /* amplitude -> periodgram */
}
break;
case 4: /* periodgram */
for (i = 0; i <= flng / 2; i++) {
x[i] = x[i] + e;
}
break;
default:
fprintf(stderr, "mgcep : Input type %d is not supported!\n", itype);
exit(1);
}
if (itype > 0) {
for (i = 1; i < flng / 2; i++)
x[flng - i] = x[i];
}
for (i = 0; i < flng; i++)
cr[i] = log(x[i]);
/* initial value of generalized cepstrum */
ifftr(cr, y, flng); /* x : IFFT[x] */
cr[0] = exp(cr[0] / 2);
gc2gc(cr, m, 0.0, gc, m, g); /* gc : generalized cepstrum */
/* Newton-Raphson method */
for (j = 1; j <= itr2; j++) {
fillz(cr, sizeof(*cr), flng);
movem(&gc[1], &cr[1], sizeof(*cr), m);
fftr(cr, ci, flng); /* cr+jci : FFT[gc] */
for (i = 0; i < flng; i++) {
t = x[i] / agexp(g, cr[i], ci[i]);
cr[i] = 1 + g * cr[i];
ci[i] = g * ci[i];
s = cr[i] * cr[i] + ci[i] * ci[i];
rr[i] = t / s;
hr[i] = (cr[i] * cr[i] - ci[i] * ci[i]) * t / (s * s);
hi[i] = 2 * cr[i] * ci[i] * t / (s * s);
er[i] = cr[i] * t / s;
ei[i] = ci[i] * t / s;
}
ifftr(rr, y, flng); /* rr : r(k) */
ifft(hr, hi, flng); /* hr : h(k) */
ifft(er, ei, flng); /* er : e(k) */
s = gc[0]; /* gc[0] : gain */
for (i = 1, t = 0.0; i <= m; i++)
t += er[i] * gc[i];
t = er[0] + g * t;
t = sqrt(fabs(t));
if (j >= itr1) {
if (fabs((t - dd) / t) < d) {
flag = 1;
break;
}
dd = t;
}
for (i = 2; i <= m + m; i++)
hr[i] *= 1 + g;
if (theq(rr, &hr[2], &y[1], &er[1], m, f)) {
fprintf(stderr, "gcep : Error in theq() at %dth iteration!\n", j);
exit(1);
}
gc[0] = t;
for (i = 1; i <= m; i++)
gc[i] += y[i];
}
if (flag)
return (0);
else
return (-1);
}
int main(int argc, char *argv[])
{
FILE *fp = stdin, *fpc;
char *coef = NULL;
double *x = NULL, *dx = NULL, **dw_coef = NULL, *y = NULL;
int i, j, l, d, t, tj, ispipe, fsize, leng = LENG, total = T;
int dw_num = 1, **dw_width = NULL, dw_calccoef = -1, dw_coeflen = 1,
dw_leng = 1;
char **dw_fn = (char **) calloc(sizeof(char *), argc);
int non_magic_num, win_size_forward[2], win_size_backward[2];
float_list *top, *cur, *prev, *tmpf;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc) {
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'd':
if (dw_calccoef == 1 || dw_calccoef == 2) {
fprintf(stderr,
"%s : Options '-r' and '-d' should not be defined simultaneously!\n",
cmnd);
return (1);
}
dw_calccoef = 0;
if (isfloat(*++argv)) {
dw_coeflen = 0;
for (i = 0; (i < argc - 1) && isfloat(argv[i]); i++) {
dw_coeflen += strlen(argv[i]) + 1;
}
dw_coeflen += 1;
coef = dw_fn[dw_num] = getmem(dw_coeflen, sizeof(char));
for (j = 0; j < i; j++) {
sprintf(coef, " %s", *argv);
coef += strlen(*argv) + 1;
if (j < i - 1) {
argv++;
argc--;
}
}
} else {
dw_fn[dw_num] = *argv;
}
dw_num++;
--argc;
break;
case 'r':
if (dw_calccoef == 0 || dw_calccoef == 2) {
fprintf(stderr,
"%s : Options '-r' and '-d' should not be defined simultaneously!\n",
cmnd);
return (1);
}
dw_calccoef = 1;
dw_coeflen = atoi(*++argv);
--argc;
if ((dw_coeflen != 1) && (dw_coeflen != 2)) {
fprintf(stderr,
"%s : Number of delta parameter should be 1 or 2!\n",
cmnd);
return (1);
}
if (argc <= 1) {
fprintf(stderr,
"%s : Window size for delta parameter required!\n",
cmnd);
return (1);
}
dw_fn[dw_num] = *++argv;
dw_num++;
--argc;
if (dw_coeflen == 2) {
if (argc <= 1) {
fprintf(stderr,
"%s : Window size for delta-delta parameter required!\n",
cmnd);
return (1);
}
dw_fn[dw_num] = *++argv;
dw_num++;
--argc;
}
break;
case 'm':
leng = atoi(*++argv) + 1;
--argc;
break;
case 'l':
leng = atoi(*++argv);
--argc;
break;
case 'R':
if (dw_calccoef == 0 || dw_calccoef == 1) {
fprintf(stderr,
"%s : Options '-r', '-d' and '-R' should not be defined simultaneously!\n",
cmnd);
return (1);
}
dw_calccoef = 2;
dw_num = atoi(*++argv) + 1;
--argc;
if ((dw_num != 2) && (dw_num != 3)) {
fprintf(stderr,
"%s : Number of delta parameter should be 1 or 2!\n",
cmnd);
return (1);
}
if (argc <= 1) {
fprintf(stderr,
"%s : Window size for delta-delta parameter required!\n",
cmnd);
return (1);
}
sscanf(*++argv, "%d", &win_size_forward[0]);
--argc;
sscanf(*++argv, "%d", &win_size_backward[0]);
--argc;
if (dw_num > 2) {
sscanf(*++argv, "%d", &win_size_forward[1]);
--argc;
sscanf(*++argv, "%d", &win_size_backward[1]);
--argc;
}
break;
case 'M':
sscanf(*++argv, "%lf", &magic);
MAGIC = TR;
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
}
/* parse window files */
/* memory allocation */
if ((dw_width = (int **) calloc(dw_num, sizeof(int *))) == NULL) {
fprintf(stderr, "%s : Cannot allocate memory!\n", cmnd);
exit(1);
}
for (i = 0; i < dw_num; i++)
if ((dw_width[i] = (int *) calloc(2, sizeof(int))) == NULL) {
fprintf(stderr, "%s : Cannot allocate memory!\n", cmnd);
exit(1);
}
if ((dw_coef = (double **) calloc(dw_num, sizeof(double *))) == NULL) {
fprintf(stderr, "%s : Cannot allocate memory!\n", cmnd);
exit(1);
}
/* window for static parameter */
dw_width[0][0] = dw_width[0][1] = 0;
dw_coef[0] = dgetmem(1);
dw_coef[0][0] = 1;
/* set delta coefficients */
if (dw_calccoef == 0) {
for (i = 1; i < dw_num; i++) {
if (dw_fn[i][0] == ' ') {
fsize = str2darray(dw_fn[i], &(dw_coef[i]));
} else {
/* read from file */
fpc = getfp(dw_fn[i], "rb");
/* check the number of coefficients */
fseek(fpc, 0L, 2);
fsize = ftell(fpc) / sizeof(real);
fseek(fpc, 0L, 0);
/* read coefficients */
dw_coef[i] = dgetmem(fsize);
freadf(dw_coef[i], sizeof(**(dw_coef)), fsize, fpc);
}
/* set pointer */
dw_leng = fsize / 2;
dw_coef[i] += dw_leng;
dw_width[i][0] = -dw_leng;
dw_width[i][1] = dw_leng;
if (fsize % 2 == 0)
dw_width[i][1]--;
}
} else if (dw_calccoef == 1) {
int a0, a1, a2;
for (i = 1; i < dw_num; i++) {
dw_leng = atoi(dw_fn[i]);
if (dw_leng < 1) {
fprintf(stderr,
"%s : Width for regression coefficient shuould be more than 1!\n",
cmnd);
exit(1);
}
dw_width[i][0] = -dw_leng;
dw_width[i][1] = dw_leng;
dw_coef[i] = dgetmem(dw_leng * 2 + 1);
dw_coef[i] += dw_leng;
}
dw_leng = atoi(dw_fn[1]);
for (a1 = 0, j = -dw_leng; j <= dw_leng; a1 += j * j, j++);
for (j = -dw_leng; j <= dw_leng; j++)
dw_coef[1][j] = (double) j / (double) a1;
if (dw_num > 2) {
dw_leng = atoi(dw_fn[2]);
for (a0 = a1 = a2 = 0, j = -dw_leng; j <= dw_leng;
a0++, a1 += j * j, a2 += j * j * j * j, j++);
for (j = -dw_leng; j <= dw_leng; j++)
dw_coef[2][j] =
2 * ((double) (a0 * j * j - a1)) /
((double) (a2 * a0 - a1 * a1));
}
}
/* -- Count number of input vectors and read -- */
x = dgetmem(leng);
top = prev = (float_list *) malloc(sizeof(float_list));
top->f = (float *) malloc(sizeof(float) * leng);
total = 0;
prev->next = NULL;
while (freadf(x, sizeof(*x), leng, fp) == leng) {
cur = (float_list *) malloc(sizeof(float_list));
cur->f = (float *) malloc(sizeof(float) * leng);
for (i = 0; i < leng; i++) {
cur->f[i] = (float) x[i];
}
total++;
prev->next = cur;
cur->next = NULL;
prev = cur;
}
free(x);
x = dgetmem(leng * total);
dx = dgetmem(dw_num * leng * total);
fillz(dx, sizeof(*x), dw_num * leng * total);
for (i = 0, tmpf = top->next; tmpf != NULL; i++, tmpf = tmpf->next) {
for (j = 0; j < leng; j++) {
x[i * leng + j] = tmpf->f[j];
}
}
if (dw_calccoef == 0 || dw_calccoef == 1) {
/* calculate delta and delta-delta */
for (t = 0; t < total; t++) {
for (d = 0; d < dw_num; d++) {
for (j = dw_width[d][0]; j <= dw_width[d][1]; j++) {
tj = t + j;
if (tj < 0)
tj = 0;
if (!(tj < total))
tj = total - 1;
for (l = 0; l < leng; l++)
dx[dw_num * leng * t + leng * d + l] +=
dw_coef[d][j] * x[leng * tj + l];
}
}
}
/* output static, delta, delta-delta */
fwritef(dx, sizeof(*dx), dw_num * total * leng, stdout);
} else if (dw_calccoef == 2) {
int *position = (int *) malloc(sizeof(int) * total);
/* skip magic number */
if (MAGIC == TR) {
for (t = 0, non_magic_num = 0; t < total; t++) {
for (l = 0; l < leng; l++) {
if (x[leng * t + l] == magic) {
break;
}
}
if (l == leng) {
/* remember position of non-magic number */
position[non_magic_num] = t;
non_magic_num++;
}
}
} else {
for (t = 0; t < total; t++) {
position[t] = t;
}
non_magic_num = total;
}
/* calculate delta and delta-delta */
GetCoefficient(x, dx, dw_num, position, total, non_magic_num, leng,
win_size_forward, win_size_backward);
/* output static, delta, delta-delta */
fwritef(dx, sizeof(*dx), dw_num * total * leng, stdout);
}
return (0);
}
