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

/* HTS_Stream_load_pdf_and_tree: load PDFs and trees */static void HTS_Stream_load_pdf_and_tree(HTS_Stream * stream, FILE ** pdf_fp,                                         FILE ** tree_fp, HTS_Boolean msd_flag,                                         int interpolation_size){   int i;   /* initialize */   stream->msd_flag = msd_flag;   stream->interpolation_size = interpolation_size;   stream->model =       (HTS_Model *) HTS_calloc(interpolation_size, sizeof(HTS_Model));   /* load */   for (i = 0; i < stream->interpolation_size; i++) {      if (!pdf_fp[i])         HTS_error(1,                   "HTS_Stream_load_pdf_and_tree: File for duration PDFs is not specified./n");      if (!tree_fp[i])         HTS_error(1,                   "HTS_Stream_load_pdf_and_tree: File for duration trees is not specified./n");      HTS_Model_initialize(&stream->model[i]);      HTS_Model_load_tree(&stream->model[i], tree_fp[i]);      HTS_Model_load_pdf(&stream->model[i], pdf_fp[i], stream->model[i].ntree,                         stream->msd_flag);   }   /* check */   for (i = 1; i < stream->interpolation_size; i++)      if (stream->model[0].vector_length != stream->model[i].vector_length)         HTS_error(1,                   "HTS_Stream_load_pdf_and_tree: Vector sizes of state output vectors are different in between given modelsets./n");   /* set */   stream->vector_length = stream->model[0].vector_length;}

/* HTS_Audio_open: open audio device */static void HTS_Audio_open(HTS_Audio * audio, int sampling_rate, int max_buff_size){   if (audio->sampling_rate == sampling_rate && audio->max_buff_size == max_buff_size)      return;   HTS_Audio_close(audio);   audio->sampling_rate = sampling_rate;   audio->max_buff_size = max_buff_size;   if (audio->max_buff_size <= 0)      return;   audio->err = Pa_Initialize();   if (audio->err != paNoError)      HTS_error(0, "hts_engine: Failed to initialize your output audio device to play waveform./n");   audio->parameters.device = Pa_GetDefaultOutputDevice();   audio->parameters.channelCount = 1;   audio->parameters.sampleFormat = paInt16;   audio->parameters.suggestedLatency = Pa_GetDeviceInfo(audio->parameters.device)->defaultLowOutputLatency;   audio->parameters.hostApiSpecificStreamInfo = NULL;   audio->err = Pa_OpenStream(&audio->stream, NULL, &audio->parameters, sampling_rate, max_buff_size, paClipOff, NULL, NULL);   if (audio->err != paNoError)      HTS_error(0, "hts_engine: Failed to open your output audio device to play waveform./n");   audio->err = Pa_StartStream(audio->stream);   if (audio->err != paNoError)      HTS_error(0, "hts_engine: Failed to start your output audio device to play waveform./n");   audio->buff = (short *) HTS_calloc(max_buff_size, sizeof(short));   audio->buff_size = 0;}

/* HTS_ModelSet_load_parameter: load model */void HTS_ModelSet_load_parameter(HTS_ModelSet * ms, FILE ** pdf_fp,                                 FILE ** tree_fp, FILE ** win_fp,                                 int stream_index, HTS_Boolean msd_flag,                                 int window_size, int interpolation_size){   int i;   /* check */   if (pdf_fp == NULL)      HTS_error(1,                "HTS_ModelSet_load_parameter: File for pdfs is not specified./n");   if (tree_fp == NULL)      HTS_error(1,                "HTS_ModelSet_load_parameter: File for wins is not specified./n");   if (win_fp == NULL)      HTS_error(1,                "HTS_ModelSet_load_parameter: File for wins is not specified./n");   /* initialize */   if (!ms->stream) {      ms->stream = (HTS_Stream *) HTS_calloc(ms->nstream, sizeof(HTS_Stream));      for (i = 0; i < ms->nstream; i++)         HTS_Stream_initialize(&ms->stream[i]);   }   /* load */   HTS_Stream_load_pdf_and_tree(&ms->stream[stream_index], pdf_fp, tree_fp,                                msd_flag, interpolation_size);   HTS_Stream_load_dynamic_window(&ms->stream[stream_index], win_fp,                                  window_size);}

