festival.c

#
#define GITKR_SPEECH_FESTIVAL_C

#include "gitkrincludes.h"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

FT_Info *festival_initialize(char *host, int port, char *mode) {
  FT_Info *info;

  info=calloc(1,sizeof(FT_Info));

  info->server_host=((host!=NULL)?host:FESTIVAL_DEFAULT_SERVER_HOST);
  info->server_port=((port!=-1  )?port:FESTIVAL_DEFAULT_SERVER_PORT);
  info->text_mode  =((mode!=NULL)?mode:FESTIVAL_DEFAULT_TEXT_MODE  );

  if((info->server_fd = festival_socket_open(info->server_host, info->server_port))==-1) {
    gitk_log("can't connect to festival speech service");
    festival_done(info);return(NULL);
  }
  
  return(info);
}

void festival_done(FT_Info *info) {
  if(!info) return;

  if(info->server_fd!=-1) close(info->server_fd);

  free(info);
}

void festival_say_text(FT_Info *info, const char *text) {
  FILE *fd;
  const char *p;
  char  *exp;
  char str[1024];
  unsigned int sl;
  int rc;

  if(!info) return;
  if(info->server_fd == -1) return;

  fd=fdopen(dup(info->server_fd),"wb");
  //-- copy text over to server, escaping any quotes
  fprintf(fd,"(SayText \"");
  for(p=text;(p && (*p!='\0'));p++) {
    //-- escape chars like '"' '\' with another '\' 
    if((*p=='"')||(*p=='\\')) putc('\\',fd);
    putc(*p,fd);
  }
  fputs("\")",fd);  
  fclose(fd);
  
  do
  {
    rc = festival_server_results(info->server_fd);
    switch (rc){
      case FESTIVAL_SERVER_OK:
        gitk_log("festival response : okay");
        break;
      case FESTIVAL_SERVER_WAVEFORM:
        gitk_log("festival response : waveform");
        break;
      case FESTIVAL_SERVER_EXPR:
        gitk_log("festival response : expression");
  exp = socket_receive_file_to_buff(info->server_fd, &sl);
  if(sl>0) {
    exp[sl]='\0';
    gitk_log1("  expression : \"%s\"",exp);
  }
        break;
  /*read(info->server_fd,str,1024);
  sl=strlen(str);
  if(sl>0) {
    str[sl-1]='\0';
    gitk_log1("  expression : \"%s\"",str);
  }
        break;*/
      case FESTIVAL_SERVER_ERROR:
        gitk_log("festival response : error");
        return;
    }  
  }while(rc>0);
}

FT_Wave *festival_text2wave(FT_Info *info, const char *text) {
  FT_Wave *wave = NULL;
  FILE *fd;
  const char *p;
  char *exp;
  unsigned int sl;
  int rc;
  
  //gitk_log("festival_text2wave() beg");

  if(!info) return NULL;
  if(info->server_fd == -1) return NULL;
  
  wave = (FT_Wave *)malloc(sizeof(FT_Wave));
  if(!wave)return NULL;
  wave->sample_rate = 16000;  

  fd=fdopen(dup(info->server_fd),"wb");
  //-- copy text over to server, escaping any quotes
  fprintf(fd,"(utt.send.wave.client (utt.synth (set! utt1 (Utterance Text \"");
  for(p=text;(p && (*p!='\0'));p++) {
    //-- escape chars like '"' '\' with another '\' 
    if((*p=='"')||(*p=='\\')) putc('\\',fd);
    putc(*p,fd);
  }
  fputs("\"))))",fd);
  fclose(fd);
  
  do
  {
    rc = festival_server_results(info->server_fd);
    switch (rc){
      case FESTIVAL_SERVER_OK:
        gitk_log("festival response : okay");
        break;
      case FESTIVAL_SERVER_WAVEFORM:
        //gitk_log("festival response : waveform beg");
        wave->samples = (short *)socket_receive_file_to_buff(info->server_fd, &(wave->num_samples));
        wave->num_samples = (wave->num_samples)/2;
        //gitk_log("festival response : waveform end");
        break;
      case FESTIVAL_SERVER_EXPR:
        //gitk_log("festival response : expression");
  exp = socket_receive_file_to_buff(info->server_fd, &sl);
  if(sl>0) {
    exp[sl]='\0';
    gitk_log1("  expression : \"%s\"",exp);
  }
        break;
      case FESTIVAL_SERVER_ERROR:
        //gitk_log("festival response : error");
        return NULL;
    } 
  }while(rc!=FESTIVAL_SERVER_OK);
  //gitk_log("festival_text2wave() end");
  return wave;
}

void festival_play_wave(FT_Info *info, const char *filename) {
  FILE *fd;
  const char *p;
  char  *exp;
  char str[1024];
  unsigned int sl;
  int rc;

  if(!info) return;
  if(info->server_fd == -1) return;

  fd=fdopen(dup(info->server_fd),"wb");
  //-- copy text over to server, escaping any quotes
  fprintf(fd,"(wave.play (wave.load \"");
  for(p=filename;(p && (*p!='\0'));p++) {
    //-- escape chars like '"' '\' with another '\' 
    if((*p=='"')||(*p=='\\')) putc('\\',fd);
    putc(*p,fd);
  }
  fputs("\" \"wav\" 16 44100))",fd);  
  fclose(fd);
  
  do
  {
    rc = festival_server_results(info->server_fd);
    switch (rc){
      case FESTIVAL_SERVER_OK:
        gitk_log("festival response : okay");
        break;
      case FESTIVAL_SERVER_WAVEFORM:
        gitk_log("festival response : waveform");
        break;
      case FESTIVAL_SERVER_EXPR:
        gitk_log("festival response : expression");
  exp = socket_receive_file_to_buff(info->server_fd, &sl);
  if(sl>0) {
    exp[sl]='\0';
    gitk_log1("  expression : \"%s\"",exp);
  }
        break;
  /*read(info->server_fd,str,1024);
  sl=strlen(str);
  if(sl>0) {
    str[sl-1]='\0';
    gitk_log1("  expression : \"%s\"",str);
  }
        break;*/
      case FESTIVAL_SERVER_ERROR:
        gitk_log("festival response : error");
        return;
    }  
  }while(rc>0);
}

