/* HTS_Audio_close: close audio device */
static void HTS_Audio_close(HTS_Audio * audio)
{
MMRESULT error;
if (audio->max_buff_size <= 0)
return;
/* stop audio */
error = waveOutReset(audio->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Cannot stop and reset your output audio device.\n");
/* unprepare */
error = waveOutUnprepareHeader(audio->hwaveout, &(audio->buff_1), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
error = waveOutUnprepareHeader(audio->hwaveout, &(audio->buff_2), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
/* close */
error = waveOutClose(audio->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Failed to close your output audio device.\n");
HTS_free(audio->buff_1.lpData);
HTS_free(audio->buff_2.lpData);
HTS_free(audio->buff);
}
/* HTS_Engine_load_gv_from_fn: load GV pdfs and trees from file names */
void HTS_Engine_load_gv_from_fn(HTS_Engine * engine, char **pdf_fn,
char **tree_fn, int stream_index,
int interpolation_size)
{
int i;
FILE **pdf_fp, **tree_fp;
pdf_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *));
if (tree_fn)
tree_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *));
else
tree_fp = NULL;
for (i = 0; i < interpolation_size; i++) {
pdf_fp[i] = HTS_get_fp(pdf_fn[i], "rb");
if (tree_fn) {
if (tree_fn[i])
tree_fp[i] = HTS_get_fp(tree_fn[i], "r");
else
tree_fp[i] = NULL;
}
}
HTS_Engine_load_gv_from_fp(engine, pdf_fp, tree_fp, stream_index,
interpolation_size);
for (i = 0; i < interpolation_size; i++) {
fclose(pdf_fp[i]);
if (tree_fp && tree_fp[i])
fclose(tree_fp[i]);
}
HTS_free(pdf_fp);
if (tree_fp)
HTS_free(tree_fp);
}
/* HTS_Audio_close: close audio device */
void HTS_Audio_close(HTS_Audio * as)
{
MMRESULT error;
if (as->buff_size != 0)
HTS_Audio_write_buffer(as);
while (as->now_buff_1 == TRUE)
Sleep(AUDIO_WAIT_BUFF_MS);
while (as->now_buff_2 == TRUE)
Sleep(AUDIO_WAIT_BUFF_MS);
/* stop audio */
error = waveOutReset(as->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0,
"hts_engine: Cannot stop and reset your output audio device.\n");
/* unprepare */
error = waveOutUnprepareHeader(as->hwaveout, &(as->buff_1), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0,
"hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
error = waveOutUnprepareHeader(as->hwaveout, &(as->buff_2), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0,
"hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
/* close */
error = waveOutClose(as->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Failed to close your output audio device.\n");
HTS_free(as->buff_1.lpData);
HTS_free(as->buff_2.lpData);
HTS_free(as->buff);
}
/* HTS_Engine_load_parameter_from_fn: load parameter pdfs, trees and windows from file names */
void HTS_Engine_load_parameter_from_fn(HTS_Engine * engine, char **pdf_fn,
char **tree_fn, char **win_fn,
int stream_index, HTS_Boolean msd_flag,
int window_size, int interpolation_size)
{
int i;
FILE **pdf_fp, **tree_fp, **win_fp;
pdf_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *));
tree_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *));
win_fp = (FILE **) HTS_calloc(window_size, sizeof(FILE *));
for (i = 0; i < interpolation_size; i++) {
pdf_fp[i] = HTS_get_fp(pdf_fn[i], "rb");
tree_fp[i] = HTS_get_fp(tree_fn[i], "r");
}
for (i = 0; i < window_size; i++)
win_fp[i] = HTS_get_fp(win_fn[i], "r");
HTS_Engine_load_parameter_from_fp(engine, pdf_fp, tree_fp, win_fp,
stream_index, msd_flag,
window_size, interpolation_size);
for (i = 0; i < interpolation_size; i++) {
fclose(pdf_fp[i]);
fclose(tree_fp[i]);
}
for (i = 0; i < window_size; i++)
fclose(win_fp[i]);
HTS_free(pdf_fp);
HTS_free(tree_fp);
HTS_free(win_fp);
}
/* HTS_free_matrix: free double matrix */
void HTS_free_matrix(double **p, size_t x) {
size_t i;
for (i = 0; i < x; i++)
HTS_free(p[i]);
HTS_free(p);
}
/* HTS_free_matrix: free double matrix */
void HTS_free_matrix(double **p, const int x)
{
int i;
for (i = x - 1; i >= 0; i--)
HTS_free(p[i]);
HTS_free(p);
}
/* HTS_Label_clear: free label */
void HTS_Label_clear(HTS_Label * label)
{
HTS_LabelString *lstring, *next_lstring;
for (lstring = label->head; lstring; lstring = next_lstring) {
next_lstring = lstring->next;
HTS_free(lstring->name);
HTS_free(lstring);
}
HTS_Label_initialize(label);
}
/* HTS_Question_clear: clear loaded question */
static void HTS_Question_clear(HTS_Question * question)
{
HTS_Pattern *pattern, *next_pattern;
HTS_free(question->string);
for (pattern = question->head; pattern; pattern = next_pattern) {
next_pattern = pattern->next;
HTS_free(pattern->string);
HTS_free(pattern);
}
}
/* HTS_Tree_clear: clear given tree */
static void HTS_Tree_clear(HTS_Tree * tree)
{
HTS_Pattern *pattern, *next_pattern;
for (pattern = tree->head; pattern; pattern = next_pattern) {
next_pattern = pattern->next;
HTS_free(pattern->string);
HTS_free(pattern);
}
HTS_Node_clear(tree->root);
}
/* HTS_Vocoder_postfilter_mcp: postfilter for MCP */
void HTS_Vocoder_postfilter_mcp(HTS_Vocoder *v, double *mcp, const int m,
double alpha, double beta)
{
double e1, e2;
int k;
if (beta > 0.0 && m > 1) {
if (v->postfilter_size < m) {
if (v->postfilter_buff != NULL)
HTS_free(v->postfilter_buff);
v->postfilter_buff = (double *) HTS_calloc(m + 1, sizeof(double));
v->postfilter_size = m;
}
HTS_mc2b(mcp, v->postfilter_buff, m, alpha);
e1 = HTS_b2en(v, v->postfilter_buff, m, alpha);
v->postfilter_buff[1] -= beta * alpha * mcp[2];
for (k = 2; k <= m; k++)
v->postfilter_buff[k] *= (1.0 + beta);
e2 = HTS_b2en(v, v->postfilter_buff, m, alpha);
v->postfilter_buff[0] += log(e1 / e2) / 2;
HTS_b2mc(v->postfilter_buff, mcp, m, alpha);
}
}
/* HTS_lsp2en: calculate frame energy */
static double HTS_lsp2en(HTS_Vocoder * v, double *lsp, size_t m, double alpha)
{
size_t i;
double en = 0.0;
double *buff;
if (v->spectrum2en_size < m) {
if (v->spectrum2en_buff != NULL)
HTS_free(v->spectrum2en_buff);
v->spectrum2en_buff = (double *) HTS_calloc(m + 1 + IRLENG, sizeof(double));
v->spectrum2en_size = m;
}
buff = v->spectrum2en_buff + m + 1;
/* lsp2lpc */
HTS_lsp2lpc(v, lsp + 1, v->spectrum2en_buff, m);
if (v->use_log_gain)
v->spectrum2en_buff[0] = exp(lsp[0]);
else
v->spectrum2en_buff[0] = lsp[0];
/* mgc2mgc */
if (NORMFLG1)
HTS_ignorm(v->spectrum2en_buff, v->spectrum2en_buff, m, v->gamma);
else if (MULGFLG1)
v->spectrum2en_buff[0] = (1.0 - v->spectrum2en_buff[0]) * ((double) v->stage);
if (MULGFLG1)
for (i = 1; i <= m; i++)
v->spectrum2en_buff[i] *= -((double) v->stage);
HTS_mgc2mgc(v, v->spectrum2en_buff, m, alpha, v->gamma, buff, IRLENG - 1, 0.0, 1);
for (i = 0; i < IRLENG; i++)
en += buff[i] * buff[i];
return en;
}
/* HTS_freqt: frequency transformation */
static void HTS_freqt(HTS_Vocoder * v, const double *c1, const int m1, double *c2, const int m2, const double a)
{
int i, j;
const double b = 1 - a * a;
double *g;
if (m2 > v->freqt_size) {
if (v->freqt_buff != NULL)
HTS_free(v->freqt_buff);
v->freqt_buff = (double *) HTS_calloc(m2 + m2 + 2, sizeof(double));
v->freqt_size = m2;
}
g = v->freqt_buff + v->freqt_size + 1;
for (i = 0; i < m2 + 1; i++)
g[i] = 0.0;
for (i = -m1; i <= 0; i++) {
if (0 <= m2)
g[0] = c1[-i] + a * (v->freqt_buff[0] = g[0]);
if (1 <= m2)
g[1] = b * v->freqt_buff[0] + a * (v->freqt_buff[1] = g[1]);
for (j = 2; j <= m2; j++)
g[j] = v->freqt_buff[j - 1] + a * ((v->freqt_buff[j] = g[j]) - g[j - 1]);
}
HTS_movem(g, c2, m2 + 1);
}
/* HTS_b2en: calculate frame energy */
static double HTS_b2en(HTS_Vocoder * v, const double *b, const int m, const double a)
{
int i;
double en = 0.0;
double *cep;
double *ir;
if (v->spectrum2en_size < m) {
if (v->spectrum2en_buff != NULL)
HTS_free(v->spectrum2en_buff);
v->spectrum2en_buff = (double *) HTS_calloc((m + 1) + 2 * IRLENG, sizeof(double));
v->spectrum2en_size = m;
}
cep = v->spectrum2en_buff + m + 1;
ir = cep + IRLENG;
HTS_b2mc(b, v->spectrum2en_buff, m, a);
HTS_freqt(v, v->spectrum2en_buff, m, cep, IRLENG - 1, -a);
HTS_c2ir(cep, IRLENG, ir, IRLENG);
for (i = 0; i < IRLENG; i++)
en += ir[i] * ir[i];
return (en);
}
/* HTS_gc2gc: generalized cepstral transformation */
static void HTS_gc2gc(HTS_Vocoder * v, double *c1, const int m1, const double g1, double *c2, const int m2, const double g2)
{
int i, min, k, mk;
double ss1, ss2, cc;
if (m1 > v->gc2gc_size) {
if (v->gc2gc_buff != NULL)
HTS_free(v->gc2gc_buff);
v->gc2gc_buff = (double *) HTS_calloc(m1 + 1, sizeof(double));
v->gc2gc_size = m1;
}
HTS_movem(c1, v->gc2gc_buff, m1 + 1);
c2[0] = v->gc2gc_buff[0];
for (i = 1; i <= m2; i++) {
ss1 = ss2 = 0.0;
min = m1 < i ? m1 : i - 1;
for (k = 1; k <= min; k++) {
mk = i - k;
cc = v->gc2gc_buff[k] * c2[mk];
ss2 += k * cc;
ss1 += mk * cc;
}
if (i <= m1)
c2[i] = v->gc2gc_buff[i] + (g2 * ss2 - g1 * ss1) / i;
else
c2[i] = (g2 * ss2 - g1 * ss1) / i;
}
}
/* HTS_Node_clear: recursive function to free Node */
static void HTS_Node_clear(HTS_Node * node)
{
if (node->yes != NULL)
HTS_Node_clear(node->yes);
if (node->no != NULL)
HTS_Node_clear(node->no);
HTS_free(node);
}
/* HTS_Engine_clear: free engine */
void HTS_Engine_clear(HTS_Engine * engine)
{
size_t i;
if (engine->condition.msd_threshold != NULL)
HTS_free(engine->condition.msd_threshold);
if (engine->condition.duration_iw != NULL)
HTS_free(engine->condition.duration_iw);
if (engine->condition.gv_weight != NULL)
HTS_free(engine->condition.gv_weight);
if (engine->condition.parameter_iw != NULL) {
for (i = 0; i < HTS_ModelSet_get_nvoices(&engine->ms); i++)
HTS_free(engine->condition.parameter_iw[i]);
HTS_free(engine->condition.parameter_iw);
}
if (engine->condition.gv_iw != NULL) {
for (i = 0; i < HTS_ModelSet_get_nvoices(&engine->ms); i++)
HTS_free(engine->condition.gv_iw[i]);
HTS_free(engine->condition.gv_iw);
}
HTS_ModelSet_clear(&engine->ms);
HTS_Audio_clear(&engine->audio);
HTS_Engine_initialize(engine);
}
/* HTS_Window_clear: free dynamic window */
static void HTS_Window_clear(HTS_Window * win)
{
int i;
if (win->coefficient) {
for (i = win->size - 1; i >= 0; i--) {
win->coefficient[i] += win->l_width[i];
HTS_free(win->coefficient[i]);
}
HTS_free(win->coefficient);
}
if (win->l_width)
HTS_free(win->l_width);
if (win->r_width)
HTS_free(win->r_width);
HTS_Window_initialize(win);
}
/* HTS_ModelSet_clear: free model set */
void HTS_ModelSet_clear(HTS_ModelSet * ms)
{
int i;
HTS_Stream_clear(&ms->duration);
if (ms->stream) {
for (i = 0; i < ms->nstream; i++)
HTS_Stream_clear(&ms->stream[i]);
HTS_free(ms->stream);
}
if (ms->gv) {
for (i = 0; i < ms->nstream; i++)
HTS_Stream_clear(&ms->gv[i]);
HTS_free(ms->gv);
}
HTS_Model_clear(&ms->gv_switch);
HTS_ModelSet_initialize(ms, -1);
}
/* HTS_GStreamSet_clear: free generated parameter stream set */
void HTS_GStreamSet_clear(HTS_GStreamSet * gss)
{
size_t i, j;
if (gss->gstream) {
for (i = 0; i < gss->nstream; i++) {
if (gss->gstream[i].par != NULL) {
for (j = 0; j < gss->total_frame; j++)
HTS_free(gss->gstream[i].par[j]);
HTS_free(gss->gstream[i].par);
}
}
HTS_free(gss->gstream);
}
if (gss->gspeech)
HTS_free(gss->gspeech);
HTS_GStreamSet_initialize(gss);
}
/* HTS_GStreamSet_clear: free generated parameter stream set */
void HTS_GStreamSet_clear(HTS_GStreamSet * gss)
{
int i, j;
#ifndef HTS_EMBEDDED
if (gss->gstream) {
for (i = 0; i < gss->nstream; i++) {
for (j = 0; j < gss->total_frame; j++)
HTS_free(gss->gstream[i].par[j]);
HTS_free(gss->gstream[i].par);
}
HTS_free(gss->gstream);
}
#endif /* !HTS_EMBEDDED */
if (gss->gspeech)
HTS_free(gss->gspeech);
HTS_GStreamSet_initialize(gss);
}
/* HTS_fclose: wrapper for fclose */
void HTS_fclose(HTS_File *fp) {
if (fp == NULL) {
return;
} else if (fp->type == HTS_FILE) {
if (fp->pointer != NULL)
fclose((FILE *) fp->pointer);
HTS_free(fp);
return;
} else if (fp->type == HTS_DATA) {
if (fp->pointer != NULL) {
HTS_Data *d = (HTS_Data *) fp->pointer;
if (d->data != NULL)
HTS_free(d->data);
HTS_free(d);
}
HTS_free(fp);
return;
}
HTS_error(0, "HTS_fclose: Unknown file type.\n");
}
/* HTS_Stream_clear: free stream */
static void HTS_Stream_clear(HTS_Stream * stream)
{
int i;
if (stream->model) {
for (i = 0; i < stream->interpolation_size; i++)
HTS_Model_clear(&stream->model[i]);
HTS_free(stream->model);
}
HTS_Window_clear(&stream->window);
HTS_Stream_initialize(stream);
}
/* HTS_Engine_load_duratin_from_fn: load duration pdfs, trees and number of state from file names */
void HTS_Engine_load_duration_from_fn(HTS_Engine * engine, char **pdf_fn,
char **tree_fn, int interpolation_size)
{
int i;
FILE **pdf_fp, **tree_fp;
pdf_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *));
tree_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *));
for (i = 0; i < interpolation_size; i++) {
pdf_fp[i] = HTS_get_fp(pdf_fn[i], "rb");
tree_fp[i] = HTS_get_fp(tree_fn[i], "r");
}
HTS_Engine_load_duration_from_fp(engine, pdf_fp, tree_fp,
interpolation_size);
for (i = 0; i < interpolation_size; i++) {
fclose(pdf_fp[i]);
fclose(tree_fp[i]);
}
HTS_free(pdf_fp);
HTS_free(tree_fp);
}
/* HTS_Model_clear: free pdfs and trees */
static void HTS_Model_clear(HTS_Model * model)
{
int i, j;
HTS_Question *question, *next_question;
HTS_Tree *tree, *next_tree;
for (question = model->question; question; question = next_question) {
next_question = question->next;
HTS_Question_clear(question);
HTS_free(question);
}
for (tree = model->tree; tree; tree = next_tree) {
next_tree = tree->next;
HTS_Tree_clear(tree);
HTS_free(tree);
}
if (model->pdf) {
for (i = 2; i <= model->ntree + 1; i++) {
for (j = 1; j <= model->npdf[i]; j++) {
HTS_free(model->pdf[i][j]);
}
model->pdf[i]++;
HTS_free(model->pdf[i]);
}
model->pdf += 2;
HTS_free(model->pdf);
}
if (model->npdf) {
model->npdf += 2;
HTS_free(model->npdf);
}
HTS_Model_initialize(model);
}
/* HTS_fopen_from_fn: wrapper for fopen */
HTS_File *HTS_fopen_from_fn(const char *name, const char *opt) {
HTS_File *fp = (HTS_File *) HTS_calloc(1, sizeof(HTS_File));
fp->type = HTS_FILE;
fp->pointer = (void *) fopen(name, opt);
if (fp->pointer == NULL) {
HTS_error(0, "HTS_fopen: Cannot open %s.\n", name);
HTS_free(fp);
return NULL;
}
return fp;
}
/* HTS_Vocoder_clear: clear vocoder */
void HTS_Vocoder_clear(HTS_Vocoder *v)
{
if (v != NULL) {
/* free buffer */
if (v->freqt_buff != NULL) {
HTS_free(v->freqt_buff);
v->freqt_buff = NULL;
}
v->freqt_size = 0;
if (v->gc2gc_buff != NULL) {
HTS_free(v->gc2gc_buff);
v->gc2gc_buff = NULL;
}
v->gc2gc_size = 0;
if (v->lsp2lpc_buff != NULL) {
HTS_free(v->lsp2lpc_buff);
v->lsp2lpc_buff = NULL;
}
v->lsp2lpc_size = 0;
if (v->postfilter_buff != NULL) {
HTS_free(v->postfilter_buff);
v->postfilter_buff = NULL;
}
v->postfilter_size = 0;
if (v->spectrum2en_buff != NULL) {
HTS_free(v->spectrum2en_buff);
v->spectrum2en_buff = NULL;
}
v->spectrum2en_size = 0;
if (v->pade != NULL) {
HTS_free(v->pade);
v->pade = NULL;
}
if (v->c != NULL) {
HTS_free(v->c);
v->c = NULL;
}
/* close audio device */
if (v->audio != NULL) {
HTS_Audio_close(v->audio);
HTS_free(v->audio);
v->audio = NULL;
}
}
}
/* HTS_Engine_clear: free engine */
void HTS_Engine_clear(HTS_Engine * engine)
{
int i;
HTS_free(engine->global.msd_threshold);
HTS_free(engine->global.duration_iw);
for (i = 0; i < HTS_ModelSet_get_nstream(&engine->ms); i++) {
HTS_free(engine->global.parameter_iw[i]);
if (engine->global.gv_iw[i])
HTS_free(engine->global.gv_iw[i]);
}
HTS_free(engine->global.parameter_iw);
HTS_free(engine->global.gv_iw);
HTS_free(engine->global.gv_weight);
HTS_ModelSet_clear(&engine->ms);
}
/* HTS_Vocoder_clear: clear vocoder */
void HTS_Vocoder_clear(HTS_Vocoder * v)
{
if (v != NULL) {
/* free buffer */
if (v->freqt_buff != NULL) {
HTS_free(v->freqt_buff);
v->freqt_buff = NULL;
}
v->freqt_size = 0;
if (v->gc2gc_buff != NULL) {
HTS_free(v->gc2gc_buff);
v->gc2gc_buff = NULL;
}
v->gc2gc_size = 0;
if (v->lsp2lpc_buff != NULL) {
HTS_free(v->lsp2lpc_buff);
v->lsp2lpc_buff = NULL;
}
v->lsp2lpc_size = 0;
if (v->postfilter_buff != NULL) {
HTS_free(v->postfilter_buff);
v->postfilter_buff = NULL;
}
v->postfilter_size = 0;
if (v->spectrum2en_buff != NULL) {
HTS_free(v->spectrum2en_buff);
v->spectrum2en_buff = NULL;
}
v->spectrum2en_size = 0;
if (v->c != NULL) {
HTS_free(v->c);
v->c = NULL;
}
v->excite_buff_size = 0;
v->excite_buff_index = 0;
if (v->excite_ring_buff != NULL) {
HTS_free(v->excite_ring_buff);
v->excite_ring_buff = NULL;
}
}
}
/* HTS_Vocoder_postfilter_lsp: postfilter for LSP */
static void HTS_Vocoder_postfilter_lsp(HTS_Vocoder * v, double *lsp, size_t m, double alpha, double beta)
{
double e1, e2;
size_t i;
double d1, d2;
if (beta > 0.0 && m > 1) {
if (v->postfilter_size < m) {
if (v->postfilter_buff != NULL)
HTS_free(v->postfilter_buff);
v->postfilter_buff = (double *) HTS_calloc(m + 1, sizeof(double));
v->postfilter_size = m;
}
e1 = HTS_lsp2en(v, lsp, m, alpha);
/* postfiltering */
for (i = 0; i <= m; i++) {
if (i > 1 && i < m) {
d1 = beta * (lsp[i + 1] - lsp[i]);
d2 = beta * (lsp[i] - lsp[i - 1]);
v->postfilter_buff[i] = lsp[i - 1] + d2 + (d2 * d2 * ((lsp[i + 1] - lsp[i - 1]) - (d1 + d2))) / ((d2 * d2) + (d1 * d1));
} else {
v->postfilter_buff[i] = lsp[i];
}
}
HTS_movem(v->postfilter_buff, lsp, m + 1);
e2 = HTS_lsp2en(v, lsp, m, alpha);
if (e1 != e2) {
if (v->use_log_gain)
lsp[0] += 0.5 * log(e1 / e2);
else
lsp[0] *= sqrt(e1 / e2);
}
}
}
/* HTS_Audio_close: close audio device */
static void HTS_Audio_close(HTS_Audio * audio)
{
if (audio->max_buff_size <= 0)
return;
if (audio->buff_size > 0) {
audio->err = Pa_WriteStream(audio->stream, audio->buff, audio->buff_size);
if (audio->err != paNoError && audio->err != paOutputUnderflowed)
HTS_error(0, "hts_engine: Cannot send datablocks to your output audio device to play waveform.\n");
audio->buff_size = 0;
}
HTS_free(audio->buff);
audio->err = Pa_StopStream(audio->stream);
if (audio->err != paNoError)
HTS_error(0, "hts_engine: Cannot stop your output audio device.\n");
audio->err = Pa_CloseStream(audio->stream);
if (audio->err != paNoError)
HTS_error(0, "hts_engine: Failed to close your output audio device.\n");
Pa_Terminate();
}