/* 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_ModelSet_load_duration: load duration model and number of state */HTS_Boolean HTS_ModelSet_load_duration(HTS_ModelSet * ms, HTS_File ** pdf_fp, HTS_File ** tree_fp, int interpolation_size){   /* check */   if (ms == NULL) {      return FALSE;   }   if (interpolation_size <= 0) {      HTS_ModelSet_clear(ms);      return FALSE;   }   if (pdf_fp == NULL) {      HTS_error(1, "HTS_ModelSet_load_duration: File for duration PDFs is not specified./n");      HTS_ModelSet_clear(ms);      return FALSE;   }   if (tree_fp == NULL) {      HTS_error(1, "HTS_ModelSet_load_duration: File for duration trees is not specified./n");      HTS_ModelSet_clear(ms);      return FALSE;   }   if (HTS_Stream_load_pdf_and_tree(&ms->duration, pdf_fp, tree_fp, interpolation_size) == FALSE) {      HTS_ModelSet_clear(ms);      return FALSE;   }   ms->nstate = ms->duration.vector_length;   return TRUE;}

/* 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_Model_load_tree: load trees */static void HTS_Model_load_tree(HTS_Model * model, FILE * fp){   char buff[HTS_MAXBUFLEN];   HTS_Question *question, *last_question;   HTS_Tree *tree, *last_tree;   int state;   /* check */   if (fp == NULL)      HTS_error(1, "HTS_Model_load_tree: File for trees is not specified./n");   model->ntree = 0;   last_question = NULL;   last_tree = NULL;   while (!feof(fp)) {      HTS_get_pattern_token(fp, buff);      /* parse questions */      if (strcmp(buff, "QS") == 0) {         question = (HTS_Question *) HTS_calloc(1, sizeof(HTS_Question));         HTS_Question_load(question, fp);         if (model->question)            last_question->next = question;         else            model->question = question;         question->next = NULL;         last_question = question;      }      /* parse trees */      state = HTS_get_state_num(buff);      if (state != 0) {         tree = (HTS_Tree *) HTS_calloc(1, sizeof(HTS_Tree));         tree->next = NULL;         tree->root = NULL;         tree->head = NULL;         tree->state = state;         HTS_Tree_parse_pattern(tree, buff);         HTS_Tree_load(tree, fp, model->question);         if (model->tree)            last_tree->next = tree;         else            model->tree = tree;         tree->next = NULL;         last_tree = tree;         model->ntree++;      }   }   /* No Tree information in tree file */   if (model->tree == NULL)      HTS_error(1, "HTS_Model_load_tree: No trees are loaded./n");}

/* HTS_ModelSet_load_duration: load duration model and number of state */void HTS_ModelSet_load_duration(HTS_ModelSet * ms, FILE ** pdf_fp,                                FILE ** tree_fp, int interpolation_size){   /* check */   if (pdf_fp == NULL)      HTS_error(1,                "HTS_ModelSet_load_duration: File for duration PDFs is not specified./n");   if (tree_fp == NULL)      HTS_error(1,                "HTS_ModelSet_load_duration: File for duration trees is not specified./n");   HTS_Stream_load_pdf_and_tree(&ms->duration, pdf_fp, tree_fp, FALSE,                                interpolation_size);   ms->nstate = ms->duration.vector_length;}

/* HTS_Stream_load_pdf: load pdf */static HTS_Boolean HTS_Stream_load_pdf(HTS_Stream * stream, HTS_File ** fp, int ntree, int interpolation_size){   int i;   HTS_Boolean result = TRUE;   /* initialize */   stream->interpolation_size = interpolation_size;   stream->model = (HTS_Model *) HTS_calloc(interpolation_size, sizeof(HTS_Model));   /* load pdfs */   for (i = 0; i < stream->interpolation_size; i++) {      HTS_Model_initialize(&stream->model[i]);      if (HTS_Model_load_pdf(&stream->model[i], fp[i], ntree, &stream->msd_flag) == FALSE)         result = FALSE;   }   if (result == FALSE) {      HTS_Stream_clear(stream);      return FALSE;   }   /* check */   for (i = 1; i < stream->interpolation_size; i++) {      if (stream->model[0].vector_length != stream->model[1].vector_length) {         HTS_error(1, "HTS_Stream_load_pdf: # of states are different in between given modelsets./n");         HTS_Stream_clear(stream);         return FALSE;      }   }   /* set */   stream->vector_length = stream->model[0].vector_length;   return TRUE;}

