自学教程：C++ HTS_free函数代码示例

/* 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);      }   }}