int main(int argc, char **argv)
{
int m = ORDER, m1;
FILE *fp = stdin;
double a = ALPHA, *x;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'a':
a = atof(*++argv);
--argc;
break;
case 'm':
m = 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");
m1 = m + 1;
x = dgetmem(m1);
while (freadf(x, sizeof(*x), m1, fp) == m1) {
b2mc(x, x, m, a);
fwritef(x, sizeof(*x), m1, stdout);
}
return (0);
}
int main(int argc, char **argv)
{
int m = ORDERA, n = ORDERC;
FILE *fp = stdin;
double *c, *a;
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 'M':
n = 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");
a = dgetmem(m + n + 2);
c = a + m + 1;
while (freadf(a, sizeof(*a), m + 1, fp) == m + 1) {
lpc2c(a, m, c, n);
fwritef(c, sizeof(*c), n + 1, stdout);
}
return (0);
}
void main(int argc, char **argv)
{
int m = ORDER, i;
FILE *fp = stdin;
double *x, k;
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 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c' !\n", cmnd, *(*argv+1));
usage(1);
}
}
else
fp = getfp(*argv, "r");
x = dgetmem(m+1);
while(freadf(x, sizeof(*x), m+1, fp) == m+1){
norm0(x, x, m);
fwritef(x, sizeof(*x), m+1, stdout);
}
exit(0);
}
int main(int argc, char **argv)
{
int m = DEF_M;
FILE *fp = stdin;
double *csm, *r;
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 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
csm = dgetmem(2 * m + 2 * m);
r = csm + 2 * m;
while (freadf(csm, sizeof(*csm), 2 * m, fp) == 2 * m) {
csm2acr(csm, r, m);
fwritef(r, sizeof(*r), 2 * m, stdout);
}
return 0;
}
int main(int argc, char *argv[])
{
FILE *fp;
char *s, *infile = NULL, c;
int size2;
double *x, *y;
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':
case 'r':
c -= ('a' - 'A');
case 'I':
case 'R':
out = c;
break;
case 'h':
default:
usage();
}
} else
infile = s;
}
fp = stdin;
if (infile) {
fp = getfp(infile, "rb");
}
x = dgetmem(size2 = size + size);
y = x + size;
while (!feof(fp)) {
if (freadf(x, sizeof(*x), size2, fp) != size2)
break;
ifft(x, y, size);
if (out != 'I')
fwritef(x, sizeof(*x), size, stdout);
if (out != 'R')
fwritef(y, sizeof(*y), size, stdout);
}
if (infile) {
fclose(fp);
}
return (0);
}
int main(int argc, char **argv)
{
int m = ORDER, num = 0, otype = OTYPE, i;
FILE *fp = stdin, *fp1 = NULL;
double *x, *y, sub, sum, z = 0.0;
Boolean frame = FRAME;
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 'o':
otype = atoi(*++argv);
--argc;
break;
case 'f':
frame = 1 - frame;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else if (fp1 == NULL)
fp1 = getfp(*argv, "rb");
else
fp = getfp(*argv, "rb");
x = dgetmem(m + m + 2);
y = x + m + 1;
while (freadf(x, sizeof(*x), m + 1, fp) == m + 1
&& freadf(y, sizeof(*y), m + 1, fp1) == m + 1) {
sum = 0.0;
for (i = 1; i <= m; i++) {
sub = x[i] - y[i];
sum += sub * sub;
}
if (otype == 0) {
sum = sqrt(2.0 * sum);
sum *= LN_TO_LOG;
} else if (otype == 2)
sum = sqrt(sum);
if (!frame) {
z += sum;
num++;
} else
fwritef(&sum, sizeof(sum), 1, stdout);
}
if (!frame) {
z = z / (double) num;
fwritef(&z, sizeof(z), 1, stdout);
}
return 0;
}
int main(int argc, char *argv[])
{
FILE *fp = stdin, *fp_eigen = NULL;
int i, j, k, n = PRICOMP_ORDER, leng = LENG, total = -1;
BOOL out_evecFlg = FALSE, out_evalFlg = FALSE;
double sum;
double *buf = NULL;
double *mean = NULL, **var = NULL;
double eps = EPS;
int itemax = ITEMAX;
double **e_vec = NULL, *e_val = NULL; /* eigenvector and eigenvalue */
double *cont_rate = NULL; /* contribution rate */
double jacobi_conv;
float_list *top, *cur, *prev, *tmpf, *tmpff;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if ((**++argv) == '-') {
switch (*(*argv + 1)) {
case 'l':
leng = atoi(*++argv);
--argc;
break;
case 'n':
n = atoi(*++argv);
--argc;
break;
case 'e':
eps = atof(*++argv);
--argc;
break;
case 'i':
itemax = atoi(*++argv);
--argc;
break;
case 'v':
out_evecFlg = TRUE;
break;
case 'V':
out_evalFlg = TRUE;
fp_eigen = getfp(*++argv, "wb");
--argc;
break;
case 'h':
usage(EXIT_SUCCESS);
default:
fprintf(stderr, "%s : Invalid option '%s'!\n", cmnd, *argv);
usage(EXIT_FAILURE);
}
} else
fp = getfp(*argv, "rb");
if (n > leng) {
fprintf(stderr, "\n %s (Error) output number of pricipal component"
" must be less than length of vector.\n", cmnd);
usage(EXIT_FAILURE);
}
/* -- Count number of input vectors and read -- */
buf = dgetmem(leng);
top = prev = (float_list *) malloc(sizeof(float_list));
top->f = fgetmem(leng);
total = 0;
prev->next = NULL;
while (freadf(buf, sizeof(*buf), leng, fp) == leng) {
cur = (float_list *) malloc(sizeof(float_list));
cur->f = fgetmem(leng);
for (i = 0; i < leng; i++) {
cur->f[i] = (float) buf[i];
}
total++;
prev->next = cur;
cur->next = NULL;
prev = cur;
}
free(buf);
buf = dgetmem(total * leng);
for (i = 0, tmpf = top->next; tmpf != NULL; i++, tmpf = tmpff) {
for (j = 0; j < leng; j++) {
buf[i * leng + j] = tmpf->f[j];
}
tmpff = tmpf->next;
free(tmpf->f);
free(tmpf);
}
free(top);
/* PCA */
/* allocate memory for mean vectors and covariance matrix */
mean = dgetmem(leng);
var = malloc_matrix(leng);
/* calculate mean vector */
for (i = 0; i < leng; i++) {
for (j = 0, sum = 0.0; j < total; j++)
sum += buf[i + j * leng];
mean[i] = sum / total;
}
/* calculate cov. mat. */
for (i = 0; i < leng; i++) {
for (j = 0; j < leng; j++) {
sum = 0.0;
for (k = 0; k < total; k++)
sum +=
(buf[i + k * leng] - mean[i]) * (buf[j + k * leng] - mean[j]);
var[i][j] = sum / total;
}
}
/* allocate memory for eigenvector and eigenvalue */
e_vec = malloc_matrix(leng);
e_val = dgetmem(leng);
/* calculate eig.vec. and eig.val. with jacobi method */
if ((jacobi_conv = jacobi(var, leng, eps, e_val, e_vec, itemax)) == -1) {
fprintf(stderr, "Error : matrix is not symmetric.\n");
exit(EXIT_FAILURE);
} else if (jacobi_conv == -2) {
fprintf(stderr, "Error : loop in jacobi method reached %d times.\n",
itemax);
exit(EXIT_FAILURE);
}
/* allocate memory for contribution rate of each eigenvalue */
cont_rate = dgetmem(leng);
/* calculate contribution rate of each eigenvalue */
for (j = 0; j < leng; j++) {
sum = 0.0;
for (i = 0; i < leng; i++)
sum += e_val[i];
cont_rate[j] = e_val[j] / sum;
}
/* end of PCA */
/* output mean vector and eigen vectors */
if (out_evecFlg == TRUE) {
fwritef(mean, sizeof(*mean), leng, stdout);
for (i = 0; i < n; i++)
fwritef(e_vec[i], sizeof(*(e_vec[i])), leng, stdout);
}
/* output eigen values and contribution ratio */
if (out_evalFlg == TRUE) {
for (i = 0; i < n; i++) {
fwritef(e_val + i, sizeof(*e_val), 1, fp_eigen);
fwritef(cont_rate + i, sizeof(*cont_rate), 1, fp_eigen);
}
fclose(fp_eigen);
}
return EXIT_SUCCESS;
}
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);
}
void main(int argc, char **argv)
{
int l = LENG, cbsize = CBSIZE, index;
Boolean qflag = QFLAG;
FILE *fp = stdin, *fpcb = NULL;
double *x, *qx, *cb;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-'){
switch (*(*argv+1)) {
case 'l':
l = atoi(*++argv);
--argc;
break;
case 'n':
l = atoi(*++argv)+1;
--argc;
break;
case 's':
cbsize = atoi(*++argv);
--argc;
break;
case 'q':
qflag = 1 - qflag;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c' !\n", cmnd, *(*argv+1));
usage(1);
}
}
else if (fpcb == NULL)
fpcb = getfp(*argv, "r");
else
fp = getfp(*argv, "r");
fseek(fpcb,0,2);
#ifdef DOUBLE
cbsize = ftell(fpcb)/sizeof(double)/l;
#else
cbsize = ftell(fpcb)/sizeof(float)/l;
#endif
rewind(fpcb);
x = dgetmem(l+l+cbsize*l);
qx = x + l;
cb = qx + l;
if(freadf(cb, sizeof(*cb), cbsize*l, fpcb) != cbsize*l){
fprintf(stderr,"%s : Codebook size error !\n",cmnd);
exit(1);
}
if(! qflag)
while (freadf(x, sizeof(*x), l, fp) == l){
index = vq(x, cb, l, cbsize);
fwrite(&index, sizeof(index), 1, stdout);
}
else
while (freadf(x, sizeof(*x), l, fp) == l){
index = vq(x, cb, l, cbsize);
ivq(index, cb, l, qx);
fwritef(qx, sizeof(*qx), l, stdout);
}
exit(0);
}
int main(int argc, char **argv)
{
int m = ORDER, flng = FLENG, ilng = FLENG, itype = ITYPE,
etype = ETYPE, itr1 = MINITR, itr2 = MAXITR;
FILE *fp = stdin;
double *c, *x, end = END, e = EPS;
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':
flng = atoi(*++argv);
--argc;
break;
case 'q':
itype = atoi(*++argv);
--argc;
break;
case 'i':
itr1 = atoi(*++argv);
--argc;
break;
case 'j':
itr2 = atoi(*++argv);
--argc;
break;
case 'd':
end = atof(*++argv);
--argc;
break;
case 'e':
etype = 1;
e = atof(*++argv);
--argc;
break;
case 'E':
etype = 2;
e = atof(*++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 (itype == 0)
ilng = flng;
else
ilng = flng / 2 + 1;
x = dgetmem(flng + m + 1);
c = x + flng;
while (freadf(x, sizeof(*x), ilng, fp) == ilng) {
uels(x, flng, c, m, itr1, itr2, end, etype, e, itype);
fwritef(c, sizeof(*c), m + 1, stdout);
}
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)
{
int m = ORDER, otype = OTYPE, n = SPNUM, p = MAXITR, i;
FILE *fp = stdin;
double *a, *lsp, end = END, sampling = SAMPLING;
Boolean gain = GAIN, loggain = LOGGAIN;
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 's':
sampling = atof(*++argv);
--argc;
break;
case 'o':
otype = atoi(*++argv);
--argc;
break;
case 'p':
p = atoi(*++argv);
--argc;
break;
case 'n':
n = atoi(*++argv);
--argc;
break;
case 'd':
end = atof(*++argv);
--argc;
break;
case 'k':
gain = 1 - gain;
break;
case 'l':
loggain = 1 - loggain;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
lsp = dgetmem(m + m + 1);
a = lsp + m;
while (freadf(a, sizeof(*a), m + 1, fp) == m + 1) {
lpc2lsp(a, lsp, m, n, p, end);
if (otype == 0)
for (i = 0; i < m; i++)
lsp[i] *= PI2;
else if (otype == 2 || otype == 3)
for (i = 0; i < m; i++)
lsp[i] *= sampling;
if (otype == 3)
for (i = 0; i < m; i++)
lsp[i] *= 1000;
if (gain) {
if (loggain)
*a = log(*a);
fwritef(a, sizeof(*a), 1, stdout);
}
fwritef(lsp, sizeof(*lsp), m, stdout);
}
return (0);
}
int main(int argc, char **argv)
{
int l = LENG, normal = NORMAL;
double zero, pulse, period = PERIOD, i;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
l = atoi(*++argv);
--argc;
break;
case 'p':
period = atof(*++argv);
--argc;
break;
case 'n':
normal = atoi(*++argv);
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
}
switch (normal) {
case 0:
pulse = 1;
break;
case 1:
pulse = sqrt(period);
break;
case 2:
pulse = period;
break;
}
zero = 0.0;
i = 0.5;
if (period >= 1.0)
while (l--)
if (--i >= 0.0)
fwritef(&zero, sizeof(zero), 1, stdout);
else {
i += period;
fwritef(&pulse, sizeof(pulse), 1, stdout);
} else if (period != 0.0) {
fprintf(stderr, "-p : frame period must be 0.0 or more than 1.0!\n");
usage(1);
} else
while (l--) {
pulse = mseq();
fwritef(&pulse, sizeof(pulse), 1, stdout);
}
return (0);
}
int main(int argc, char **argv)
{
int m = ORDER, itype = ITYPE, i, gain = GAIN;
FILE *fp = stdin;
double *a, *lsp, sampling = SAMPLING;
Boolean loggain = LOGGAIN;
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 's':
sampling = atof(*++argv);
--argc;
break;
case 'k':
gain = 0;
break;
case 'l':
case 'L':
loggain = TR;
break;
case 'i':
case 'q':
itype = 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");
lsp = dgetmem(m + m + 1 + gain);
a = lsp + m + gain;
while (freadf(lsp, sizeof(*lsp), m + gain, fp) == m + gain) {
if (itype == 0)
for (i = gain; i < m + gain; i++)
lsp[i] /= PI2;
else if (itype == 2 || itype == 3)
for (i = gain; i < m + gain; i++)
lsp[i] /= sampling;
if (itype == 3)
for (i = gain; i < m + gain; i++)
lsp[i] /= 1000;
lsp2lpc(lsp + gain, a, m);
if (gain) {
if (loggain)
*lsp = exp(*lsp);
fwritef(lsp, sizeof(*lsp), 1, stdout);
}
fwritef(a + gain, sizeof(*a), m + 1 - gain, stdout);
}
return (0);
}
int main(int argc, char **argv)
{
int m = ORDER, pd = PADEORDER, fftlen = FFTLENGTH, stable_condition =
STABLE1, frame = 0, c = 0;
double *in, *out, max, a = ALPHA, r = PADE4_THRESH1, R = 0.0;
FILE *fp = stdin;
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 'a':
a = atof(*++argv);
--argc;
break;
case 'P':
pd = atoi(*++argv);
--argc;
break;
case 'l':
fftlen = atoi(*++argv);
--argc;
break;
case 'c':
c = atoi(*++argv);
if ((c != 0 && c != 1 && c != 2 && c != 3 && c != 4)
|| isdigit(**argv) == 0) {
fprintf(stderr,
"%s : '-c' option must be specified with 0, 1, 2, 3 or 4.\n",
cmnd);
usage(1);
}
--argc;
break;
case 'r':
stable_condition = atoi(*++argv);
if (stable_condition != STABLE1 && stable_condition != STABLE2) {
fprintf(stderr,
"%s : '-r' option must be specified with %d or %d.\n",
cmnd, STABLE1, STABLE2);
usage(1);
}
--argc;
break;
case 'R':
R = atof(*++argv);
if (isdigit(**argv) == 0) {
fprintf(stderr,
"%s : '-R' option must be specified by real number !\n",
cmnd);
usage(1);
}
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else {
fp = getfp(*argv, "rb");
}
}
switch (pd) {
case 4:
if (stable_condition == STABLE1)
r = PADE4_THRESH1;
else
r = PADE4_THRESH2;
break;
case 5:
if (stable_condition == STABLE1)
r = PADE5_THRESH1;
else
r = PADE5_THRESH2;
break;
default:
fprintf(stderr, "%s : Order of Pade approximation should be 4 or 5!\n",
cmnd);
usage(1);
}
if (R != 0.0)
r = R;
in = dgetmem(m + 1);
out = dgetmem(m + 1);
/* check stability of MLSA filter and output */
while (freadf(in, sizeof(*in), m + 1, fp) == m + 1) {
max = mlsacheck(in, out, m, fftlen, a, r, c);
/* output ascii report */
if (max > r) {
fprintf(stderr,
"[No. %d] is unstable frame (maximum = %f, threshold = %f)\n",
frame, max, r);
}
fwritef(out, sizeof(*out), m + 1, stdout);
frame++;
}
return (0);
}
int main(int argc, char **argv)
{
FILE *pdffp = stdin, *parfp = stdout;
int nframe, delay;
char *coef;
int coeflen;
PStream pst;
int i, j;
void InitPStream(PStream *);
double *mlpg(PStream *);
pst.order = ORDER;
pst.range = RANGE;
pst.iType = ITYPE;
pst.dw.fn = (char **) calloc(sizeof(char *), argc);
pst.dw.num = 1;
pst.dw.calccoef = -1;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc) {
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'd':
if (pst.dw.calccoef == 1) {
fprintf(stderr,
"%s : Options '-r' and '-d' should not be defined simultaneously!\n",
cmnd);
return (1);
}
pst.dw.calccoef = 0;
if (isfloat(*++argv)) {
coeflen = 0;
for (i = 0; (i < argc - 1) && isfloat(argv[i]); i++) {
coeflen += strlen(argv[i]) + 1;
}
coeflen += 1;
coef = pst.dw.fn[pst.dw.num] = getmem(coeflen, sizeof(char));
for (j = 0; j < i; j++) {
sprintf(coef, " %s", *argv);
coef += strlen(*argv) + 1;
if (j < i - 1) {
argv++;
argc--;
}
}
} else {
pst.dw.fn[pst.dw.num] = *argv;
}
pst.dw.num++;
--argc;
break;
case 'r':
if (pst.dw.calccoef == 0) {
fprintf(stderr,
"%s : Options '-r' and '-d' should not be defined simultaneously!\n",
cmnd);
return (1);
}
pst.dw.calccoef = 1;
coeflen = atoi(*++argv);
--argc;
if ((coeflen != 1) && (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);
}
pst.dw.fn[pst.dw.num] = *++argv;
pst.dw.num++;
--argc;
if (coeflen == 2) {
if (argc <= 1) {
fprintf(stderr,
"%s : Window size for delta-delta parameter required!\n",
cmnd);
return (1);
}
pst.dw.fn[pst.dw.num] = *++argv;
pst.dw.num++;
--argc;
}
break;
case 'm':
pst.order = atoi(*++argv);
--argc;
break;
case 'l':
pst.order = atoi(*++argv) - 1;
--argc;
break;
case 'i':
pst.iType = atoi(*++argv);
--argc;
break;
case 's':
pst.range = atoi(*++argv);
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
pdffp = getfp(*argv, "rb");
}
InitPStream(&pst);
delay = pst.range + pst.dw.maxw[WRIGHT];
nframe = 0;
while (freadf(pst.mean, sizeof(*(pst.mean)), pst.vSize * 2, pdffp) ==
pst.vSize * 2) {
if (pst.dw.num == 1)
fwritef(pst.mean, sizeof(*pst.mean), pst.order + 1, parfp);
else {
if (pst.iType == 0)
for (i = 0; i < pst.vSize; i++)
pst.ivar[i] = finv(pst.ivar[i]);
mlpg(&pst);
if (nframe >= delay)
fwritef(pst.par, sizeof(*(pst.par)), pst.order + 1, parfp);
}
nframe++;
}
if (pst.dw.num > 1) {
for (i = 0; i < pst.vSize; i++) {
pst.mean[i] = 0.0;
pst.ivar[i] = 0.0;
}
for (i = 0; i < min(nframe, delay); i++) {
mlpg(&pst);
fwritef(pst.par, sizeof(*(pst.par)), pst.order + 1, parfp);
}
}
return (0);
}
int main(int argc, char **argv)
{
int m = ORDER, itype = ITYPE, otype = OTYPE, i, num;
Boolean arrange = ARRANGE, gain = GAIN;
FILE *fp = stdin;
double *lsp, *lsp1, alpha = ALPHA, sampling = SAMPLING;
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 's':
sampling = atof(*++argv);
--argc;
break;
case 'i':
itype = atoi(*++argv);
--argc;
break;
case 'o':
otype = atoi(*++argv);
--argc;
break;
case 'r':
alpha = atof(*++argv);
if (alpha <= 0 || alpha >= 1) {
fprintf(stderr, "%s : Invalid option 'r'!\n", cmnd);
usage(0);
}
--argc;
arrange = 1 - arrange;
break;
case 'k':
gain = 1 - gain;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else {
fp = getfp(*argv, "rb");
}
if (otype < 0)
otype = itype;
lsp = dgetmem(m + m + gain);
lsp1 = lsp + m + gain;
num = 0;
while (freadf(lsp, sizeof(*lsp), m + gain, fp) == m + gain) {
if (itype == 0)
for (i = gain; i < m + gain; i++)
lsp1[i] = lsp[i] / PI2;
else if (itype == 1)
for (i = gain; i < m + gain; i++)
lsp1[i] = lsp[i];
else if (itype == 2 || itype == 3)
for (i = gain; i < m + gain; i++)
lsp1[i] = lsp[i] / sampling;
if (itype == 3)
for (i = gain; i < m + gain; i++)
lsp1[i] = lsp[i] / 1000;
if (lspcheck(lsp1 + gain, m) == -1) {
if (!arrange) {
fprintf(stderr, "[ unstable frame number : %d ]\n", num);
for (i = 0; i < m + gain; i++)
fprintf(stderr, "%f\n", lsp[i]);
fprintf(stderr, "\n");
}
}
if (arrange)
lsparrange(lsp1 + gain, m, alpha, itype, sampling);
if (otype == 0)
for (i = gain; i < m + gain; i++)
lsp1[i] *= PI2;
else if (otype == 2 || otype == 3)
for (i = gain; i < m + gain; i++)
lsp1[i] *= sampling;
if (otype == 3)
for (i = gain; i < m + gain; i++)
lsp1[i] *= 1000;
if (gain == 1)
lsp1[0] = lsp[0];
fwritef(lsp1, sizeof(*lsp1), m + gain, stdout);
num++;
}
putchar('\n');
return (0);
}
int main(int argc, char *argv[])
{
int i, o = OTYPE, L = FLENG;
char *s, c;
FILE *fp = stdin;
double *buf, tmp;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc) {
if (*(s = *++argv) == '-') {
c = *++s;
if (*++s == '\0') {
s = *++argv;
--argc;
}
switch (c) {
case 'l':
L = atoi(s);
break;
case 'o':
o = atoi(s);
break;
case 'h':
usage();
default:
usage();
}
} else
fp = getfp(*argv, "rb");
}
if (L % 2 != 0) {
fprintf(stderr, "%s : value of L must be even number!\n", cmnd);
usage();
}
L /= 2;
buf = dgetmem(L);
if ((o != 0) && (o != 1) && (o != 2)) {
fprintf(stderr, "%s : invalid output type %d\n", cmnd, o);
usage();
}
if (L <= 1) {
fprintf(stderr, "%s : value of L must be L>=4!\n", cmnd);
usage();
}
while (freadf(buf, sizeof(*buf), L, fp) == L) {
if (o == 0) {
if (L <= 2) {
fprintf(stderr, "%s : value of L must be L>=6! (if o==0)\n", cmnd);
usage();
}
for (i = 0; i < L; i++) {
fwritef(&buf[i], sizeof(*buf), 1, stdout);
}
for (i = L - 2; i > 0; i--) {
fwritef(&buf[i], sizeof(*buf), 1, stdout);
}
} else if (o == 1) {
for (i = L - 1; i > 0; i--) {
fwritef(&buf[i], sizeof(*buf), 1, stdout);
}
for (i = 0; i < L; i++) {
fwritef(&buf[i], sizeof(*buf), 1, stdout);
}
} else if (o == 2) {
tmp = buf[L - 1] / 2;
fwritef(&tmp, sizeof(*buf), 1, stdout);
for (i = L - 2; i > 0; i--) {
fwritef(&buf[i], sizeof(*buf), 1, stdout);
}
for (i = 0; i < L - 1; i++) {
fwritef(&buf[i], sizeof(*buf), 1, stdout);
}
fwritef(&tmp, sizeof(tmp), 1, stdout);
}
}
free(buf);
fclose(fp);
return (0);
}
int main(int argc, char **argv)
{
int l = LENG, ii, end;
FILE *fp = stdin;
double i = MIN, j = MAX, x1, y1, x2, y2, y, x, t;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
l = atoi(*++argv) - 1;
--argc;
break;
case 'm':
l = atoi(*++argv);
--argc;
break;
case 'x':
i = atof(*++argv);
--argc;
j = atof(*++argv);
--argc;
break;
case 'i':
i = atof(*++argv);
--argc;
break;
case 'j':
j = atof(*++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");
t = (j - i) / (double) l;
for (;;) {
if (freadf(&x2, sizeof(x2), 1, fp) != 1)
break;
if (freadf(&y2, sizeof(y2), 1, fp) != 1)
break;
fwritef(&y2, sizeof(y2), 1, stdout);
for (end = 0, ii = 1; end == 0;) {
x1 = x2;
y1 = y2;
if (freadf(&x2, sizeof(x2), 1, fp) != 1)
break;
if (freadf(&y2, sizeof(y2), 1, fp) != 1)
break;
if (x2 == j)
end = 1;
for (;; ii++) {
x = i + t * ii;
if (x > x2)
break;
y = ((y1 - y2) * x + x1 * y2 - x2 * y1) / (x1 - x2);
fwritef(&y, sizeof(y), 1, stdout);
}
}
}
return (0);
}
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);
}
int main(int argc, char **argv)
{
int leng = LENG, m = ORDER, itype = ITYPE, otype = OTYPE, gain = GAIN;
double alpha = ALPHA, gamma = GAMMA;
FILE *fp = stdin;
double logk, sampling = SAMPLING;
double *x, *lsp;
int i, no, loggain = 1;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'a':
case 'g':
case 'c':
if (isdigit(**(argv + 1)) == 0) { /* Check the value is correct */
if (**(argv + 1) != '+' && **(argv + 1) != '-') {
fprintf(stderr, "%s : need numerical number !\n", cmnd);
usage(1);
} else if (isdigit(*(*(argv + 1) + 1)) == 0) {
fprintf(stderr, "%s : need numerical number !\n", cmnd);
usage(1);
}
}
if ((*(*argv + 1)) == 'a') {
alpha = atof(*++argv);
} else if ((*(*argv + 1)) == 'g') {
gamma = atof(*++argv);
if (gamma == 0.0) {
fprintf(stderr, "%s : value of g must not be zero!\n", cmnd);
}
} else {
gamma = atof(*++argv);
if (gamma < 1)
fprintf(stderr, "%s : value of c must be c>=1!\n", cmnd);
gamma = -1.0 / gamma;
}
--argc;
break;
case 'm':
case 's':
case 'l':
case 'i':
case 'q':
case 'o':
if (isdigit(**(argv + 1)) == 0) {
if ((**(argv + 1)) != '+') {
fprintf(stderr,
"%s : %s option need positive value !\n", cmnd,
*argv);
usage(1);
} else if (isdigit(*(*(argv + 1) + 1)) == 0) {
fprintf(stderr,
"%s : %s option need positive value !\n", cmnd,
*argv);
usage(1);
}
}
if ((*(*argv + 1)) == 'm')
m = atoi(*++argv);
else if ((*(*argv + 1)) == 's')
sampling = atof(*++argv);
else if ((*(*argv + 1)) == 'l')
leng = atoi(*++argv);
else if ((*(*argv + 1)) == 'i' || (*(*argv + 1)) == 'q')
itype = atoi(*++argv);
else if ((*(*argv + 1)) == 'o')
otype = atoi(*++argv);
--argc;
break;
case 'L':
loggain = 0;
break;
case 'k':
gain = 0;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
lsp = dgetmem(m + gain);
no = leng / 2 + 1;
x = dgetmem(no);
logk = 20.0 / log(10.0);
while (freadf(lsp, sizeof(*lsp), m + gain, fp) == m + gain) {
if (itype == 1)
for (i = gain; i < m + gain; i++)
lsp[i] *= PI2;
else if (itype == 2 || itype == 3) {
for (i = gain; i < m + gain; i++)
lsp[i] = lsp[i] / sampling * PI2;
}
if (loggain == 0)
*lsp = log(*lsp);
mgclsp2sp(alpha, gamma, lsp, m, x, no, gain);
switch (otype) {
case 1:
break;
case 2:
for (i = no; i--;)
x[i] = exp(x[i]);
break;
case 3:
for (i = no; i--;)
x[i] = exp(2 * x[i]);
break;
default:
for (i = no; i--;)
x[i] *= logk;
break;
}
fwritef(x, sizeof(*x), no, stdout);
}
free(lsp);
free(x);
return (0);
}
int main(int argc, char **argv)
{
int m = ORDER, fprd = FPERIOD, iprd = IPERIOD, i, j, flag_odd;
FILE *fp = stdin, *fpc = NULL;
double *c, *inc, *cc, *d, x;
Boolean ngain = NGAIN, loggain = LOGGAIN;
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 'p':
fprd = atoi(*++argv);
--argc;
break;
case 'i':
iprd = atoi(*++argv);
--argc;
break;
/* case 't':
tp = 1 - tp;
break; */
case 'k':
ngain = 1 - ngain;
break;
case 'l':
case 'L':
loggain = 1 - loggain;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else if (fpc == NULL)
fpc = getfp(*argv, "rb");
else
fp = getfp(*argv, "rb");
if (fpc == NULL) {
fprintf(stderr, "%s : Cannot open LSP file!\n", cmnd);
return (1);
}
if (m % 2 == 0)
flag_odd = 0;
else
flag_odd = 1;
c = dgetmem(5 * m + 4);
cc = c + m + 1;
inc = cc + m + 1;
d = inc + m + 1;
if (freadf(c, sizeof(*c), m + 1, fpc) != m + 1)
return (1);
for (;;) {
if (freadf(cc, sizeof(*cc), m + 1, fpc) != m + 1)
return (0);
if (!ngain && loggain)
c[0] = exp(c[0]);
for (i = 0; i <= m; i++)
inc[i] = (cc[i] - c[i]) * iprd / fprd;
for (j = fprd, i = (iprd + 1) / 2; j--;) {
if (freadf(&x, sizeof(x), 1, fp) != 1)
return (0);
if (!ngain)
x *= c[0];
if (flag_odd)
x = lspdf_odd(x, c, m, d);
else
x = lspdf_even(x, c, m, d);
fwritef(&x, sizeof(x), 1, stdout);
if (!--i) {
for (i = 0; i <= m; i++)
c[i] += inc[i];
i = iprd;
}
}
movem(cc, c, sizeof(*cc), m + 1);
}
return (0);
}
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)
{
int fprd = FPERIOD, iprd = IPERIOD, i, j, seed = SEED;
long next = SEED;
FILE *fp = stdin;
double x, p1, p2, inc, pc;
Boolean gauss = GAUSS;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'p':
fprd = atoi(*++argv);
--argc;
break;
case 'i':
iprd = atoi(*++argv);
--argc;
break;
case 'n':
gauss = TR;
break;
case 's':
seed = 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 (gauss & (seed != 1))
next = srnd((unsigned int) seed);
if (freadf(&p1, sizeof(p1), 1, fp) != 1)
return (1);
pc = p1;
for (;;) {
if (freadf(&p2, sizeof(p2), 1, fp) != 1)
return (0);
if ((p1 != 0.0) && (p2 != 0.0))
inc = (p2 - p1) * (double) iprd / (double) fprd;
else {
inc = 0.0;
pc = p2;
p1 = 0.0;
}
for (j = fprd, i = (iprd + 1) / 2; j--;) {
if (p1 == 0.0) {
if (gauss)
x = (double) nrandom(&next);
else
x = mseq();
} else {
if ((pc += 1.0) >= p1) {
x = sqrt(p1);
pc = pc - p1;
} else
x = 0.0;
}
fwritef(&x, sizeof(x), 1, stdout);
if (!--i) {
p1 += inc;
i = iprd;
}
}
p1 = p2;
}
return 0;
}
int main(int argc, char **argv){
int i;
for(i=0;i<argc;i++)
fwritef("argv[%d]=%s\n",i,argv[i]);
return 0;
}
int main(int argc, char **argv)
{
int m = ORDER, l = LENG, otype = OTYPE, no, i;
double alpha = ALPHA, gamma = GAMMA, *c, *x, *y, logk;
Boolean norm = NORM, phase = PHASE, mulg = MULG;
FILE *fp = stdin;
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 'a':
alpha = atof(*++argv);
--argc;
break;
case 'g':
gamma = atof(*++argv);
--argc;
break;
case 'c':
gamma = atoi(*++argv);
--argc;
if (gamma < 1)
fprintf(stderr, "%s : value of c must be c>=1!\n", cmnd);
gamma = -1.0 / gamma;
break;
case 'n':
norm = 1 - norm;
break;
case 'u':
mulg = 1 - mulg;
break;
case 'l':
l = atoi(*++argv);
--argc;
break;
case 'o':
otype = atoi(*++argv);
--argc;
break;
case 'p':
phase = 1 - phase;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
x = dgetmem(l + l + m + 1);
y = x + l;
c = y + l;
no = l / 2 + 1;
logk = 20.0 / log(10.0);
while (freadf(c, sizeof(*c), m + 1, fp) == m + 1) {
if (norm)
ignorm(c, c, m, gamma);
else if (mulg) {
if (gamma == 0) {
fprintf(stderr,
"%s : gamma for input mgc coefficients should not equal to 0 if you specify -u option!\n",
cmnd);
usage(1);
}
c[0] = (c[0] - 1.0) / gamma;
}
if (mulg) {
if (gamma == 0) {
fprintf(stderr,
"%s : gamma for input mgc coefficients should not equal to 0 if you specify -u option!\n",
cmnd);
usage(1);
}
for (i = m; i > 0; i--)
c[i] /= gamma;
}
mgc2sp(c, m, alpha, gamma, x, y, l);
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;
case 3:
for (i = no; i--;)
x[i] = exp(2 * 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[])
{
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);
}
int sopr(FILE * fp)
{
double x, y;
int k, i;
Boolean skipflg = FA;
while (freadf(&x, sizeof(x), 1, fp) == 1) {
for (k = 0; k < MEMSIZE; ++k)
mem[k] = 0;
for (k = 0; k < nopr; ++k) {
y = optbl[k].d;
if (optbl[k].magic) { /* -magic or -MAGIC */
if (optbl[k].ifrep) { /* -MAGIC */
if (x == optbl[mopr].d) { /* still remains magic number */
x = y; /* substitute by new magic number */
skipflg = FA;
}
} else if (x == y) { /* -magic */
skipflg = TR;
}
} else if (skipflg == FA) {
switch (optbl[k].op[0]) {
case 'r':
x = mem[(int) y];
break;
case 'w':
mem[(int) y] = x;
break;
case '+':
x += mem[(int) y];
break;
case '-':
x -= mem[(int) y];
break;
case '*':
x *= mem[(int) y];
break;
case '/':
x /= mem[(int) y];
break;
case 'a':
x += y;
break;
case 's':
x -= y;
break;
case 'm':
x *= y;
break;
case 'd':
x /= y;
break;
case 'f':
x = (x < y) ? y : x;
break;
case 'c':
x = (x > y) ? y : x;
break;
case 'A':
if (optbl[k].op[1] == 'T')
x = atan(x);
else if (x < 0)
x = -x;
break;
case 'C':
if (optbl[k].op[1] == 'L') {
if (x < 0)
x = 0;
} else
x = cos(x);
break;
case 'I':
x = 1 / x;
break;
case 'P':
if (optbl[k].op[1] == 'O' && optbl[k].op[3] == '1')
x = pow(10.0, x);
else if (optbl[k].op[1] == 'O' && optbl[k].op[3] == '2')
x = pow(2.0, x);
else
x *= x;
break;
case 'R':
x = sqrt(x);
break;
case 'S':
if (optbl[k].op[1] == 'Q')
x = sqrt(x);
else
x = sin(x);
break;
case 'E':
x = exp(x);
break;
case 'L':
if (optbl[k].op[3] == '1')
x = log10(x);
else if (optbl[k].op[3] == '2')
x = LOG2(x);
else
x = log(x);
break;
case 'F':
if (x < 0)
i = x - 0.5;
else
i = x + 0.5;
x = i;
break;
case 'T':
x = tan(x);
break;
case 'U':
if (x < 0)
x = 0;
else
x = 1;
case 'M':
default:
break;
}
}
}
if (skipflg == FA)
fwritef(&x, sizeof(x), 1, stdout);
skipflg = FA;
}
return (0);
}
int main(int argc, char **argv)
{
int l = LENG, *cbsize, *index, stage = 0, ss = 0, num, i;
FILE *fp = stdin, *fpcb;
double *x, *cb = NULL, *p;
char **cbfile;
cbsize = (int *) calloc(argc / 2, sizeof(*cbsize));
index = (int *) calloc(argc / 2, sizeof(*index));
cbfile = (char **) calloc(argc / 2, sizeof(**cbfile));
p = cb;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
l = atoi(*++argv);
--argc;
break;
case 'n':
l = atoi(*++argv) + 1;
--argc;
break;
case 's':
cbsize[stage] = atoi(*++argv);
cbfile[stage++] = *++argv;
argc -= 2;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
for (i = 0, num = 0; i < stage; i++)
num += cbsize[i];
cb = dgetmem(num * l);
p = cb;
for (i = 0; i < stage; i++) {
fpcb = getfp(cbfile[i], "rb");
if (freadf(p, sizeof(*p), cbsize[i] * l, fpcb) != cbsize[i] * l) {
fprintf(stderr, "%s : Codebook size error of %d stage!\n", cmnd, ss);
return (1);
}
p += cbsize[i] * l;
}
x = dgetmem(l);
while (freadx(index, sizeof(*index), stage, fp) == stage) {
imsvq(index, cb, l, cbsize, stage, x);
fwritef(x, sizeof(*x), l, 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);
}