/* HTS_ModelSet_get_gv_switch_index: get index of GV switch tree and PDF */void HTS_ModelSet_get_gv_switch_index(HTS_ModelSet * ms, char *string, int *tree_index, int *pdf_index){   HTS_Tree *tree;   HTS_Pattern *pattern;   HTS_Boolean find;   find = FALSE;   (*tree_index) = 2;   (*pdf_index) = 1;   for (tree = ms->gv_switch.tree; tree; tree = tree->next) {      pattern = tree->head;      if (!pattern)         find = TRUE;      for (; pattern; pattern = pattern->next)         if (HTS_pattern_match(string, pattern->string)) {            find = TRUE;            break;         }      if (find)         break;      (*tree_index)++;   }   if (tree == NULL) {      HTS_error(1, "HTS_ModelSet_get_gv_switch_index: Cannot find model %s./n", string);      return;   }   (*pdf_index) = HTS_Tree_search_node(tree, string);}

/* HTS_Audio_write_buffer: send buffer to audio device */static void HTS_Audio_write_buffer(HTS_Audio * audio){   MMRESULT error;   if (audio->which_buff == 1) {      while (audio->now_buff_1 == TRUE)         Sleep(AUDIO_WAIT_BUFF_MS);      audio->now_buff_1 = TRUE;      audio->which_buff = 2;      memcpy(audio->buff_1.lpData, audio->buff, audio->buff_size * sizeof(short));      audio->buff_1.dwBufferLength = audio->buff_size * sizeof(short);      error = waveOutWrite(audio->hwaveout, &(audio->buff_1), sizeof(WAVEHDR));   } else {      while (audio->now_buff_2 == TRUE)         Sleep(AUDIO_WAIT_BUFF_MS);      audio->now_buff_2 = TRUE;      audio->which_buff = 1;      memcpy(audio->buff_2.lpData, audio->buff, audio->buff_size * sizeof(short));      audio->buff_2.dwBufferLength = audio->buff_size * sizeof(short);      error = waveOutWrite(audio->hwaveout, &(audio->buff_2), sizeof(WAVEHDR));   }   if (error != MMSYSERR_NOERROR)      HTS_error(0, "hts_engine: Cannot send datablocks to your output audio device to play waveform./n");}

/* HTS_fread: wrapper for fread */static size_t HTS_fread(void *buf, size_t size, size_t n, HTS_File * fp){   if (fp == NULL || size == 0 || n == 0) {      return 0;   }   if (fp->type == HTS_FILE) {      return fread(buf, size, n, (FILE *) fp->pointer);   } else if (fp->type == HTS_DATA) {      HTS_Data *d = (HTS_Data *) fp->pointer;      size_t i, length = size * n;      unsigned char *c = (unsigned char *) buf;      for (i = 0; i < length; i++) {         if (d->index < d->size)            c[i] = d->data[d->index++];         else            break;      }      if (i == 0)         return 0;      else         return i / size;   }   HTS_error(0, "HTS_fread: Unknown file type./n");   return 0;}

/* HTS_ModelSet_get_parameter_index: get index of parameter tree and PDF */void HTS_ModelSet_get_parameter_index(HTS_ModelSet * ms, char *string,                                      int *tree_index, int *pdf_index,                                      int stream_index, int state_index,                                      int interpolation_index){   HTS_Tree *tree;   HTS_Pattern *pattern;   HTS_Boolean find;   find = FALSE;   (*tree_index) = 2;   (*pdf_index) = 1;   for (tree = ms->stream[stream_index].model[interpolation_index].tree; tree;        tree = tree->next) {      if (tree->state == state_index) {         pattern = tree->head;         if (!pattern)            find = TRUE;         for (; pattern; pattern = pattern->next)            if (HTS_pattern_match(string, pattern->string)) {               find = TRUE;               break;            }         if (find)            break;      }      (*tree_index)++;   }   if (tree == NULL)      HTS_error(1, "HTS_ModelSet_get_parameter_index: Cannot find model %s./n",                string);   (*pdf_index) = HTS_Tree_search_node(tree, string);}

