void MyFrame::OnAbout(wxCommandEvent& event)
{//=========================================
int result;
char buf[300];
wxString url_docs;
wxBoxSizer *topsizer;
HtmlWindow *html;
wxDialog dlg(this, wxID_ANY, wxString(_("About")));
topsizer = new wxBoxSizer(wxVERTICAL);
switch(event.GetId())
{
case MENU_ABOUT:
{
sprintf(buf,about_string,espeak_Info(NULL));
html = new HtmlWindow(&dlg, wxID_ANY, wxDefaultPosition, wxSize(380, 160), wxHW_SCROLLBAR_NEVER);
html -> SetBorders(0);
html -> SetPage(wxString(buf,wxConvLocal));
html -> SetSize(html -> GetInternalRepresentation() -> GetWidth(),
html -> GetInternalRepresentation() -> GetHeight());
topsizer -> Add(html, 1, wxALL, 10);
//#if wxUSE_STATLINE
// topsizer -> Add(new wxStaticLine(&dlg, wxID_ANY), 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
//#endif // wxUSE_STATLINE
wxButton *bu1 = new wxButton(&dlg, wxID_OK, _("OK"));
bu1 -> SetDefault();
topsizer -> Add(bu1, 0, wxALL | wxALIGN_RIGHT, 15);
dlg.SetSizer(topsizer);
topsizer -> Fit(&dlg);
dlg.ShowModal();
}
break;
case MENU_DOCS:
strcpy(buf,"/docs/docindex.html");
url_docs = wxGetCwd() + wxString(buf,wxConvLocal); // look for "docs" in the current directory
if(!wxFileExists(url_docs))
{
strcpy(buf,"http://espeak.sourceforge.net/docindex.html");
url_docs = wxString(buf,wxConvLocal);
}
else
{
url_docs = _T("file://") + url_docs;
}
result = wxLaunchDefaultBrowser(url_docs);
if(result == 0)
wxLogStatus(_T("Failed to launch default browser: "+url_docs));
break;
}
}
static void PrintVersion()
{
const char *version;
const char *path_data;
espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, NULL, espeakINITIALIZE_DONT_EXIT);
version = espeak_Info(&path_data);
printf("eSpeak NG text-to-speech: %s Data at: %s\n", version, path_data);
}
static int spk_construct(volatile SpeechSynthesizer *spk, char **parameters)
{
char *data_path, *voicename, *punctlist;
int result;
spk->setVolume = spk_setVolume;
spk->setRate = spk_setRate;
spk->setPitch = spk_setPitch;
spk->setPunctuation = spk_setPunctuation;
spk->drain = spk_drain;
logMessage(LOG_INFO, "eSpeak-NG version %s", espeak_Info(NULL));
data_path = parameters[PARM_PATH];
if (data_path && !*data_path)
data_path = NULL;
result = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, 0);
if (result < 0) {
logMessage(LOG_ERR, "eSpeak-NG: initialization failed");
return 0;
}
voicename = parameters[PARM_VOICE];
if(!voicename || !*voicename)
voicename = "en";
result = espeak_SetVoiceByName(voicename);
if (result != EE_OK) {
espeak_VOICE voice_select;
memset(&voice_select, 0, sizeof(voice_select));
voice_select.languages = voicename;
result = espeak_SetVoiceByProperties(&voice_select);
}
if (result != EE_OK) {
logMessage(LOG_ERR, "eSpeak-NG: unable to load voice '%s'", voicename);
return 0;
}
punctlist = parameters[PARM_PUNCTLIST];
if (punctlist && *punctlist) {
wchar_t w_punctlist[strlen(punctlist) + 1];
int i = 0;
while ((w_punctlist[i] = punctlist[i]) != 0) i++;
espeak_SetPunctuationList(w_punctlist);
}
if (parameters[PARM_MAXRATE]) {
int val = atoi(parameters[PARM_MAXRATE]);
if (val > espeakRATE_MINIMUM) maxrate = val;
}
espeak_SetSynthCallback(SynthCallback);
return 1;
}
// Initialise this in OnInit, not statically
bool MyApp::OnInit(void)
{//=====================
int j;
wxChar *p;
char param[80];
if(argc > 1)
{
p = argv[1];
j = 0;
while((param[j] = p[j]) != 0) j++;
if((strcmp(param,"--help")==0) || (strcmp(param,"-h")==0))
{
printf(about_string2,espeak_Info(NULL));
printf("%s", help_text);
exit(0);
}
ConfigInit();
if(strcmp(param,"--compile")==0)
{
LoadPhData(NULL);
samplerate_native = samplerate = 22050;
CompilePhonemeData();
CompileIntonation();
}
exit(0);
}
ConfigInit();
gui_flag = 1;
// It seems that the wctype functions don't work until the locale has been set
// to something other than the default "C". Then, not only Latin1 but also the
// other characters give the correct results with iswalpha() etc.
if(setlocale(LC_CTYPE,"en_US.UTF-8") == NULL)
{
if(setlocale(LC_CTYPE,"UTF-8") == NULL)
setlocale(LC_CTYPE,"");
}
if((frame_w == 0) || (frame_h == 0))
{
frame_w = 800;
frame_h = 768;
}
// Create the main frame window
myframe = new MyFrame(NULL, -1, AppName, wxPoint(frame_x, frame_y), wxSize(frame_w, frame_h),
wxDEFAULT_FRAME_STYLE |
wxNO_FULL_REPAINT_ON_RESIZE |
wxHSCROLL | wxVSCROLL);
// Make a menubar
myframe->SetMenuBar(MakeMenu(0, voice_name2));
myframe->CreateStatusBar();
myframe->SetVoiceTitle(voice_name2);
// myframe->Maximize();
myframe->Show(TRUE);
SetTopWindow(myframe);
wxInitAllImageHandlers();
// wxImage::AddHandler(wxPNGHandler);
return TRUE;
}
static int espeak_init(char **status_info)
{
int ret;
const char *espeak_version;
GString *info;
log_msg(OTTS_LOG_NOTICE, "Espeak: Module init().");
/* Make sure the glib functions are thread safe. */
if (!g_thread_supported())
g_thread_init(NULL);
*status_info = NULL;
info = g_string_new("");
/* Report versions. */
espeak_version = espeak_Info(NULL);
log_msg(OTTS_LOG_INFO,
"Espeak: espeak Output Module version %s, espeak Engine version %s",
MODULE_VERSION, espeak_version);
/* <Espeak setup */
log_msg(OTTS_LOG_INFO,
"Espeak: Initializing engine with buffer size %d ms.",
EspeakAudioChunkSize);
#if ESPEAK_API_REVISION == 1
espeak_sample_rate =
espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, EspeakAudioChunkSize,
NULL);
#else
espeak_sample_rate =
espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, EspeakAudioChunkSize,
NULL, 0);
#endif
if (espeak_sample_rate == EE_INTERNAL_ERROR) {
log_msg(OTTS_LOG_CRIT, "Espeak: Could not initialize engine.");
*status_info = g_strdup("Could not initialize engine. ");
return FATAL_ERROR;
}
log_msg(OTTS_LOG_INFO, "Espeak: Registering callbacks.");
espeak_SetSynthCallback(synth_callback);
espeak_SetUriCallback(uri_callback);
log_msg(OTTS_LOG_DEBUG,
"Setting up espeak specific configuration settings.");
ret = espeak_set_punctuation_list_from_utf8(EspeakPunctuationList);
if (ret != OK)
log_msg(OTTS_LOG_WARN,
"Espeak: Failed to set punctuation list.");
espeak_voice_list = espeak_list_synthesis_voices();
/* Reset global state */
espeak_state_reset();
/* <Threading setup */
/* These mutexes are locked when the corresponding threads are suspended. */
pthread_mutex_init(&espeak_stop_or_pause_suspended_mutex, NULL);
pthread_mutex_init(&espeak_play_suspended_mutex, NULL);
/* This mutex mediates access to the playback queue between the espeak synthesis thread andthe the playback thread. */
pthread_mutex_init(&playback_queue_mutex, NULL);
pthread_cond_init(&playback_queue_condition, NULL);
/* The following mutex protects access to various flags */
pthread_mutex_init(&espeak_state_mutex, NULL);
log_msg(OTTS_LOG_NOTICE,
"Espeak: Creating new thread for stop or pause.");
espeak_stop_or_pause_semaphore = module_semaphore_init();
ret =
pthread_create(&espeak_stop_or_pause_thread, NULL,
_espeak_stop_or_pause, NULL);
if (0 != ret) {
ABORT("Failed to create stop-or-pause thread.");
}
espeak_play_semaphore = module_semaphore_init();
log_msg(OTTS_LOG_INFO, "Espeak: Creating new thread for playback.");
ret = pthread_create(&espeak_play_thread, NULL, _espeak_play, NULL);
if (ret != OK) {
ABORT("Failed to create playback thread.");
}
*status_info = g_strdup("Espeak: Initialized successfully.");
return OK;
}
int main (int argc, char **argv)
//==============================
{
static struct option long_options[] =
{
/* These options set a flag. */
// {"verbose", no_argument, &verbose_flag, 1},
// {"brief", no_argument, &verbose_flag, 0},
/* These options don't set a flag.
We distinguish them by their indices. */
{"help", no_argument, 0, 'h'},
{"stdin", no_argument, 0, 0x100},
{"compile-debug", optional_argument, 0, 0x101},
{"compile", optional_argument, 0, 0x102},
{"punct", optional_argument, 0, 0x103},
{"voices", optional_argument, 0, 0x104},
{"stdout", no_argument, 0, 0x105},
{"split", optional_argument, 0, 0x106},
{0, 0, 0, 0}
};
static const char* err_load = "Failed to read ";
FILE *f_text=NULL;
char *p_text=NULL;
int option_index = 0;
int c;
int ix;
int flag_stdin = 0;
int flag_compile = 0;
int filesize = 0;
int synth_flags = espeakCHARS_AUTO | espeakPHONEMES | espeakENDPAUSE;
int volume = -1;
int speed = -1;
int pitch = -1;
int wordgap = -1;
int option_capitals = -1;
int option_punctuation = -1;
int option_phonemes = -1;
int option_linelength = 0;
int option_waveout = 0;
char filename[120];
char voicename[40];
char voice_mbrola[20];
char dictname[40];
#define N_PUNCTLIST 100
wchar_t option_punctlist[N_PUNCTLIST];
voicename[0] = 0;
voice_mbrola[0] = 0;
dictname[0] = 0;
wavefile[0] = 0;
filename[0] = 0;
option_punctlist[0] = 0;
while(true)
{
c = getopt_long (argc, argv, "a:bf:g:hk:l:mp:qs:v:w:xXz",
long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
switch (c)
{
case 'b':
synth_flags |= espeakCHARS_8BIT;
break;
case 'h':
printf("\n");
printf("eSpeak text-to-speech: %s\n%s",espeak_Info(NULL),help_text);
exit(0);
break;
case 'k':
option_capitals = atoi(optarg);
break;
case 'x':
option_phonemes = 1;
break;
case 'X':
option_phonemes = 2;
break;
case 'm':
synth_flags |= espeakSSML;
break;
case 'p':
pitch = atoi(optarg);
break;
case 'q':
quiet = 1;
break;
case 'f':
strncpy0(filename,optarg,sizeof(filename));
break;
case 'l':
option_linelength = atoi(optarg);
break;
case 'a':
volume = atoi(optarg);
break;
case 's':
speed = atoi(optarg);
break;
case 'g':
wordgap = atoi(optarg);
break;
case 'v':
strncpy0(voicename,optarg,sizeof(voicename));
break;
case 'w':
option_waveout = 1;
strncpy0(wavefile,optarg,sizeof(filename));
break;
case 'z': // remove pause from the end of a sentence
synth_flags &= ~espeakENDPAUSE;
break;
case 0x100: // --stdin
flag_stdin = 1;
break;
case 0x105: // --stdout
option_waveout = 1;
strcpy(wavefile,"stdout");
break;
case 0x101: // --compile-debug
case 0x102: // --compile
strncpy0(voicename,optarg,sizeof(voicename));
flag_compile = c;
quiet = 1;
break;
case 0x103: // --punct
option_punctuation = 1;
if(optarg != NULL)
{
ix = 0;
while((ix < N_PUNCTLIST) && ((option_punctlist[ix] = optarg[ix]) != 0)) ix++;
option_punctlist[N_PUNCTLIST-1] = 0;
option_punctuation = 2;
}
break;
case 0x104: // --voices
espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS,0,NULL,0);
DisplayVoices(stdout,optarg);
exit(0);
case 0x106: // -- split
if(optarg == NULL)
samples_split = 30; // default 30 minutes
else
samples_split = atoi(optarg);
break;
default:
exit(0);
}
}
if(option_waveout || quiet)
{
// writing to a file (or no output), we can use synchronous mode
samplerate = espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS,0,NULL,0);
samples_split = (samplerate * samples_split) * 60;
espeak_SetSynthCallback(SynthCallback);
if(samples_split)
{
char *extn;
extn = strrchr(wavefile,'.');
if((extn != NULL) && ((wavefile + strlen(wavefile) - extn) <= 4))
{
strcpy(filetype,extn);
*extn = 0;
}
}
else
if(option_waveout)
{
if(OpenWavFile(wavefile,samplerate) != 0)
exit(4);
}
}
else
{
// play the sound output
samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK,0,NULL,0);
}
if(voicename[0] == 0)
strcpy(voicename,"default");
if(espeak_SetVoiceByName(voicename) != EE_OK)
{
fprintf(stderr,"%svoice '%s'\n",err_load,voicename);
exit(2);
}
if(flag_compile)
{
// This must be done after the voice is set
espeak_CompileDictionary("", stderr, flag_compile & 0x1);
exit(0);
}
// set any non-default values of parameters. This must be done after espeak_Initialize()
if(speed > 0)
espeak_SetParameter(espeakRATE,speed,0);
if(volume >= 0)
espeak_SetParameter(espeakVOLUME,volume,0);
if(pitch >= 0)
espeak_SetParameter(espeakPITCH,pitch,0);
if(option_capitals >= 0)
espeak_SetParameter(espeakCAPITALS,option_capitals,0);
if(option_punctuation >= 0)
espeak_SetParameter(espeakPUNCTUATION,option_punctuation,0);
if(wordgap >= 0)
espeak_SetParameter(espeakWORDGAP,wordgap,0);
if(option_linelength > 0)
espeak_SetParameter(espeakLINELENGTH,option_linelength,0);
if(option_punctuation == 2)
espeak_SetPunctuationList(option_punctlist);
if(option_phonemes >= 0)
espeak_SetPhonemeTrace(option_phonemes,stderr);
if(filename[0]==0)
{
if((optind < argc) && (flag_stdin == 0))
{
// there's a non-option parameter, and no -f or --stdin
// use it as text
p_text = argv[optind];
}
else
{
f_text = stdin;
if(flag_stdin == 0)
{
flag_stdin = 2;
}
}
}
else
{
filesize = GetFileLength(filename);
f_text = fopen(filename,"r");
}
if((f_text == NULL) && (p_text == NULL))
{
fprintf(stderr,"%sfile '%s'\n",err_load,filename);
exit(1);
}
if(p_text != NULL)
{
int size;
size = strlen(p_text);
espeak_Synth(p_text,size+1,0,POS_CHARACTER,0,synth_flags,NULL,NULL);
}
else
if(flag_stdin)
{
int max = 1000;
p_text = (char *)malloc(max);
if(flag_stdin == 2)
{
// line by line input on stdin
while(fgets(p_text,max,stdin) != NULL)
{
p_text[max-1] = 0;
espeak_Synth(p_text,max,0,POS_CHARACTER,0,synth_flags,NULL,NULL);
}
}
else
{
// bulk input on stdin
ix = 0;
while(!feof(stdin))
{
p_text[ix++] = fgetc(stdin);
if(ix >= (max-1))
{
max += 1000;
p_text = (char *)realloc(p_text,max);
}
}
if(ix > 0)
{
p_text[ix-1] = 0;
espeak_Synth(p_text,ix+1,0,POS_CHARACTER,0,synth_flags,NULL,NULL);
}
}
}
else
if(f_text != NULL)
{
if((p_text = (char *)malloc(filesize+1)) == NULL)
{
fprintf(stderr,"Failed to allocate memory %d bytes",filesize);
exit(3);
}
fread(p_text,1,filesize,f_text);
p_text[filesize]=0;
espeak_Synth(p_text,filesize+1,0,POS_CHARACTER,0,synth_flags,NULL,NULL);
fclose(f_text);
}
espeak_Synchronize();
return(0);
}
