long set_voice( const char* aName, const char* aLang=NULL, unsigned char aGender=0, unsigned char aAge=0, unsigned char aVariant = 0 ) { long result = 0; if (aLang || aGender || aAge || aVariant) { espeak_VOICE props = { 0 }; props.name = aName; props.languages = aLang; props.gender = aGender; props.age = aAge; props.variant = aVariant; result = espeak_SetVoiceByProperties(&props); } else { result = espeak_SetVoiceByName(aName); } // This way we don't need to allocate the name/lang strings to the heap. // Instead, we store the actual global voice. current_voice = espeak_GetCurrentVoice(); return result; }
eSpeak::eSpeak(std::unique_ptr<NUClear::Environment> environment) : Reactor(std::move(environment)) { // Initialize espeak, and set it to play out the speakers, and not exit if it can't find it's directory espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 500, nullptr, 1 << 15); espeak_SetVoiceByName("default"); espeak_SetParameter(espeakVOLUME, 100, 0); espeak_SetParameter(espeakCAPITALS, 6, 0); on<Trigger<messages::output::Say>, Options<Sync<eSpeak>>>([](const messages::output::Say& message) { // Wait to finish the current message (if any) // By waiting here this reaction can finish and return to the pool // if it does not have to wait for another say message espeak_Synchronize(); // Say the new message espeak_Synth(message.c_str(), // Text message.size() + 1, // Size (including null at end) 0, // Start position POS_CHARACTER, // Position Type (irrelevant since we start at the beginning) 0, // End position (0 means no end position) espeakCHARS_AUTO, // Flags (auto encoding) nullptr, // User identifier for callback nullptr // Callback ); }); on<Trigger<Shutdown>>([](const Shutdown&) { // Stop espeak espeak_Terminate(); }); }
static void reinitialize_espeak(struct synth_t *s) { int rate; /* Re-initialize espeak */ rate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 50, NULL, 0); if (rate < 0) { fprintf(stderr, "Unable to initialize espeak.\n"); return; } /* We need a callback in acsint mode, but not in speakup mode. */ if (espeakup_mode == ESPEAKUP_MODE_ACSINT) espeak_SetSynthCallback(acsint_callback); /* Set parameters again */ espeak_SetVoiceByName(s->voice); espeak_SetParameter(espeakRANGE, s->frequency * frequencyMultiplier, 0); espeak_SetParameter(espeakPITCH, s->pitch * pitchMultiplier, 0); espeak_SetParameter(espeakRATE, s->rate * rateMultiplier + rateOffset, 0); espeak_SetParameter(espeakVOLUME, (s->volume + 1) * volumeMultiplier, 0); espeak_SetParameter(espeakCAPITALS, 0, 0); paused_espeak = 0; return; }
static espeak_ERROR set_voice(struct synth_t *s, char *voice) { espeak_ERROR rc; rc = espeak_SetVoiceByName(voice); if (rc == EE_OK) strcpy(s->voice, voice); return rc; }
bool PlatformSpeechSynthesisProviderEfl::engineInit() { if (!m_isEngineStarted) { if (!(m_isEngineStarted = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, 0, 0) != EE_INTERNAL_ERROR)) return false; espeak_SetVoiceByName("default"); } return true; }
static void espeak_set_synthesis_voice(char *synthesis_voice) { if (synthesis_voice != NULL) { espeak_ERROR ret = espeak_SetVoiceByName(synthesis_voice); if (ret != EE_OK) { DBG("Espeak: Failed to set synthesis voice to %s.", synthesis_voice); } } }
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; }
//----------------------------------------------------------------------------- // InitSpeak - This function initializes the speech using the current file name // or parameters... //----------------------------------------------------------------------------- void RobotSpeak::InitSpeak() { espeak_ERROR err = EE_NOT_FOUND; // something other than OK... // See if this is the first time through if so register our release function. if (_bIDSDRSpeak == 0xff) _bIDSDRSpeak = SDRRegisterReleaseFunction(&_EndSpeak); // Tell our quick and dirty Sound registry stuff, that we want to be the current one... SDRSetCurrent(_bIDSDRSpeak); esoutput = AUDIO_OUTPUT_PLAYBACK; espeak_Initialize(esoutput, Buflength, path, Options ); // First see if someone registered a voice file name if (_pszVoiceFileName) { err = espeak_SetVoiceByName(_pszVoiceFileName); if (err != EE_OK) printf("Speak SetVoiceByProp failed %d\n", err); } else if (_pszVoiceLanguage) { espeak_VOICE voice; voice.name = NULL; voice.languages = _pszVoiceLanguage; voice.identifier= NULL; voice.age = 0; voice.gender = _bVoiceGender; voice.variant = 0; err = espeak_SetVoiceByProperties(&voice); if (err != EE_OK) printf("Speak SetVoiceByProp failed %d\n", err); } if (err != EE_OK) espeak_SetVoiceByName(g_szDefaultVoice); _fSpeakInit = true; }
/* Given a language code and SD voice code, sets the espeak voice. */ static void espeak_set_language_and_voice(char *lang, SPDVoiceType voice_code) { log_msg(OTTS_LOG_DEBUG, "Espeak: set_language_and_voice %s %d", lang, voice_code); espeak_ERROR ret; unsigned char overlay = 0; switch (voice_code) { case SPD_NO_VOICE: overlay = 0; break; case SPD_MALE1: overlay = 0; break; case SPD_MALE2: overlay = 1; break; case SPD_MALE3: overlay = 2; break; case SPD_FEMALE1: overlay = 11; break; case SPD_FEMALE2: overlay = 12; break; case SPD_FEMALE3: overlay = 13; break; case SPD_CHILD_MALE: overlay = 4; break; case SPD_CHILD_FEMALE: overlay = 14; break; } char *name = g_strdup_printf("%s+%d", lang, overlay); log_msg(OTTS_LOG_INFO, "Espeak: set_language_and_voice name=%s", name); ret = espeak_SetVoiceByName(name); if (ret != EE_OK) { log_msg(OTTS_LOG_WARN, "Espeak: Error selecting language %s", name); } else { log_msg(OTTS_LOG_DEBUG, "Espeak: Successfully set voice to \"%s\"", name); } g_free(name); }
int main(int argc, char* argv[] ) { output = AUDIO_OUTPUT_PLAYBACK; int I, Run = 1, L; espeak_Initialize(output, Buflength, path, Options ); espeak_SetVoiceByName(Voice); Size = strlen(text)+1; printf("Saying '%s'",text); espeak_Synth( text, Size, position, position_type, end_position, flags, unique_identifier, user_data ); espeak_Synchronize( ); printf("\n:Done\n"); return 0; }
void synth_(const char* aText, void* aCallback) { t_espeak_callback* cb = reinterpret_cast<t_espeak_callback*>(aCallback); espeak_SetSynthCallback(cb); espeak_SetParameter(espeakPITCH, pitch, 0); espeak_SetParameter(espeakRATE, rate, 0); if (current_voice) espeak_SetVoiceByProperties(current_voice); else espeak_SetVoiceByName("default"); espeak_Synth(aText, 0, 0, POS_CHARACTER, 0, 0, NULL, NULL); // Reset callback so other instances will work too. espeak_SetSynthCallback(NULL); }
static espeak_ERROR set_voice(struct synth_t *s, char *voice) { espeak_ERROR rc; espeak_VOICE voice_select; rc = espeak_SetVoiceByName(voice); if (rc != EE_OK) { memset(&voice_select, 0, sizeof(voice_select)); voice_select.languages = voice; rc = espeak_SetVoiceByProperties(&voice_select); } if (rc == EE_OK) strcpy(s->voice, voice); return rc; }
uint8_t speech_poll() { speech_list_t *p_list; if( speaking == 2 ) { SDL_PauseAudio( 1 ); speaking = 0; } if( speaking == 0 ) { SDL_mutexP( speech_mx ); if( speech_first ) { // Queue pop p_list = speech_first; speech_first = p_list->next; SDL_mutexV( speech_mx ); #ifdef USE_SAM // Set parameters sam_params( SAM_SCALE, SAM_SING, SAM_SPEED, SAM_PITCH, SAM_MOUTH, SAM_THROAT ); buf_pos = 0; buf_size = sizeof( buf ); if( sam_speak( buf, &buf_size, p_list->data ) == 0 ) buf_play(); #else printf( "Speech [info]: eSpeak voice return: %i\n", espeak_SetVoiceByName( p_list->voice ) ); espeak_SetParameter(espeakRATE,130,0); espeak_SetParameter(espeakRANGE,0,0); // espeak_SetParameter(espeakVOLUME,volume,0); // espeak_SetParameter(espeakPITCH,pitch,0); // espeak_SetParameter(espeakCAPITALS,option_capitals,0); // espeak_SetParameter(espeakPUNCTUATION,option_punctuation,0); // espeak_SetParameter(espeakWORDGAP,wordgap,0); // espeak_SetParameter(espeakLINELENGTH,option_linelength,0); // espeak_SetPunctuationList(option_punctlist); p_buf = buf; viseme_count = 0; espeak_Synth( p_list->data, strlen( p_list->data ) + 1, 0, POS_CHARACTER, 0, 0, NULL, NULL ); buf_play(); #endif free( p_list ); } else { SDL_mutexV( speech_mx ); } } return( speaking ); }
void PlatformSpeechSynthesisProviderEfl::speak(PassRefPtr<PlatformSpeechSynthesisUtterance> utterance) { if (!engineInit() || !utterance) { fireSpeechEvent(SpeechError); return; } m_utterance = utterance; String voice = voiceName(m_utterance); espeak_SetVoiceByName(voice.utf8().data()); espeak_SetParameter(espeakRATE, convertRateToEspeakValue(m_utterance->rate()), 0); espeak_SetParameter(espeakVOLUME, convertVolumeToEspeakValue(m_utterance->volume()), 0); espeak_SetParameter(espeakPITCH, convertPitchToEspeakValue(m_utterance->pitch()), 0); String textToRead = m_utterance->text(); espeak_ERROR err = espeak_Synth(textToRead.utf8().data(), textToRead.length(), 0, POS_CHARACTER, 0, espeakCHARS_AUTO, 0, nullptr); if (err == EE_INTERNAL_ERROR) { fireSpeechEvent(SpeechError); m_utterance = nullptr; return; } fireSpeechEvent(SpeechStart); }
void carmen_voice_initialize(char *language) { espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 500, NULL, 0); espeak_SetVoiceByName(language); }
static void espeak_voice(t_espeak*x, t_symbol*s){ espeak_ERROR err= espeak_SetVoiceByName(s->s_name); }
/*Used to set person in TTS. in the case of espeak we will set * language by this. return False if language is not available */ int T4K_Tts_set_voice(char voice_name[]){ if (espeak_SetVoiceByName(voice_name) == EE_OK) return 1; else return 0; }
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); }