/* HTS_ModelSet_load_parameter: load model */HTS_Boolean HTS_ModelSet_load_parameter(HTS_ModelSet * ms, HTS_File ** pdf_fp, HTS_File ** tree_fp, HTS_File ** win_fp, int stream_index, int window_size, int interpolation_size){   int i;   /* check */   if (ms == NULL) {      return FALSE;   }   if (stream_index < 0 || stream_index >= ms->nstream || window_size <= 0 || interpolation_size <= 0) {      HTS_ModelSet_clear(ms);      return FALSE;   }   if (pdf_fp == NULL) {      HTS_error(1, "HTS_ModelSet_load_parameter: File for pdfs is not specified./n");      HTS_ModelSet_clear(ms);      return FALSE;   }   if (tree_fp == NULL) {      HTS_error(1, "HTS_ModelSet_load_parameter: File for wins is not specified./n");      HTS_ModelSet_clear(ms);      return FALSE;   }   if (win_fp == NULL) {      HTS_error(1, "HTS_ModelSet_load_parameter: File for wins is not specified./n");      HTS_ModelSet_clear(ms);      return FALSE;   }   /* initialize */   if (!ms->stream) {      ms->stream = (HTS_Stream *) HTS_calloc(ms->nstream, sizeof(HTS_Stream));      for (i = 0; i < ms->nstream; i++)         HTS_Stream_initialize(&ms->stream[i]);   }   /* load */   if (HTS_Stream_load_pdf_and_tree(&ms->stream[stream_index], pdf_fp, tree_fp, interpolation_size) == FALSE) {      HTS_ModelSet_clear(ms);      return FALSE;   }   if (HTS_Stream_load_dynamic_window(&ms->stream[stream_index], win_fp, window_size) == FALSE) {      HTS_ModelSet_clear(ms);      return FALSE;   }   return TRUE;}

/* HTS_Node_find: find node for given number */static HTS_Node *HTS_Node_find(HTS_Node * node, const int num){   for (; node; node = node->next)      if (node->index == num)         return node;   HTS_error(1, "HTS_Node_find: Cannot find node %d./n", num);   return NULL;                 /* make compiler happy */}

/* HTS_get_fp: wrapper for fopen */FILE *HTS_get_fp(const char *name, const char *opt){   FILE *fp = fopen(name, opt);   if (fp == NULL)      HTS_error(2, "HTS_get_fp: Cannot open %s./n", name);   return (fp);}