FT_Alaw *festival_string_to_alaw(FT_Info *info, const char *text) 
{  
  FT_Wave *wave = NULL;
  FT_Alaw *alaw = NULL;

  if (info == 0) return 0;
  if (info->server_fd == -1)
  {
    fprintf(stderr,"festival_client: server connection unopened\n");
    return 0;
  }
  alaw = (FT_Alaw*)malloc(sizeof(FT_Alaw));
  if(!alaw)return NULL; 
  wave = festival_text2wave(info, text);  
  if(!wave)return NULL;
  if(festival_wav2alaw(wave, alaw)<=0)return NULL; 
  if(wave){
    if(wave->samples)free(wave->samples);
    free(wave);
  }
  wave = NULL; 
  return alaw;
}

//-- private helper

static int festival_socket_open(const char *host, int port) {   
  struct sockaddr_in serv_addr;
  struct hostent *serverhost;
  int fd;

  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  if (fd < 0) {
    gitk_log("festival_client: can't get socket");
    return -1;
  }
  memset(&serv_addr, 0, sizeof(serv_addr));
  if ((serv_addr.sin_addr.s_addr = inet_addr(host)) == -1) {
    /* its a name rather than an ipnum */
    serverhost = gethostbyname(host);
    if (serverhost == (struct hostent *)0) {
      gitk_log("festival_client: gethostbyname failed");
      return -1;
    }
    memmove(&serv_addr.sin_addr,serverhost->h_addr, serverhost->h_length);
  }
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(port);

  if (connect(fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != 0) {
    gitk_log("festival_client: connect to server failed");
    return -1;
  }

  return fd;
}

static int festival_server_results(int fd)
{
  char ack[4];
  int n;

  if (fd == -1)
  {
    fprintf(stderr,"festival_client: server connection unopened\n");
    return -1;
  }
  for (n=0; n < 3; )n += read(fd,ack+n,3-n);
  ack[3] = '\0';
  if (strcmp(ack,"WV\n") == 0)         /* receive a waveform */
    return FESTIVAL_SERVER_WAVEFORM;
  else if (strcmp(ack,"LP\n") == 0)    /* receive an s-expr */
    return FESTIVAL_SERVER_EXPR;
  else if (strcmp(ack,"ER\n") == 0)    /* server got an error */
    return FESTIVAL_SERVER_ERROR;
  else if (strcmp(ack,"OK\n") == 0)    /* server got an okay */
    return FESTIVAL_SERVER_OK;
  return 4711;
}

static char *socket_receive_file_to_buff(int fd,int *size)
{
  /* Receive file (probably a waveform file) from socket using   */
  /* Festival key stuff technique, but long winded I know, sorry */
  /* but will receive any file without closeing the stream or    */
  /* using OOB data                                              */
  static char *file_stuff_key = "ft_StUfF_key"; /* must == Festival's key */
  char *buff;
  int bufflen;
  int n,k,i;
  char c;
    
  //bufflen = 1024;/* the original of socket_receive_file_to_buff() */
  bufflen = 32768;// 2048;
  buff = (char *)malloc(bufflen);
  *size=0;
  gitk_log("socket_recieve_file_to_buff() beg");
  for (k=0; file_stuff_key[k] != '\0';)
  {
    n = read(fd,&c,1);
    if (n==0) break;  /* hit stream eof before end of file */
    if ((*size)+k+1 >= bufflen)
    {   /* +1 so you can add a NULL if you want */
      bufflen += bufflen/4;
      //gitk_log("socket_recieve_file_to_buff() Puffer mit realloc vergroessert");
      buff = (char *)realloc(buff,bufflen);
    }
    if (file_stuff_key[k] == c) k++;
    else if ((c == 'X') && (file_stuff_key[k+1] == '\0'))
    {   /* It looked like the key but wasn't */
      for (i=0; i < k; i++,(*size)++) 
      buff[*size] = file_stuff_key[i];
      k=0;
      /* omit the stuffed 'X' */
    } else {
      for (i=0; i < k; i++,(*size)++) buff[*size] = file_stuff_key[i];
      k=0;
      buff[*size] = c;
      (*size)++;
    }
  }
  gitk_log1("socket_recieve_file_to_buff() end size = %d", *size);
  return buff;
}

int festival_wav2alaw(FT_Wave *wave, FT_Alaw *alaw)
{
  int i;
  short index;
  char *al;
  void *wav;
  char wav_channels;
  
  if(wave==0) return 0;
  
  if(alaw==NULL)alaw = malloc(sizeof(FT_Alaw));
  wav = wave->samples;
  wav_channels = ((char *)wav)[22];
  
  //gitk_log1("wav_channels %d", wav_channels);
  if(wav_channels > 2 && wav_channels < 1)wav_channels = 1;
  
  alaw->num_samples = wave->num_samples/2;
  alaw->num_samples = alaw->num_samples/wav_channels;
  alaw->samples = (char *)malloc(alaw->num_samples*sizeof(char));  
  al = (char *)alaw->samples;  
  //pcmTable auslesen
  for (i=0;i<alaw->num_samples;i+=wav_channels)
  {
    index=(((short*)wav)[2*i])/8;
    (*(++al))=pcmTable[index+4096];
    //al++;
  }    
  return alaw->num_samples;   
}

---