ref: 2dabff3c93c430a7e5578327227e8b6789c31ccd
dir: /src/cg/cst_vc.c/
/* --------------------------------------------------------------- */
/* The HMM-Based Speech Synthesis System (HTS): version 1.1b */
/* HTS Working Group */
/* */
/* Department of Computer Science */
/* Nagoya Institute of Technology */
/* and */
/* Interdisciplinary Graduate School of Science and Engineering */
/* Tokyo Institute of Technology */
/* Copyright (c) 2001-2003 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and */
/* distribute this software and its documentation without */
/* restriction, including without limitation the rights to use, */
/* copy, modify, merge, publish, distribute, sublicense, and/or */
/* sell copies of this work, and to permit persons to whom this */
/* work is furnished to do so, subject to the following conditions: */
/* */
/* 1. The code must retain the above copyright notice, this list */
/* of conditions and the following disclaimer. */
/* */
/* 2. Any modifications must be clearly marked as such. */
/* */
/* NAGOYA INSTITUTE OF TECHNOLOGY, TOKYO INSITITUTE OF TECHNOLOGY, */
/* HTS WORKING GROUP, AND THE CONTRIBUTORS TO THIS WORK DISCLAIM */
/* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL */
/* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL NAGOYA INSTITUTE OF TECHNOLOGY, TOKYO INSITITUTE OF */
/* TECHNOLOGY, HTS WORKING GROUP, NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY */
/* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, */
/* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTUOUS */
/* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR */
/* PERFORMANCE OF THIS SOFTWARE. */
/* */
/* --------------------------------------------------------------- */
/* This is Zen's MLSA filter as ported by Toda to festvox vc */
/* and back ported into hts/festival so we can do MLSA filtering */
/* If I took more time I could probably make this use the same as */
/* as the other code in this directory -- awb@cs.cmu.edu 03JAN06 */
/* --------------------------------------------------------------- */
/* and then ported into Flite (November 2007 awb@cs.cmu.edu) */
/*********************************************************************/
/* */
/* vector (etc) code common to mlpg and mlsa */
/*-------------------------------------------------------------------*/
#include "cst_alloc.h"
#include "cst_string.h"
#include "cst_math.h"
#include "cst_vc.h"
/* from vector.cc */
LVECTOR xlvalloc(long length)
{
LVECTOR x;
length = MAX(length, 0);
x = cst_alloc(struct LVECTOR_STRUCT,1);
x->data = cst_alloc(long,MAX(length, 1));
x->imag = NULL;
x->length = length;
return x;
}
void xlvfree(LVECTOR x)
{
if (x != NULL) {
if (x->data != NULL) {
cst_free(x->data);
}
if (x->imag != NULL) {
cst_free(x->imag);
}
cst_free(x);
}
return;
}
DVECTOR xdvalloc(long length)
{
DVECTOR x;
length = MAX(length, 0);
x = cst_alloc(struct DVECTOR_STRUCT,1);
x->data = cst_alloc(double,MAX(length, 1));
x->imag = NULL;
x->length = length;
return x;
}
void xdvfree(DVECTOR x)
{
if (x != NULL) {
if (x->data != NULL) {
cst_free(x->data);
}
if (x->imag != NULL) {
cst_free(x->imag);
}
cst_free(x);
}
return;
}
void dvialloc(DVECTOR x)
{
if (x->imag != NULL) {
cst_free(x->imag);
}
x->imag = cst_alloc(double,x->length);
return;
}
DVECTOR xdvcut(DVECTOR x, long offset, long length)
{
long k;
long pos;
DVECTOR y;
y = xdvalloc(length);
if (x->imag != NULL) {
dvialloc(y);
}
for (k = 0; k < y->length; k++) {
pos = k + offset;
if (pos >= 0 && pos < x->length) {
y->data[k] = x->data[pos];
if (y->imag != NULL) {
y->imag[k] = x->imag[pos];
}
} else {
y->data[k] = 0.0;
if (y->imag != NULL) {
y->imag[k] = 0.0;
}
}
}
return y;
}
DMATRIX xdmalloc(long row, long col)
{
DMATRIX matrix;
int i;
matrix = cst_alloc(struct DMATRIX_STRUCT,1);
matrix->data = cst_alloc(double *,row);
for (i=0; i<row; i++)
matrix->data[i] = cst_alloc(double,col);
matrix->imag = NULL;
matrix->row = row;
matrix->col = col;
return matrix;
}
void xdmfree(DMATRIX matrix)
{
int i;
if (matrix != NULL) {
if (matrix->data != NULL) {
for (i=0; i<matrix->row; i++)
cst_free(matrix->data[i]);
cst_free(matrix->data);
}
if (matrix->imag != NULL) {
for (i=0; i<matrix->row; i++)
cst_free(matrix->imag[i]);
cst_free(matrix->imag);
}
cst_free(matrix);
}
return;
}
DVECTOR xdvinit(double j, double incr, double n)
{
long k;
long num;
DVECTOR x;
if ((incr > 0.0 && j > n) || (incr < 0.0 && j < n)) {
x = xdvnull();
return x;
}
if (incr == 0.0) {
num = (long)n;
if (num <= 0) {
x = xdvnull();
return x;
}
} else {
num = LABS((long)((n - j) / incr)) + 1;
}
/* memory allocate */
x = xdvalloc(num);
/* initailize data */
for (k = 0; k < x->length; k++) {
x->data[k] = j + (k * incr);
}
return x;
}
/* from voperate.cc */
double dvmax(DVECTOR x, long *index)
{
long k;
long ind;
double max;
ind = 0;
max = x->data[ind];
for (k = 1; k < x->length; k++) {
if (max < x->data[k]) {
ind = k;
max = x->data[k];
}
}
if (index != NULL) {
*index = ind;
}
return max;
}
double dvmin(DVECTOR x, long *index)
{
long k;
long ind;
double min;
ind = 0;
min = x->data[ind];
for (k = 1; k < x->length; k++) {
if (min > x->data[k]) {
ind = k;
min = x->data[k];
}
}
if (index != NULL) {
*index = ind;
}
return min;
}
double dvsum(DVECTOR x)
{
long k;
double sum;
for (k = 0, sum = 0.0; k < x->length; k++) {
sum += x->data[k];
}
return sum;
}