/* HTS_Audio_flush: flush remain data */void HTS_Audio_flush(HTS_Audio * audio){   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_Stream_load_pdf_and_tree: load PDFs and trees */static HTS_Boolean HTS_Stream_load_pdf_and_tree(HTS_Stream * stream, HTS_File ** pdf_fp, HTS_File ** tree_fp, int interpolation_size){   int i;   HTS_Boolean result = TRUE;   /* initialize */   stream->interpolation_size = interpolation_size;   stream->model = (HTS_Model *) HTS_calloc(interpolation_size, sizeof(HTS_Model));   /* load */   for (i = 0; i < stream->interpolation_size; i++) {      if (!pdf_fp[i]) {         HTS_error(1, "HTS_Stream_load_pdf_and_tree: File for duration PDFs is not specified./n");         HTS_Stream_clear(stream);         return FALSE;      }      if (!tree_fp[i]) {         HTS_error(1, "HTS_Stream_load_pdf_and_tree: File for duration trees is not specified./n");         HTS_Stream_clear(stream);         return FALSE;      }      HTS_Model_initialize(&stream->model[i]);      result = HTS_Model_load_tree(&stream->model[i], tree_fp[i]);      if (result == FALSE) {         HTS_Stream_clear(stream);         return FALSE;      }      result = HTS_Model_load_pdf(&stream->model[i], pdf_fp[i], stream->model[i].ntree, &stream->msd_flag);      if (result == FALSE) {         HTS_Stream_clear(stream);         return FALSE;      }   }   /* check */   for (i = 1; i < stream->interpolation_size; i++)      if (stream->model[0].vector_length != stream->model[i].vector_length) {         HTS_error(1, "HTS_Stream_load_pdf_and_tree: Vector sizes of state output vectors are different in between given modelsets./n");         HTS_Stream_clear(stream);         return FALSE;      }   /* set */   stream->vector_length = stream->model[0].vector_length;   return TRUE;}

/* HTS_Audio_write: send data to audio device */void HTS_Audio_write(HTS_Audio * audio, short data){   audio->buff[audio->buff_size++] = data;   if (audio->buff_size >= audio->max_buff_size) {      audio->err = Pa_WriteStream(audio->stream, audio->buff, audio->max_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_Question_find_question: find question from question list */static HTS_Question *HTS_Question_find_question(HTS_Question * question, const char *buff){   for (; question; question = question->next)      if (strcmp(buff, question->string) == 0)         return question;   HTS_error(1, "HTS_Question_find_question: Cannot find question %s./n", buff);   return NULL;                 /* make compiler happy */}

/* HTS_fopen: wrapper for fopen */HTS_File *HTS_fopen(const char *name, const char *opt){   HTS_File *fp = utf8_fopen(name, opt);   if (fp == NULL) {      HTS_error(1, "HTS_fopen: Cannot open %s./n", name);      return NULL;   }   return fp;}

/* HTS_feof: wrapper for feof */int HTS_feof(HTS_File *fp) {    if (fp == NULL) {        return 1;    } else if (fp->type == HTS_FILE) {        return feof((FILE *) fp->pointer);    } else if (fp->type == HTS_DATA) {        HTS_Data *d = (HTS_Data *) fp->pointer;        return d->size <= d->index ? 1 : 0;    }    HTS_error(0, "HTS_feof: Unknown file type./n");    return 1;}

/* HTS_calloc: wrapper for calloc */char *HTS_calloc(const size_t num, const size_t size){#ifdef FESTIVAL   char *mem = (char *) safe_wcalloc(num * size);#else   char *mem = (char *) calloc(num, size);#endif                          /* FESTIVAL */   if (mem == NULL)      HTS_error(1, "HTS_calloc: Cannot allocate memory./n");   return mem;}

/* HTS_fgetc: wrapper for fgetc */int HTS_fgetc(HTS_File *fp) {    if (fp == NULL) {        return EOF;    } else if (fp->type == HTS_FILE) {        return fgetc((FILE *) fp->pointer);    } else if (fp->type == HTS_DATA) {        HTS_Data *d = (HTS_Data *) fp->pointer;        if (d->size <= d->index)            return EOF;        return (int) d->data[d->index++];    }    HTS_error(0, "HTS_fgetc: Unknown file type./n");    return EOF;}

/* 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_calloc: wrapper for calloc */void *HTS_calloc(const size_t num, const size_t size){   size_t n = num * size;#ifdef FESTIVAL   void *mem = (void *) safe_wcalloc(n);#else   void *mem = (void *) malloc(n);#endif                          /* FESTIVAL */   memset(mem, 0, n);   if (mem == NULL)      HTS_error(1, "HTS_calloc: Cannot allocate memory./n");   return mem;}

/* HTS_ftell: rapper for ftell */size_t HTS_ftell(HTS_File * fp){   if (fp == NULL) {      return 0;   } else if (fp->type == HTS_FILE) {      fpos_t pos;      fgetpos((FILE *) fp->pointer, &pos);#if defined(_WIN32) || defined(__CYGWIN__) || defined(__APPLE__) || defined(__ANDROID__)      return (size_t) pos;#else      return (size_t) pos.__pos;#endif                          /* _WIN32 || __CYGWIN__ || __APPLE__ || __ANDROID__ */   }   HTS_error(0, "HTS_ftell: Unknown file type./n");   return 0;}

/* HTS_Label_load_from_strings: load label from strings */void HTS_Label_load_from_strings(HTS_Label * label, size_t sampling_rate, size_t fperiod, char **lines, size_t num_lines){   char buff[HTS_MAXBUFLEN];   HTS_LabelString *lstring = NULL;   size_t i;   size_t data_index;   double start, end;   const double rate = (double) sampling_rate / ((double) fperiod * 1e+7);   if (label->head || label->size != 0) {      HTS_error(1, "HTS_Label_load_from_fp: label list is not initialized./n");      return;   }   /* copy label */   for (i = 0; i < num_lines; i++) {      if (!isgraph((int) lines[i][0]))         break;      label->size++;      if (lstring) {         lstring->next = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString));         lstring = lstring->next;      } else {                  /* first time */         lstring = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString));         label->head = lstring;      }      data_index = 0;      if (isdigit_string(lines[i])) {   /* has frame infomation */         HTS_get_token_from_string(lines[i], &data_index, buff);         start = atof(buff);         HTS_get_token_from_string(lines[i], &data_index, buff);         end = atof(buff);         HTS_get_token_from_string(lines[i], &data_index, buff);         lstring->name = HTS_strdup(buff);         lstring->start = rate * start;         lstring->end = rate * end;      } else {         lstring->start = -1.0;         lstring->end = -1.0;         lstring->name = HTS_strdup(lines[i]);      }      lstring->next = NULL;   }   HTS_Label_check_time(label);}