| @@ -38,8 +38,6 @@ extern int GetFileLength(const char *filename); | |||
| // This version of the command-line speak program uses the | |||
| // libespeak.so.1 library | |||
| static const char *help_text = | |||
| "\nespeak-ng [options] [\"<words>\"]\n\n" | |||
| "-f <text file> Text file to speak\n" | |||
| @@ -102,9 +100,6 @@ static const char *help_text = | |||
| "\t List the available voices for the specified language.\n" | |||
| "\t If <language> is omitted, then list all voices.\n"; | |||
| int samplerate; | |||
| int quiet = 0; | |||
| unsigned int samples_total = 0; | |||
| @@ -116,7 +111,6 @@ FILE *f_wavfile = NULL; | |||
| char filetype[5]; | |||
| char wavefile[200]; | |||
| void DisplayVoices(FILE *f_out, char *language) | |||
| { | |||
| int ix; | |||
| @@ -177,9 +171,6 @@ void DisplayVoices(FILE *f_out, char *language) | |||
| } | |||
| } | |||
| static void Write4Bytes(FILE *f, int value) | |||
| { | |||
| // Write 4 bytes to a file, least significant first | |||
| @@ -191,8 +182,6 @@ static void Write4Bytes(FILE *f, int value) | |||
| } | |||
| } | |||
| int OpenWavFile(char *path, int rate) | |||
| { | |||
| static unsigned char wave_hdr[44] = { | |||
| @@ -219,7 +208,6 @@ int OpenWavFile(char *path, int rate) | |||
| return 1; | |||
| } | |||
| fwrite(wave_hdr, 1, 24, f_wavfile); | |||
| Write4Bytes(f_wavfile, rate); | |||
| Write4Bytes(f_wavfile, rate * 2); | |||
| @@ -227,8 +215,6 @@ int OpenWavFile(char *path, int rate) | |||
| return 0; | |||
| } | |||
| static void CloseWavFile() | |||
| { | |||
| unsigned int pos; | |||
| @@ -250,7 +236,6 @@ static void CloseWavFile() | |||
| } | |||
| static int SynthCallback(short *wav, int numsamples, espeak_EVENT *events) | |||
| { | |||
| char fname[210]; | |||
| @@ -295,7 +280,6 @@ static int SynthCallback(short *wav, int numsamples, espeak_EVENT *events) | |||
| return 0; | |||
| } | |||
| static void PrintVersion() | |||
| { | |||
| const char *version; | |||
| @@ -305,8 +289,6 @@ static void PrintVersion() | |||
| printf("eSpeak text-to-speech: %s Data at: %s\n", version, path_data); | |||
| } | |||
| #ifdef NEED_GETOPT | |||
| struct option { | |||
| char *name; | |||
| @@ -349,7 +331,6 @@ int main(int argc, char **argv) | |||
| static const char *err_load = "Failed to read "; | |||
| FILE *f_text = NULL; | |||
| char *p_text = NULL; | |||
| FILE *f_phonemes_out = stdout; | |||
| @@ -451,87 +432,68 @@ int main(int argc, char **argv) | |||
| else | |||
| synth_flags |= espeakCHARS_8BIT; | |||
| break; | |||
| case 'h': | |||
| printf("\n"); | |||
| PrintVersion(); | |||
| printf("%s", help_text); | |||
| exit(0); | |||
| break; | |||
| case 'k': | |||
| option_capitals = atoi(optarg2); | |||
| break; | |||
| case 'x': | |||
| phoneme_options |= espeakPHONEMES_SHOW; | |||
| break; | |||
| case 'X': | |||
| phoneme_options |= espeakPHONEMES_TRACE; | |||
| break; | |||
| case 'm': | |||
| synth_flags |= espeakSSML; | |||
| break; | |||
| case 'p': | |||
| pitch = atoi(optarg2); | |||
| break; | |||
| case 'q': | |||
| quiet = 1; | |||
| break; | |||
| case 'f': | |||
| strncpy0(filename, optarg2, sizeof(filename)); | |||
| break; | |||
| case 'l': | |||
| option_linelength = atoi(optarg2); | |||
| break; | |||
| case 'a': | |||
| volume = atoi(optarg2); | |||
| break; | |||
| case 's': | |||
| speed = atoi(optarg2); | |||
| break; | |||
| case 'g': | |||
| wordgap = atoi(optarg2); | |||
| break; | |||
| case 'v': | |||
| strncpy0(voicename, optarg2, sizeof(voicename)); | |||
| break; | |||
| case 'w': | |||
| option_waveout = 1; | |||
| strncpy0(wavefile, optarg2, 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, optarg2, sizeof(voicename)); | |||
| flag_compile = c; | |||
| quiet = 1; | |||
| break; | |||
| case 0x103: // --punct | |||
| option_punctuation = 1; | |||
| if (optarg2 != NULL) { | |||
| @@ -541,32 +503,26 @@ int main(int argc, char **argv) | |||
| option_punctuation = 2; | |||
| } | |||
| break; | |||
| case 0x104: // --voices | |||
| espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, data_path, 0); | |||
| DisplayVoices(stdout, optarg2); | |||
| exit(0); | |||
| case 0x106: // -- split | |||
| if (optarg2 == NULL) | |||
| samples_split_seconds = 30 * 60; // default 30 minutes | |||
| else | |||
| samples_split_seconds = atoi(optarg2) * 60; | |||
| break; | |||
| case 0x107: // --path | |||
| data_path = optarg2; | |||
| break; | |||
| case 0x108: // --phonout | |||
| if ((f_phonemes_out = fopen(optarg2, "w")) == NULL) | |||
| fprintf(stderr, "Can't write to: %s\n", optarg2); | |||
| break; | |||
| case 0x109: // --pho | |||
| phoneme_options |= espeakPHONEMES_MBROLA; | |||
| break; | |||
| case 0x10a: // --ipa | |||
| phoneme_options |= espeakPHONEMES_IPA; | |||
| if (optarg2 != NULL) { | |||
| @@ -588,11 +544,9 @@ int main(int argc, char **argv) | |||
| } | |||
| break; | |||
| case 0x10b: // --version | |||
| PrintVersion(); | |||
| exit(0); | |||
| case 0x10c: // --sep | |||
| phoneme_options |= espeakPHONEMES_SHOW; | |||
| if (optarg2 == 0) | |||
| @@ -602,7 +556,6 @@ int main(int argc, char **argv) | |||
| if (phonemes_separator == 'z') | |||
| phonemes_separator = 0x200c; // ZWNJ | |||
| break; | |||
| case 0x10d: // --tie | |||
| phoneme_options |= (espeakPHONEMES_SHOW | espeakPHONEMES_TIE); | |||
| if (optarg2 == 0) | |||
| @@ -612,28 +565,23 @@ int main(int argc, char **argv) | |||
| if (phonemes_separator == 'z') | |||
| phonemes_separator = 0x200d; // ZWJ | |||
| break; | |||
| case 0x10e: // --compile-mbrola | |||
| samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, 0); | |||
| espeak_ng_CompileMbrolaVoice(optarg2, stdout); | |||
| exit(0); | |||
| case 0x10f: // --compile-intonations | |||
| samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, espeakINITIALIZE_PATH_ONLY); | |||
| espeak_ng_CompileIntonation(stdout); | |||
| exit(0); | |||
| case 0x110: // --compile-phonemes | |||
| samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, espeakINITIALIZE_PATH_ONLY); | |||
| espeak_ng_CompilePhonemeData(22050, stdout); | |||
| exit(0); | |||
| 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, data_path, 0); | |||
| @@ -653,7 +601,6 @@ int main(int argc, char **argv) | |||
| samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, 0); | |||
| } | |||
| if (voicename[0] == 0) | |||
| strcpy(voicename, "default"); | |||
| @@ -690,7 +637,6 @@ int main(int argc, char **argv) | |||
| if (option_punctuation == 2) | |||
| espeak_SetPunctuationList(option_punctlist); | |||
| espeak_SetPhonemeTrace(phoneme_options | (phonemes_separator << 8), f_phonemes_out); | |||
| if (filename[0] == 0) { | |||
| @@ -713,7 +659,6 @@ int main(int argc, char **argv) | |||
| exit(1); | |||
| } | |||
| if (p_text != NULL) { | |||
| int size; | |||
| size = strlen(p_text); | |||
| @@ -101,8 +101,6 @@ static keywtab_t k_conditions[] = { | |||
| { NULL, 0, 0 } | |||
| }; | |||
| static keywtab_t k_properties[] = { | |||
| { "isPause", 0, phPAUSE }, | |||
| { "isVowel", 0, phVOWEL }, | |||
| @@ -238,7 +236,6 @@ static keywtab_t keywords[] = { | |||
| { "afr", tPHONEME_TYPE, phSTOP }, // treat as stop | |||
| { "apr", tPHONEME_TYPE, phFRICATIVE }, // [h] voiceless approximant | |||
| // keywords | |||
| { "phonemenumber", tSTATEMENT, kPHONEMENUMBER }, | |||
| { "phonemetable", tSTATEMENT, kPHONEMETABLE }, | |||
| @@ -256,7 +253,6 @@ static keywtab_t keywords[] = { | |||
| { "endtype", tSTATEMENT, kENDTYPE }, | |||
| { "voicingswitch", tSTATEMENT, kVOICINGSWITCH }, | |||
| { "IF", tSTATEMENT, kIF }, | |||
| { "ELSE", tSTATEMENT, kELSE }, | |||
| { "ELIF", tSTATEMENT, kELIF }, | |||
| @@ -276,7 +272,6 @@ static keywtab_t keywords[] = { | |||
| { "VowelEnding", tSTATEMENT, kVOWELENDING }, | |||
| { "addWav", tSTATEMENT, kANDWAV }, | |||
| { "Vowelin", tSTATEMENT, kVOWELIN }, | |||
| { "Vowelout", tSTATEMENT, kVOWELOUT }, | |||
| { "Continue", tSTATEMENT, kCONTINUE }, | |||
| @@ -359,12 +354,10 @@ static keywtab_t keywords[] = { | |||
| { NULL, 0, -1 } | |||
| }; | |||
| static keywtab_t *keyword_tabs[] = { | |||
| keywords, k_conditions, k_properties, k_intonation | |||
| }; | |||
| static PHONEME_TAB *phoneme_out; | |||
| static int n_phcodes_list[N_PHONEME_TABS]; | |||
| @@ -376,7 +369,6 @@ static int place_articulation; | |||
| static char *p_equivalence; | |||
| static char equivalence_buf[20000]; | |||
| #define N_PROCS 50 | |||
| int n_procs; | |||
| int proc_addr[N_PROCS]; | |||
| @@ -540,7 +532,6 @@ static void DecompilePhoneme(FILE *f_out, PHONEME_TAB *ph, int compile_phoneme) | |||
| fprintf(f_out, ")"); | |||
| } | |||
| break; | |||
| case 2: | |||
| case 3: | |||
| if (type2 < 12) { | |||
| @@ -593,17 +584,14 @@ static void DecompilePhoneme(FILE *f_out, PHONEME_TAB *ph, int compile_phoneme) | |||
| } | |||
| fprintf(f_out, ")"); | |||
| break; | |||
| case 6: | |||
| fprintf(f_out, "%s", instn_jumps[(instn >> 9) & 7]); | |||
| fprintf(f_out, " %d", instn & 0x1ff); | |||
| break; | |||
| case 9: | |||
| address = ((data1 & 0xf) << 4) + *pc++; | |||
| fprintf(f_out, "CALL %.5x", address); | |||
| break; | |||
| case 10: | |||
| fprintf(f_out, "%s", instn10_string[type2]); | |||
| switch (type2) | |||
| @@ -622,7 +610,6 @@ static void DecompilePhoneme(FILE *f_out, PHONEME_TAB *ph, int compile_phoneme) | |||
| break; | |||
| } | |||
| break; | |||
| case 11: | |||
| case 12: | |||
| case 13: | |||
| @@ -636,10 +623,6 @@ static void DecompilePhoneme(FILE *f_out, PHONEME_TAB *ph, int compile_phoneme) | |||
| } | |||
| } | |||
| static int n_phoneme_tabs; | |||
| static int n_phcodes; | |||
| @@ -652,12 +635,10 @@ static FILE *f_errors = NULL; | |||
| static FILE *f_prog_log = NULL; | |||
| static FILE *f_report; | |||
| static FILE *f_in; | |||
| static int f_in_linenum; | |||
| static int f_in_displ; | |||
| static int linenum; | |||
| static int count_references = 0; | |||
| static int duplicate_references = 0; | |||
| @@ -682,13 +663,11 @@ typedef struct { | |||
| static REF_HASH_TAB *ref_hash_tab[256]; | |||
| #define N_ENVELOPES 30 | |||
| int n_envelopes = 0; | |||
| char envelope_paths[N_ENVELOPES][80]; | |||
| unsigned char envelope_dat[N_ENVELOPES][ENV_LEN]; | |||
| typedef struct { | |||
| FILE *file; | |||
| int linenum; | |||
| @@ -708,7 +687,6 @@ typedef struct { | |||
| } IF_STACK; | |||
| IF_STACK if_stack[N_IF_STACK]; | |||
| enum { | |||
| tENDFILE = 1, | |||
| tSTRING, | |||
| @@ -727,8 +705,6 @@ int item_terminator; | |||
| #define N_ITEM_STRING 256 | |||
| char item_string[N_ITEM_STRING]; | |||
| static int ref_sorter(char **a, char **b) | |||
| { | |||
| int ix; | |||
| @@ -747,8 +723,6 @@ static int ref_sorter(char **a, char **b) | |||
| return p1->ph_mnemonic - p2->ph_mnemonic; | |||
| } | |||
| static void CompileReport(void) | |||
| { | |||
| int ix; | |||
| @@ -827,7 +801,6 @@ static void CompileReport(void) | |||
| fclose(f_report); | |||
| } | |||
| static void error(const char *format, const char *string) | |||
| { | |||
| if (string == NULL) | |||
| @@ -855,7 +828,6 @@ static FILE *fopen_log(FILE *f_log, const char *fname, const char *access) | |||
| return f; | |||
| } | |||
| static unsigned int StringToWord(const char *string) | |||
| { | |||
| // Pack 4 characters into a word | |||
| @@ -875,7 +847,6 @@ static unsigned int StringToWord(const char *string) | |||
| return word; | |||
| } | |||
| static MNEM_TAB reserved_phonemes[] = { | |||
| { "_\001", phonCONTROL }, // NOT USED | |||
| { "%", phonSTRESS_U }, | |||
| @@ -913,7 +884,6 @@ static MNEM_TAB reserved_phonemes[] = { | |||
| { NULL, 0 } | |||
| }; | |||
| static void ReservePhCodes() | |||
| { | |||
| // Reserve phoneme codes which have fixed numbers so that they can be | |||
| @@ -932,7 +902,6 @@ static void ReservePhCodes() | |||
| } | |||
| } | |||
| static int LookupPhoneme(const char *string, int control) | |||
| { | |||
| // control = 0 explicit declaration | |||
| @@ -983,8 +952,6 @@ static int LookupPhoneme(const char *string, int control) | |||
| return use; | |||
| } | |||
| static unsigned int get_char() | |||
| { | |||
| unsigned int c; | |||
| @@ -1001,7 +968,6 @@ static void unget_char(unsigned int c) | |||
| linenum--; | |||
| } | |||
| int CheckNextChar() | |||
| { | |||
| int c; | |||
| @@ -1010,7 +976,6 @@ int CheckNextChar() | |||
| return c; | |||
| } | |||
| static int NextItem(int type) | |||
| { | |||
| int acc; | |||
| @@ -1099,7 +1064,6 @@ static int NextItem(int type) | |||
| return acc * sign; | |||
| } | |||
| if ((type >= tKEYWORD) && (type <= tINTONATION)) { | |||
| pk = keyword_tabs[type-tKEYWORD]; | |||
| while (pk->mnem != NULL) { | |||
| @@ -1117,8 +1081,6 @@ static int NextItem(int type) | |||
| return -1; | |||
| } | |||
| static int NextItemMax(int max) | |||
| { | |||
| // Get a number, but restrict value to max | |||
| @@ -1134,8 +1096,6 @@ static int NextItemMax(int max) | |||
| return value; | |||
| } | |||
| static int NextItemBrackets(int type, int control) | |||
| { | |||
| // Expect a parameter inside parantheses | |||
| @@ -1156,19 +1116,14 @@ static int NextItemBrackets(int type, int control) | |||
| if (item_terminator != ')') | |||
| error("Expected ')'", NULL); | |||
| return value; | |||
| } | |||
| static void UngetItem() | |||
| { | |||
| fseek(f_in, f_in_displ, SEEK_SET); | |||
| linenum = f_in_linenum; | |||
| } | |||
| static int Range(int value, int divide, int min, int max) | |||
| { | |||
| if (value < 0) | |||
| @@ -1184,7 +1139,6 @@ static int Range(int value, int divide, int min, int max) | |||
| return value - min; | |||
| } | |||
| int CompileVowelTransition(int which) | |||
| { | |||
| // Compile a vowel transition | |||
| @@ -1291,8 +1245,6 @@ int CompileVowelTransition(int which) | |||
| return 0; | |||
| } | |||
| int LoadSpect(const char *path, int control) | |||
| { | |||
| SpectSeq *spectseq; | |||
| @@ -1470,8 +1422,6 @@ int LoadSpect(const char *path, int control) | |||
| return displ; | |||
| } | |||
| static int LoadWavefile(FILE *f, const char *fname) | |||
| { | |||
| int displ; | |||
| @@ -1523,7 +1473,6 @@ static int LoadWavefile(FILE *f, const char *fname) | |||
| if (system(command) != 0) | |||
| failed = 1; | |||
| if (failed || (GetFileLength(fname_temp) <= 0)) { | |||
| if (resample_fails < 2) | |||
| error("Resample command failed: %s", command); | |||
| @@ -1569,7 +1518,6 @@ static int LoadWavefile(FILE *f, const char *fname) | |||
| max = sample; | |||
| else if (sample < -max) | |||
| max = -sample; | |||
| } | |||
| scale_factor = (max / 127) + 1; | |||
| @@ -1620,8 +1568,6 @@ static int LoadWavefile(FILE *f, const char *fname) | |||
| return displ | 0x800000; // set bit 23 to indicate a wave file rather than a spectrum | |||
| } | |||
| static int LoadEnvelope(FILE *f, const char *fname) | |||
| { | |||
| int displ; | |||
| @@ -1643,8 +1589,6 @@ static int LoadEnvelope(FILE *f, const char *fname) | |||
| return displ; | |||
| } | |||
| /* Generate a hash code from the specified string */ | |||
| static int Hash8(const char *string) | |||
| { | |||
| @@ -1662,8 +1606,6 @@ static int Hash8(const char *string) | |||
| return (hash+chars) & 0xff; | |||
| } | |||
| static int LoadEnvelope2(FILE *f, const char *fname) | |||
| { | |||
| int ix, ix2; | |||
| @@ -1714,7 +1656,6 @@ static int LoadEnvelope2(FILE *f, const char *fname) | |||
| env[x] = y; | |||
| } | |||
| if (n_envelopes < N_ENVELOPES) { | |||
| strncpy0(envelope_paths[n_envelopes], fname, sizeof(envelope_paths[0])); | |||
| memcpy(envelope_dat[n_envelopes], env, ENV_LEN); | |||
| @@ -1809,7 +1750,6 @@ static int LoadDataFile(const char *path, int control) | |||
| return addr; | |||
| } | |||
| static int CompileToneSpec(void) | |||
| { | |||
| int pitch1 = 0; | |||
| @@ -1888,8 +1828,6 @@ int CompileSound(int keyword, int isvowel) | |||
| return 0; | |||
| } | |||
| /* | |||
| Condition | |||
| bits 14,15 1 | |||
| @@ -1901,7 +1839,6 @@ int CompileSound(int keyword, int isvowel) | |||
| =8 data = stress bitmap | |||
| =9 special tests | |||
| */ | |||
| int CompileIf(int elif) | |||
| { | |||
| int key; | |||
| @@ -2011,7 +1948,6 @@ int CompileIf(int elif) | |||
| return 0; | |||
| } | |||
| void FillThen(int add) | |||
| { | |||
| USHORT *p; | |||
| @@ -2040,7 +1976,6 @@ void FillThen(int add) | |||
| then_count = 0; | |||
| } | |||
| int CompileElse(void) | |||
| { | |||
| USHORT *ref; | |||
| @@ -2068,7 +2003,6 @@ int CompileElse(void) | |||
| return 0; | |||
| } | |||
| int CompileElif(void) | |||
| { | |||
| if (if_level < 1) { | |||
| @@ -2081,7 +2015,6 @@ int CompileElif(void) | |||
| return 0; | |||
| } | |||
| int CompileEndif(void) | |||
| { | |||
| USHORT *p; | |||
| @@ -2112,7 +2045,6 @@ int CompileEndif(void) | |||
| return 0; | |||
| } | |||
| static int CompileSwitch(int type) | |||
| { | |||
| // Type 0: EndSwitch | |||
| @@ -2131,8 +2063,6 @@ static int CompileSwitch(int type) | |||
| return 0; | |||
| } | |||
| static PHONEME_TAB_LIST *FindPhonemeTable(const char *string) | |||
| { | |||
| int ix; | |||
| @@ -2145,8 +2075,6 @@ static PHONEME_TAB_LIST *FindPhonemeTable(const char *string) | |||
| return NULL; | |||
| } | |||
| static PHONEME_TAB *FindPhoneme(const char *string) | |||
| { | |||
| PHONEME_TAB_LIST *phtab = NULL; | |||
| @@ -2178,7 +2106,6 @@ static PHONEME_TAB *FindPhoneme(const char *string) | |||
| return NULL; | |||
| } | |||
| static void ImportPhoneme(void) | |||
| { | |||
| unsigned int ph_mnem; | |||
| @@ -2198,10 +2125,8 @@ static void ImportPhoneme(void) | |||
| if (phoneme_out->type != phVOWEL) { | |||
| phoneme_out->end_type = 0; // voicingswitch, this must be set later to refer to a local phoneme | |||
| } | |||
| } | |||
| static void CallPhoneme(void) | |||
| { | |||
| PHONEME_TAB *ph; | |||
| @@ -2239,7 +2164,6 @@ static void CallPhoneme(void) | |||
| *prog_out++ = addr; | |||
| } | |||
| static void DecThenCount() | |||
| { | |||
| if (then_count > 0) | |||
| @@ -2254,7 +2178,6 @@ static void InstnPlusPhoneme(int instn) | |||
| *prog_out++ = instn + phcode; | |||
| } | |||
| int CompilePhoneme(int compile_phoneme) | |||
| { | |||
| int endphoneme = 0; | |||
| @@ -2323,17 +2246,14 @@ int CompilePhoneme(int compile_phoneme) | |||
| error("More than one phoneme type: %s", item_string); | |||
| phoneme_out->type = keyword; | |||
| break; | |||
| case tPLACE: | |||
| if (place_articulation > 0) | |||
| error("Place of articulation has already been given: %s", item_string); | |||
| place_articulation = keyword; | |||
| break; | |||
| case tPHONEME_FLAG: | |||
| phoneme_flags |= keyword; | |||
| break; | |||
| case tINSTRN1: | |||
| // instruction group 0, with 8 bit operands which set data in PHONEME_DATA | |||
| switch (keyword) | |||
| @@ -2351,19 +2271,16 @@ int CompilePhoneme(int compile_phoneme) | |||
| InstnPlusPhoneme(keyword << 8); | |||
| DecThenCount(); | |||
| break; | |||
| case i_PAUSE_BEFORE: | |||
| value = NextItemMax(255); | |||
| *prog_out++ = (i_PAUSE_BEFORE << 8) + value; | |||
| DecThenCount(); | |||
| break; | |||
| case i_PAUSE_AFTER: | |||
| value = NextItemMax(255); | |||
| *prog_out++ = (i_PAUSE_AFTER << 8) + value; | |||
| DecThenCount(); | |||
| break; | |||
| case i_SET_LENGTH: | |||
| value = NextItemMax(511); | |||
| if (phoneme_out->type == phVOWEL) | |||
| @@ -2376,18 +2293,15 @@ int CompilePhoneme(int compile_phoneme) | |||
| DecThenCount(); | |||
| } | |||
| break; | |||
| case i_ADD_LENGTH: | |||
| value = NextItem(tSIGNEDNUMBER) / 2; | |||
| *prog_out++ = (i_ADD_LENGTH << 8) + (value & 0xff); | |||
| DecThenCount(); | |||
| break; | |||
| case i_LENGTH_MOD: | |||
| value = NextItem(tNUMBER); | |||
| phoneme_out->length_mod = value; | |||
| break; | |||
| case i_IPA_NAME: | |||
| NextItem(tSTRING); | |||
| @@ -2442,7 +2356,6 @@ int CompilePhoneme(int compile_phoneme) | |||
| break; | |||
| } | |||
| break; | |||
| case tSTATEMENT: | |||
| switch (keyword) | |||
| { | |||
| @@ -2450,14 +2363,12 @@ int CompilePhoneme(int compile_phoneme) | |||
| ImportPhoneme(); | |||
| phoneme_flags = phoneme_out->phflags; | |||
| break; | |||
| case kSTARTTYPE: | |||
| phcode = NextItem(tPHONEMEMNEM); | |||
| if (phcode == -1) | |||
| phcode = LookupPhoneme(item_string, 1); | |||
| phoneme_out->start_type = phcode; | |||
| break; | |||
| case kENDTYPE: | |||
| phcode = NextItem(tPHONEMEMNEM); | |||
| if (phcode == -1) | |||
| @@ -2467,14 +2378,12 @@ int CompilePhoneme(int compile_phoneme) | |||
| else if (phcode != phoneme_out->start_type) | |||
| error("endtype must equal starttype for consonants", NULL); | |||
| break; | |||
| case kVOICINGSWITCH: | |||
| phcode = NextItem(tPHONEMEMNEM); | |||
| if (phcode == -1) | |||
| phcode = LookupPhoneme(item_string, 1); | |||
| phoneme_out->end_type = phcode; // use end_type field for consonants as voicing_switch | |||
| break; | |||
| case kSTRESSTYPE: | |||
| value = NextItem(tNUMBER); | |||
| phoneme_out->std_length = value; | |||
| @@ -2483,39 +2392,30 @@ int CompilePhoneme(int compile_phoneme) | |||
| prog_out = prog_buf; | |||
| } | |||
| break; | |||
| case kIF: | |||
| endphoneme = CompileIf(0); | |||
| break; | |||
| case kELSE: | |||
| endphoneme = CompileElse(); | |||
| break; | |||
| case kELIF: | |||
| endphoneme = CompileElif(); | |||
| break; | |||
| case kENDIF: | |||
| endphoneme = CompileEndif(); | |||
| break; | |||
| case kENDSWITCH: | |||
| break; | |||
| case kSWITCH_PREVVOWEL: | |||
| endphoneme = CompileSwitch(1); | |||
| break; | |||
| case kSWITCH_NEXTVOWEL: | |||
| endphoneme = CompileSwitch(2); | |||
| break; | |||
| case kCALLPH: | |||
| CallPhoneme(); | |||
| DecThenCount(); | |||
| break; | |||
| case kFMT: | |||
| if_stack[if_level].returned = 1; | |||
| DecThenCount(); | |||
| @@ -2524,45 +2424,40 @@ int CompilePhoneme(int compile_phoneme) | |||
| else | |||
| endphoneme = CompileSound(keyword, 0); | |||
| break; | |||
| case kWAV: | |||
| if_stack[if_level].returned = 1; | |||
| // fallthrough: | |||
| case kVOWELSTART: | |||
| case kVOWELENDING: | |||
| case kANDWAV: | |||
| DecThenCount(); | |||
| endphoneme = CompileSound(keyword, 0); | |||
| break; | |||
| case kVOWELIN: | |||
| DecThenCount(); | |||
| endphoneme = CompileVowelTransition(1); | |||
| break; | |||
| case kVOWELOUT: | |||
| DecThenCount(); | |||
| endphoneme = CompileVowelTransition(2); | |||
| break; | |||
| case kTONESPEC: | |||
| DecThenCount(); | |||
| endphoneme = CompileToneSpec(); | |||
| break; | |||
| case kCONTINUE: | |||
| *prog_out++ = i_CONTINUE; | |||
| DecThenCount(); | |||
| break; | |||
| case kRETURN: | |||
| *prog_out++ = i_RETURN; | |||
| DecThenCount(); | |||
| break; | |||
| case kINCLUDE: | |||
| case kPHONEMENUMBER: | |||
| case kPHONEMETABLE: | |||
| error("Missing 'endphoneme' before '%s'", item_string); // drop through to endphoneme | |||
| // fallthrough: | |||
| case kENDPHONEME: | |||
| case kENDPROCEDURE: | |||
| endphoneme = 1; | |||
| @@ -2572,7 +2467,6 @@ int CompilePhoneme(int compile_phoneme) | |||
| *prog_out++ = i_RETURN; | |||
| break; | |||
| } | |||
| break; | |||
| } | |||
| } | |||
| @@ -2627,10 +2521,6 @@ int CompilePhoneme(int compile_phoneme) | |||
| return 0; | |||
| } | |||
| static void WritePhonemeTables() | |||
| { | |||
| int ix; | |||
| @@ -2683,7 +2573,6 @@ static void WritePhonemeTables() | |||
| } | |||
| } | |||
| static void EndPhonemeTable() | |||
| { | |||
| int ix; | |||
| @@ -2720,7 +2609,6 @@ static void EndPhonemeTable() | |||
| } | |||
| } | |||
| static void StartPhonemeTable(const char *name) | |||
| { | |||
| int ix; | |||
| @@ -2772,7 +2660,6 @@ static void StartPhonemeTable(const char *name) | |||
| n_phoneme_tabs++; | |||
| } | |||
| static void CompileEquivalents() | |||
| { | |||
| // a list of phonemes in another language and the equivalent phoneme strings in this language | |||
| @@ -2866,8 +2753,6 @@ static void CompileEquivalents() | |||
| p_start[3] = n_bytes; | |||
| } | |||
| static void CompilePhonemeFiles() | |||
| { | |||
| int item; | |||
| @@ -2900,7 +2785,6 @@ static void CompilePhonemeFiles() | |||
| { | |||
| case kUTF8_BOM: | |||
| break; // ignore bytes 0xef 0xbb 0xbf | |||
| case kINCLUDE: | |||
| NextItem(tSTRING); | |||
| sprintf(buf, "%s/../phsource/%s", path_home, item_string); | |||
| @@ -2914,17 +2798,14 @@ static void CompilePhonemeFiles() | |||
| f_in = f; | |||
| strncpy0(current_fname, item_string, sizeof(current_fname)); | |||
| linenum = 1; | |||
| } else | |||
| error("Missing file: %s", item_string); | |||
| break; | |||
| case kPHONEMETABLE: | |||
| EndPhonemeTable(); | |||
| NextItem(tSTRING); // name of the new phoneme table | |||
| StartPhonemeTable(item_string); | |||
| break; | |||
| case kPHONEMESTART: | |||
| if (n_phoneme_tabs == 0) { | |||
| Error("phonemetable is missing"); | |||
| @@ -2932,15 +2813,12 @@ static void CompilePhonemeFiles() | |||
| } | |||
| CompilePhoneme(1); | |||
| break; | |||
| case kPROCEDURE: | |||
| CompilePhoneme(0); | |||
| break; | |||
| case kEQUIVALENTS: | |||
| CompileEquivalents(); | |||
| break; | |||
| default: | |||
| if (!feof(f_in)) | |||
| Error("Keyword 'phoneme' expected"); | |||
| @@ -2950,8 +2828,6 @@ static void CompilePhonemeFiles() | |||
| phoneme_tab2[n_phcodes+1].mnemonic = 0; // terminator | |||
| } | |||
| static espeak_ng_STATUS CompilePhonemeData2(const char *source, FILE *log) | |||
| { | |||
| char fname[sizeof(path_home)+40]; | |||
| @@ -3010,7 +2886,6 @@ static espeak_ng_STATUS CompilePhonemeData2(const char *source, FILE *log) | |||
| "# Address Data file\n" | |||
| "# ------- ---------\n"); | |||
| fprintf(f_errors, "Source data path = '%s/../phsource'\n", path_home); | |||
| fprintf(f_errors, "Master phonemes file = '%s/../phsource/phonemes'\n", path_home); | |||
| fprintf(f_errors, "Output to '%s/'\n\n", path_home); | |||
| @@ -3073,7 +2948,6 @@ static espeak_ng_STATUS CompilePhonemeData2(const char *source, FILE *log) | |||
| return ENS_OK; | |||
| } | |||
| static const char *preset_tune_names[] = { | |||
| "s1", "c1", "q1", "e1", NULL | |||
| }; | |||
| @@ -3113,7 +2987,6 @@ int LookupEnvelopeName(const char *name) | |||
| return LookupMnem(envelope_names, name); | |||
| } | |||
| #pragma GCC visibility push(default) | |||
| espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| @@ -3135,7 +3008,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| TUNE *tune_data; | |||
| TUNE new_tune; | |||
| char name[12]; | |||
| char tune_names[N_TUNE_NAMES][12]; | |||
| char buf[sizeof(path_home)+150]; | |||
| @@ -3153,7 +3025,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| } | |||
| } | |||
| for (ix = 0; preset_tune_names[ix] != NULL; ix++) { | |||
| strcpy(tune_names[ix], preset_tune_names[ix]); | |||
| } | |||
| @@ -3240,7 +3111,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| if (found == 0) | |||
| error("Bad tune name: '%s;", new_tune.name); | |||
| break; | |||
| case kENDTUNE: | |||
| compiling_tune = 0; | |||
| @@ -3254,26 +3124,22 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| } | |||
| memcpy(&tune_data[tune_number], &new_tune, sizeof(TUNE)); | |||
| break; | |||
| case kTUNE_PREHEAD: | |||
| new_tune.prehead_start = NextItem(tNUMBER); | |||
| new_tune.prehead_end = NextItem(tNUMBER); | |||
| break; | |||
| case kTUNE_ONSET: | |||
| new_tune.onset = NextItem(tNUMBER); | |||
| new_tune.unstr_start[0] = NextItem(tSIGNEDNUMBER); | |||
| new_tune.unstr_end[0] = NextItem(tSIGNEDNUMBER); | |||
| done_onset = 1; | |||
| break; | |||
| case kTUNE_HEADLAST: | |||
| new_tune.head_last = NextItem(tNUMBER); | |||
| new_tune.unstr_start[2] = NextItem(tSIGNEDNUMBER); | |||
| new_tune.unstr_end[2] = NextItem(tSIGNEDNUMBER); | |||
| done_last = 1; | |||
| break; | |||
| case kTUNE_HEADENV: | |||
| NextItem(tSTRING); | |||
| if ((ix = LookupEnvelopeName(item_string)) < 0) | |||
| @@ -3282,7 +3148,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| new_tune.stressed_env = ix; | |||
| new_tune.stressed_drop = NextItem(tNUMBER); | |||
| break; | |||
| case kTUNE_HEAD: | |||
| new_tune.head_max_steps = NextItem(tNUMBER); | |||
| new_tune.head_start = NextItem(tNUMBER); | |||
| @@ -3290,7 +3155,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| new_tune.unstr_start[1] = NextItem(tSIGNEDNUMBER); | |||
| new_tune.unstr_end[1] = NextItem(tSIGNEDNUMBER); | |||
| break; | |||
| case kTUNE_HEADEXTEND: | |||
| // up to 8 numbers | |||
| for (ix = 0; ix < (int)(sizeof(new_tune.head_extend)); ix++) { | |||
| @@ -3301,7 +3165,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| } | |||
| new_tune.n_head_extend = ix; // number of values | |||
| break; | |||
| case kTUNE_NUCLEUS0: | |||
| NextItem(tSTRING); | |||
| if ((ix = LookupEnvelopeName(item_string)) < 0) { | |||
| @@ -3312,7 +3175,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| new_tune.nucleus0_max = NextItem(tNUMBER); | |||
| new_tune.nucleus0_min = NextItem(tNUMBER); | |||
| break; | |||
| case kTUNE_NUCLEUS1: | |||
| NextItem(tSTRING); | |||
| if ((ix = LookupEnvelopeName(item_string)) < 0) { | |||
| @@ -3334,7 +3196,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| new_tune.split_tail_end = new_tune.tail_end; | |||
| } | |||
| break; | |||
| case kTUNE_SPLIT: | |||
| NextItem(tSTRING); | |||
| if ((ix = LookupEnvelopeName(item_string)) < 0) { | |||
| @@ -3359,7 +3220,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| else | |||
| new_tune.split_tune = ix; | |||
| break; | |||
| default: | |||
| error("Unexpected: '%s'", item_string); | |||
| break; | |||
| @@ -3382,8 +3242,6 @@ espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log) | |||
| return error_count > 0 ? ENE_COMPILE_ERRORS : ENS_OK; | |||
| } | |||
| espeak_ng_STATUS espeak_ng_CompilePhonemeData(long rate, FILE *log) | |||
| { | |||
| if (!log) log = stderr; | |||
| @@ -94,7 +94,6 @@ MNEM_TAB mnem_flags[] = { | |||
| { "$u2+", 0x4e }, | |||
| { "$u3+", 0x4f }, | |||
| // these set the corresponding numbered bit if dictionary_flags | |||
| { "$pause", 8 }, // ensure pause before this word | |||
| { "$strend", 9 }, // full stress if at end of clause | |||
| @@ -151,7 +150,6 @@ MNEM_TAB mnem_flags[] = { | |||
| { NULL, -1 } | |||
| }; | |||
| #define LEN_GROUP_NAME 12 | |||
| typedef struct { | |||
| @@ -161,7 +159,6 @@ typedef struct { | |||
| int group3_ix; | |||
| } RGROUP; | |||
| int isspace2(unsigned int c) | |||
| { | |||
| // can't use isspace() because on Windows, isspace(0xe1) gives TRUE ! | |||
| @@ -172,8 +169,6 @@ int isspace2(unsigned int c) | |||
| return 1; | |||
| } | |||
| static FILE *fopen_log(const char *fname, const char *access) | |||
| { | |||
| // performs fopen, but produces error message to f_log if it fails | |||
| @@ -186,7 +181,6 @@ static FILE *fopen_log(const char *fname, const char *access) | |||
| return f; | |||
| } | |||
| /* Lookup a mnemonic string in a table, return its name */ | |||
| const char *LookupMnemName(MNEM_TAB *table, const int value) | |||
| { | |||
| @@ -198,7 +192,6 @@ const char *LookupMnemName(MNEM_TAB *table, const int value) | |||
| return ""; /* not found */ | |||
| } | |||
| void print_dictionary_flags(unsigned int *flags, char *buf, int buf_len) | |||
| { | |||
| int stress; | |||
| @@ -227,9 +220,6 @@ void print_dictionary_flags(unsigned int *flags, char *buf, int buf_len) | |||
| } | |||
| } | |||
| char *DecodeRule(const char *group_chars, int group_length, char *rule, int control) | |||
| { | |||
| /* Convert compiled match template to ascii */ | |||
| @@ -384,9 +374,6 @@ char *DecodeRule(const char *group_chars, int group_length, char *rule, int cont | |||
| return output; | |||
| } | |||
| static int compile_line(char *linebuf, char *dict_line, int *hash) | |||
| { | |||
| // Compile a line in the language_list file | |||
| @@ -491,7 +478,6 @@ static int compile_line(char *linebuf, char *dict_line, int *hash) | |||
| step = 1; | |||
| } | |||
| break; | |||
| case 1: | |||
| if ((c == '-') && multiple_words) { | |||
| if (IsDigit09(word[0])) | |||
| @@ -519,7 +505,6 @@ static int compile_line(char *linebuf, char *dict_line, int *hash) | |||
| } | |||
| } | |||
| break; | |||
| case 2: | |||
| if (isspace2(c)) | |||
| multiple_words++; | |||
| @@ -529,21 +514,18 @@ static int compile_line(char *linebuf, char *dict_line, int *hash) | |||
| step = 3; | |||
| } | |||
| break; | |||
| case 3: | |||
| if (!isspace2(c)) { | |||
| phonetic = p; | |||
| step = 4; | |||
| } | |||
| break; | |||
| case 4: | |||
| if (isspace2(c)) { | |||
| p[0] = 0; /* terminate phonetic */ | |||
| step = 5; | |||
| } | |||
| break; | |||
| case 5: | |||
| break; | |||
| } | |||
| @@ -660,12 +642,9 @@ static int compile_line(char *linebuf, char *dict_line, int *hash) | |||
| } | |||
| dict_line[0] = length; | |||
| return length; | |||
| } | |||
| static void compile_dictlist_start(void) | |||
| { | |||
| // initialise dictionary list | |||
| @@ -685,7 +664,6 @@ static void compile_dictlist_start(void) | |||
| } | |||
| } | |||
| static void compile_dictlist_end(FILE *f_out) | |||
| { | |||
| // Write out the compiled dictionary list | |||
| @@ -717,8 +695,6 @@ static void compile_dictlist_end(FILE *f_out) | |||
| } | |||
| } | |||
| static int compile_dictlist_file(const char *path, const char *filename) | |||
| { | |||
| int length; | |||
| @@ -774,8 +750,6 @@ static int compile_dictlist_file(const char *path, const char *filename) | |||
| return 0; | |||
| } | |||
| static char rule_cond[80]; | |||
| static char rule_pre[80]; | |||
| static char rule_post[80]; | |||
| @@ -786,8 +760,6 @@ static int group3_ix; | |||
| #define N_RULES 3000 // max rules for each group | |||
| int isHexDigit(int c) | |||
| { | |||
| if ((c >= '0') && (c <= '9')) | |||
| @@ -799,7 +771,6 @@ int isHexDigit(int c) | |||
| return -1; | |||
| } | |||
| static void copy_rule_string(char *string, int *state_out) | |||
| { | |||
| // state 0: conditional, 1=pre, 2=match, 3=post, 4=phonemes | |||
| @@ -949,7 +920,6 @@ static void copy_rule_string(char *string, int *state_out) | |||
| } else | |||
| output[ix++] = RULE_LETTERGP2; | |||
| break; | |||
| case '$': | |||
| value = 0; | |||
| mr = mnem_rules; | |||
| @@ -977,9 +947,9 @@ static void copy_rule_string(char *string, int *state_out) | |||
| error_count++; | |||
| } | |||
| break; | |||
| case 'P': | |||
| sxflags |= SUFX_P; // Prefix, now drop through to Suffix | |||
| // fallthrough | |||
| case 'S': | |||
| output[ix++] = RULE_ENDING; | |||
| value = 0; | |||
| @@ -1040,8 +1010,6 @@ static void copy_rule_string(char *string, int *state_out) | |||
| *state_out = next_state[state]; | |||
| } | |||
| static char *compile_rule(char *input) | |||
| { | |||
| int ix; | |||
| @@ -1079,7 +1047,6 @@ static char *compile_rule(char *input) | |||
| copy_rule_string(buf, &state); | |||
| p = buf; | |||
| break; | |||
| case '(': // start of suffix section | |||
| *p = 0; | |||
| state = 2; | |||
| @@ -1091,7 +1058,6 @@ static char *compile_rule(char *input) | |||
| error_count++; | |||
| } | |||
| break; | |||
| case '\n': // end of line | |||
| case '\r': | |||
| case 0: // end of line | |||
| @@ -1099,21 +1065,18 @@ static char *compile_rule(char *input) | |||
| copy_rule_string(buf, &state); | |||
| finish = 1; | |||
| break; | |||
| case '\t': // end of section section | |||
| case ' ': | |||
| *p = 0; | |||
| copy_rule_string(buf, &state); | |||
| p = buf; | |||
| break; | |||
| case '?': | |||
| if (state == 2) | |||
| state = 0; | |||
| else | |||
| *p++ = c; | |||
| break; | |||
| default: | |||
| *p++ = c; | |||
| break; | |||
| @@ -1203,7 +1166,6 @@ static char *compile_rule(char *input) | |||
| return prule; | |||
| } | |||
| int __cdecl string_sorter(char **a, char **b) | |||
| { | |||
| char *pa, *pb; | |||
| @@ -1216,7 +1178,6 @@ int __cdecl string_sorter(char **a, char **b) | |||
| return strcmp(pa, pb); | |||
| } | |||
| static int __cdecl rgroup_sorter(RGROUP *a, RGROUP *b) | |||
| { | |||
| // Sort long names before short names | |||
| @@ -1228,7 +1189,6 @@ static int __cdecl rgroup_sorter(RGROUP *a, RGROUP *b) | |||
| return a->start-b->start; | |||
| } | |||
| #ifdef OUTPUT_FORMAT | |||
| static void print_rule_group(FILE *f_out, int n_rules, char **rules, char *name) | |||
| { | |||
| @@ -1330,7 +1290,6 @@ static void print_rule_group(FILE *f_out, int n_rules, char **rules, char *name) | |||
| } | |||
| #endif | |||
| static void output_rule_group(FILE *f_out, int n_rules, char **rules, char *name) | |||
| { | |||
| int ix; | |||
| @@ -1389,8 +1348,6 @@ static void output_rule_group(FILE *f_out, int n_rules, char **rules, char *name | |||
| #endif | |||
| } | |||
| static int compile_lettergroup(char *input, FILE *f_out) | |||
| { | |||
| char *p; | |||
| @@ -1463,7 +1420,6 @@ static int compile_lettergroup(char *input, FILE *f_out) | |||
| return 0; | |||
| } | |||
| static int compile_dictrules(FILE *f_in, FILE *f_out, char *fname_temp) | |||
| { | |||
| char *prule; | |||
| @@ -1600,7 +1556,6 @@ static int compile_dictrules(FILE *f_in, FILE *f_out, char *fname_temp) | |||
| } | |||
| break; | |||
| case 2: // .replace | |||
| { | |||
| int replace1; | |||
| @@ -1674,8 +1629,6 @@ static int compile_dictrules(FILE *f_in, FILE *f_out, char *fname_temp) | |||
| return 0; | |||
| } | |||
| int CompileDictionary(const char *dsource, const char *dict_name, FILE *log, char *fname_err, int flags) | |||
| { | |||
| // fname: space to write the filename in case of error | |||
| @@ -36,7 +36,6 @@ | |||
| #include "synthesize.h" | |||
| #include "translate.h" | |||
| int dictionary_skipwords; | |||
| char dictionary_name[40]; | |||
| @@ -80,10 +79,6 @@ static unsigned char remove_accent[N_REMOVE_ACCENT] = { | |||
| 'a', 'a', 'a', 'b', 'o', 'c', 'd', 'd', 'e', 'e', 'e', 'e', 'e', 'e' | |||
| }; | |||
| #pragma GCC visibility push(default) | |||
| void strncpy0(char *to, const char *from, int size) | |||
| { | |||
| @@ -93,7 +88,6 @@ void strncpy0(char *to, const char *from, int size) | |||
| } | |||
| #pragma GCC visibility pop | |||
| int Reverse4Bytes(int word) | |||
| { | |||
| // reverse the order of bytes from little-endian to big-endian | |||
| @@ -111,7 +105,6 @@ int Reverse4Bytes(int word) | |||
| #endif | |||
| } | |||
| int LookupMnem(MNEM_TAB *table, const char *string) | |||
| { | |||
| while (table->mnem != NULL) { | |||
| @@ -122,13 +115,11 @@ int LookupMnem(MNEM_TAB *table, const char *string) | |||
| return table->value; | |||
| } | |||
| static void InitGroups(Translator *tr) | |||
| { | |||
| // Called after dictionary 1 is loaded, to set up table of entry points for translation rule chains | |||
| // for single-letters and two-letter combinations | |||
| int ix; | |||
| char *p; | |||
| char *p_name; | |||
| @@ -206,11 +197,8 @@ static void InitGroups(Translator *tr) | |||
| p += (strlen(p) + 1); | |||
| p++; | |||
| } | |||
| } | |||
| int LoadDictionary(Translator *tr, const char *name, int no_error) | |||
| { | |||
| int hash; | |||
| @@ -248,7 +236,6 @@ int LoadDictionary(Translator *tr, const char *name, int no_error) | |||
| size = fread(tr->data_dictlist, 1, size, f); | |||
| fclose(f); | |||
| pw = (int *)(tr->data_dictlist); | |||
| length = Reverse4Bytes(pw[1]); | |||
| @@ -283,7 +270,6 @@ int LoadDictionary(Translator *tr, const char *name, int no_error) | |||
| return 0; | |||
| } | |||
| /* Generate a hash code from the specified string | |||
| This is used to access the dictionary_2 word-lookup dictionary | |||
| */ | |||
| @@ -302,8 +288,6 @@ int HashDictionary(const char *string) | |||
| return (hash+chars) & 0x3ff; // a 10 bit hash code | |||
| } | |||
| /* Translate a phoneme string from ascii mnemonics to internal phoneme numbers, | |||
| from 'p' up to next blank . | |||
| Returns advanced 'p' | |||
| @@ -343,7 +327,6 @@ const char *EncodePhonemes(const char *p, char *outptr, int *bad_phoneme) | |||
| p++; | |||
| break; | |||
| } | |||
| default: | |||
| // lookup the phoneme mnemonic, find the phoneme with the highest number of | |||
| // matching characters | |||
| @@ -407,8 +390,6 @@ const char *EncodePhonemes(const char *p, char *outptr, int *bad_phoneme) | |||
| return p; | |||
| } | |||
| void DecodePhonemes(const char *inptr, char *outptr) | |||
| { | |||
| // Translate from internal phoneme codes into phoneme mnemonics | |||
| @@ -444,7 +425,6 @@ void DecodePhonemes(const char *inptr, char *outptr) | |||
| *outptr = 0; /* string terminator */ | |||
| } | |||
| // using Kirschenbaum to IPA translation, ascii 0x20 to 0x7f | |||
| unsigned short ipa1[96] = { | |||
| 0x20, 0x21, 0x22, 0x2b0, 0x24, 0x25, 0x0e6, 0x2c8, 0x28, 0x29, 0x27e, 0x2b, 0x2cc, 0x2d, 0x2e, 0x2f, | |||
| @@ -459,7 +439,6 @@ unsigned short ipa1[96] = { | |||
| static char *phon_out_buf = NULL; // passes the result of GetTranslatedPhonemeString() | |||
| static unsigned int phon_out_size = 0; | |||
| char *WritePhMnemonic(char *phon_out, PHONEME_TAB *ph, PHONEME_LIST *plist, int use_ipa, int *flags) | |||
| { | |||
| int c; | |||
| @@ -545,8 +524,6 @@ char *WritePhMnemonic(char *phon_out, PHONEME_TAB *ph, PHONEME_LIST *plist, int | |||
| return phon_out; | |||
| } | |||
| const char *GetTranslatedPhonemeString(int phoneme_mode) | |||
| { | |||
| /* Called after a clause has been translated into phonemes, in order | |||
| @@ -594,7 +571,6 @@ const char *GetTranslatedPhonemeString(int phoneme_mode) | |||
| use_tie = 0; | |||
| } | |||
| for (ix = 1; ix < (n_phoneme_list-2); ix++) { | |||
| buf = phon_buf; | |||
| @@ -676,8 +652,6 @@ const char *GetTranslatedPhonemeString(int phoneme_mode) | |||
| return phon_out_buf; | |||
| } | |||
| static int IsLetterGroup(Translator *tr, char *word, int group, int pre) | |||
| { | |||
| // match the word against a list of utf-8 strings | |||
| @@ -710,7 +684,6 @@ static int IsLetterGroup(Translator *tr, char *word, int group, int pre) | |||
| return 0; | |||
| } | |||
| static int IsLetter(Translator *tr, int letter, int group) | |||
| { | |||
| int letter2; | |||
| @@ -740,15 +713,11 @@ static int IsLetter(Translator *tr, int letter, int group) | |||
| return 0; | |||
| } | |||
| int IsVowel(Translator *tr, int letter) | |||
| { | |||
| return IsLetter(tr, letter, LETTERGP_VOWEL2); | |||
| } | |||
| static int Unpronouncable2(Translator *tr, char *word) | |||
| { | |||
| int c; | |||
| @@ -765,7 +734,6 @@ static int Unpronouncable2(Translator *tr, char *word) | |||
| return 0; | |||
| } | |||
| int Unpronouncable(Translator *tr, char *word, int posn) | |||
| { | |||
| /* Determines whether a word in 'unpronouncable', i.e. whether it should | |||
| @@ -837,11 +805,8 @@ int Unpronouncable(Translator *tr, char *word, int posn) | |||
| return 1; // no vowel, or no vowel in first few letters | |||
| return 0; | |||
| } | |||
| static int GetVowelStress(Translator *tr, unsigned char *phonemes, signed char *vowel_stress, int *vowel_count, int *stressed_syllable, int control) | |||
| { | |||
| // control = 1, set stress to 1 for forced unstressed vowels | |||
| @@ -953,12 +918,9 @@ static int GetVowelStress(Translator *tr, unsigned char *phonemes, signed char * | |||
| return max_stress; | |||
| } | |||
| static char stress_phonemes[] = { phonSTRESS_D, phonSTRESS_U, phonSTRESS_2, phonSTRESS_3, | |||
| phonSTRESS_P, phonSTRESS_P2, phonSTRESS_TONIC }; | |||
| void ChangeWordStress(Translator *tr, char *word, int new_stress) | |||
| { | |||
| int ix; | |||
| @@ -1003,8 +965,6 @@ void ChangeWordStress(Translator *tr, char *word, int new_stress) | |||
| *word = 0; | |||
| } | |||
| void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, int tonic, int control) | |||
| { | |||
| /* Guess stress pattern of word. This is language specific | |||
| @@ -1052,7 +1012,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| static char consonant_types[16] = { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 }; | |||
| /* stress numbers STRESS_BASE + | |||
| 0 diminished, unstressed within a word | |||
| 1 unstressed, weak | |||
| @@ -1119,14 +1078,13 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| } | |||
| } | |||
| switch (tr->langopts.stress_rule) | |||
| { | |||
| case 8: | |||
| // stress on first syllable, unless it is a light syllable followed by a heavy syllable | |||
| if ((syllable_weight[1] > 0) || (syllable_weight[2] == 0)) | |||
| break; | |||
| // else drop through to case 1 | |||
| // fallthrough | |||
| case 1: | |||
| // stress on second syllable | |||
| if ((stressed_syllable == 0) && (vowel_count > 2)) { | |||
| @@ -1136,7 +1094,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = 4; | |||
| } | |||
| break; | |||
| case 10: // penultimate, but final if only 1 or 2 syllables | |||
| if (stressed_syllable == 0) { | |||
| if (vowel_count < 4) { | |||
| @@ -1145,7 +1102,7 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| break; | |||
| } | |||
| } | |||
| // drop through to next case | |||
| // fallthrough | |||
| case 2: | |||
| // a language with stress on penultimate vowel | |||
| @@ -1201,7 +1158,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| } | |||
| } | |||
| break; | |||
| case 3: | |||
| // stress on last vowel | |||
| if (stressed_syllable == 0) { | |||
| @@ -1219,7 +1175,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = 4; | |||
| } | |||
| break; | |||
| case 4: // stress on antipenultimate vowel | |||
| if (stressed_syllable == 0) { | |||
| stressed_syllable = vowel_count - 3; | |||
| @@ -1231,7 +1186,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = 4; | |||
| } | |||
| break; | |||
| case 5: | |||
| // LANG=Russian | |||
| if (stressed_syllable == 0) { | |||
| @@ -1253,7 +1207,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = 4; | |||
| } | |||
| break; | |||
| case 6: // LANG=hi stress on the last heaviest syllable | |||
| if (stressed_syllable == 0) { | |||
| int wt; | |||
| @@ -1281,7 +1234,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = 4; | |||
| } | |||
| break; | |||
| case 7: // LANG=tr, the last syllable for any vowel marked explicitly as unstressed | |||
| if (stressed_syllable == 0) { | |||
| stressed_syllable = vowel_count - 1; | |||
| @@ -1295,14 +1247,12 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = 4; | |||
| } | |||
| break; | |||
| case 9: // mark all as stressed | |||
| for (ix = 1; ix < vowel_count; ix++) { | |||
| if (vowel_stress[ix] < 0) | |||
| vowel_stress[ix] = 4; | |||
| } | |||
| break; | |||
| case 12: // LANG=kl (Greenlandic) | |||
| long_vowel = 0; | |||
| for (ix = 1; ix < vowel_count; ix++) { | |||
| @@ -1331,7 +1281,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| vowel_stress[stressed_syllable] = 4; | |||
| max_stress = 4; | |||
| break; | |||
| case 13: // LANG=ml, 1st unless 1st vowel is short and 2nd is long | |||
| if (stressed_syllable == 0) { | |||
| stressed_syllable = 1; | |||
| @@ -1358,7 +1307,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| else | |||
| stress = 3; | |||
| if (unstressed_word == 0) { | |||
| if ((stressflags & S_2_SYL_2) && (vowel_count == 3)) { | |||
| // Two syllable word, if one syllable has primary stress, then give the other secondary stress | |||
| @@ -1439,13 +1387,11 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| max_stress = tonic; | |||
| } | |||
| /* produce output phoneme string */ | |||
| p = phonetic; | |||
| v = 1; | |||
| if (!(control & 1) && ((ph = phoneme_tab[*p]) != NULL)) { | |||
| while ((ph->type == phSTRESS) || (*p == phonEND_WORD)) { | |||
| p++; | |||
| ph = phoneme_tab[p[0]]; | |||
| @@ -1536,8 +1482,6 @@ void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, | |||
| return; | |||
| } | |||
| void AppendPhonemes(Translator *tr, char *string, int size, const char *ph) | |||
| { | |||
| /* Add new phoneme string "ph" to "string" | |||
| @@ -1578,8 +1522,6 @@ void AppendPhonemes(Translator *tr, char *string, int size, const char *ph) | |||
| strcat(string, ph); | |||
| } | |||
| static void MatchRule(Translator *tr, char *word[], char *word_start, int group_length, char *rule, MatchRecord *match_out, int word_flags, int dict_flags) | |||
| { | |||
| /* Checks a specified word against dictionary rules. | |||
| @@ -1644,7 +1586,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| return; | |||
| } | |||
| total_consumed = 0; | |||
| common_phonemes = NULL; | |||
| match_type = 0; | |||
| @@ -1695,13 +1636,11 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| rule--; // so we are still pointing at the 0 | |||
| failed = 2; // matched OK | |||
| break; | |||
| case RULE_PRE_ATSTART: // pre rule with implied 'start of word' | |||
| check_atstart = 1; | |||
| unpron_ignore = 0; | |||
| match_type = RULE_PRE; | |||
| break; | |||
| case RULE_PRE: | |||
| match_type = RULE_PRE; | |||
| if (word_flags & FLAG_UNPRON_TEST) { | |||
| @@ -1711,7 +1650,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| failed = 1; | |||
| } | |||
| break; | |||
| case RULE_POST: | |||
| match_type = RULE_POST; | |||
| break; | |||
| @@ -1762,8 +1700,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_POST: | |||
| /* continue moving fowards */ | |||
| distance_right += 6; | |||
| @@ -1786,7 +1722,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_LETTERGP2: // match against a list of utf-8 strings | |||
| letter_group = *rule++ - 'A'; | |||
| if ((n_bytes = IsLetterGroup(tr, post_ptr-1, letter_group, 0)) > 0) { | |||
| @@ -1795,7 +1730,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_NOTVOWEL: | |||
| if (IsLetter(tr, letter_w, 0) || ((letter_w == ' ') && (word_flags & FLAG_SUFFIX_VOWEL))) | |||
| failed = 1; | |||
| @@ -1804,7 +1738,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| post_ptr += letter_xbytes; | |||
| } | |||
| break; | |||
| case RULE_DIGIT: | |||
| if (IsDigit(letter_w)) { | |||
| add_points = (20-distance_right); | |||
| @@ -1816,7 +1749,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_NONALPHA: | |||
| if (!iswalpha2(letter_w)) { | |||
| add_points = (21-distance_right); | |||
| @@ -1824,14 +1756,12 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_DOUBLE: | |||
| if (letter == last_letter) | |||
| add_points = (21-distance_right); | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case RULE_DOLLAR: | |||
| command = *rule++; | |||
| if (command == DOLLAR_UNPR) | |||
| @@ -1864,14 +1794,12 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| failed = 1; | |||
| } | |||
| break; | |||
| case '-': | |||
| if ((letter == '-') || ((letter == ' ') && (word_flags & FLAG_HYPHEN_AFTER))) | |||
| add_points = (22-distance_right); // one point more than match against space | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case RULE_SYLLABLE: | |||
| { | |||
| /* more than specified number of vowel letters to the right */ | |||
| @@ -1897,8 +1825,7 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| else | |||
| failed = 1; | |||
| } | |||
| break; | |||
| break; | |||
| case RULE_NOVOWELS: | |||
| { | |||
| char *p = post_ptr + letter_xbytes; | |||
| @@ -1912,8 +1839,7 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| if (!failed) | |||
| add_points = (19-distance_right); | |||
| } | |||
| break; | |||
| break; | |||
| case RULE_SKIPCHARS: | |||
| { | |||
| // Used for lang=Tamil, used to match on the next word after an unknown word ending | |||
| @@ -1930,12 +1856,10 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| if (letter_w == rule_w) | |||
| post_ptr = p2; | |||
| } | |||
| break; | |||
| break; | |||
| case RULE_INC_SCORE: | |||
| add_points = 20; // force an increase in points | |||
| break; | |||
| case RULE_DEL_FWD: | |||
| // find the next 'e' in the word and replace by 'E' | |||
| for (p = *word + group_length; p < post_ptr; p++) { | |||
| @@ -1945,7 +1869,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } | |||
| } | |||
| break; | |||
| case RULE_ENDING: | |||
| { | |||
| int end_type; | |||
| @@ -1959,15 +1882,13 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| rule += 3; | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| case RULE_NO_SUFFIX: | |||
| if (word_flags & FLAG_SUFFIX_REMOVED) | |||
| failed = 1; // a suffix has been removed | |||
| else | |||
| add_points = 1; | |||
| break; | |||
| default: | |||
| if (letter == rb) { | |||
| if ((letter & 0xc0) != 0x80) { | |||
| @@ -1979,8 +1900,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| break; | |||
| } | |||
| break; | |||
| case RULE_PRE: | |||
| /* match backwards from start of current group */ | |||
| distance_left += 2; | |||
| @@ -2005,7 +1924,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_LETTERGP2: // match against a list of utf-8 strings | |||
| letter_group = *rule++ - 'A'; | |||
| if ((n_bytes = IsLetterGroup(tr, pre_ptr, letter_group, 1)) > 0) { | |||
| @@ -2014,7 +1932,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_NOTVOWEL: | |||
| if (!IsLetter(tr, letter_w, 0)) { | |||
| add_points = (20-distance_left); | |||
| @@ -2022,14 +1939,12 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_DOUBLE: | |||
| if (letter == last_letter) | |||
| add_points = (21-distance_left); | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case RULE_DIGIT: | |||
| if (IsDigit(letter_w)) { | |||
| add_points = (21-distance_left); | |||
| @@ -2037,7 +1952,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_NONALPHA: | |||
| if (!iswalpha2(letter_w)) { | |||
| add_points = (21-distance_right); | |||
| @@ -2045,7 +1959,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| } else | |||
| failed = 1; | |||
| break; | |||
| case RULE_DOLLAR: | |||
| command = *rule++; | |||
| if ((command == DOLLAR_LIST) || ((command & 0xf0) == 0x20)) { | |||
| @@ -2065,7 +1978,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| failed = 1; | |||
| } | |||
| break; | |||
| case RULE_SYLLABLE: | |||
| /* more than specified number of vowels to the left */ | |||
| syllable_count = 1; | |||
| @@ -2078,14 +1990,12 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case RULE_STRESSED: | |||
| if (tr->word_stressed_count > 0) | |||
| add_points = 19; | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case RULE_NOVOWELS: | |||
| { | |||
| char *p = pre_ptr - letter_xbytes - 1; | |||
| @@ -2099,22 +2009,19 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| if (!failed) | |||
| add_points = 3; | |||
| } | |||
| break; | |||
| break; | |||
| case RULE_IFVERB: | |||
| if (tr->expect_verb) | |||
| add_points = 1; | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case RULE_CAPITAL: | |||
| if (word_flags & FLAG_FIRST_UPPER) | |||
| add_points = 1; | |||
| else | |||
| failed = 1; | |||
| break; | |||
| case '.': | |||
| // dot in pre- section, match on any dot before this point in the word | |||
| for (p = pre_ptr; *p != ' '; p--) { | |||
| @@ -2126,14 +2033,12 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| if (*p == ' ') | |||
| failed = 1; | |||
| break; | |||
| case '-': | |||
| if ((letter == '-') || ((letter == ' ') && (word_flags & FLAG_HYPHEN))) | |||
| add_points = (22-distance_right); // one point more than match against space | |||
| else | |||
| failed = 1; | |||
| break; | |||
| default: | |||
| if (letter == rb) { | |||
| if (letter == RULE_SPACE) | |||
| @@ -2195,9 +2100,6 @@ static void MatchRule(Translator *tr, char *word[], char *word_start, int group_ | |||
| memcpy(match_out, &best, sizeof(MatchRecord)); | |||
| } | |||
| int TranslateRules(Translator *tr, char *p_start, char *phonemes, int ph_size, char *end_phonemes, int word_flags, unsigned int *dict_flags) | |||
| { | |||
| /* Translate a word bounded by space characters | |||
| @@ -2239,7 +2141,6 @@ int TranslateRules(Translator *tr, char *p_start, char *phonemes, int ph_size, c | |||
| } | |||
| word_copy[ix] = 0; | |||
| if ((option_phonemes & espeakPHONEMES_TRACE) && ((word_flags & FLAG_NO_TRACE) == 0)) { | |||
| char wordbuf[120]; | |||
| unsigned int ix; | |||
| @@ -2454,7 +2355,6 @@ int TranslateRules(Translator *tr, char *p_start, char *phonemes, int ph_size, c | |||
| return 0; | |||
| } | |||
| void ApplySpecialAttribute2(Translator *tr, char *phonemes, int dict_flags) | |||
| { | |||
| // apply after the translation is complete | |||
| @@ -2485,8 +2385,6 @@ void ApplySpecialAttribute2(Translator *tr, char *phonemes, int dict_flags) | |||
| } | |||
| } | |||
| int TransposeAlphabet(Translator *tr, char *text) | |||
| { | |||
| // transpose cyrillic alphabet (for example) into ascii (single byte) character codes | |||
| @@ -2508,7 +2406,6 @@ int TransposeAlphabet(Translator *tr, char *text) | |||
| int bufix; | |||
| char buf[N_WORD_BYTES+1]; | |||
| offset = tr->transpose_min - 1; | |||
| min = tr->transpose_min; | |||
| max = tr->transpose_max; | |||
| @@ -2578,9 +2475,6 @@ int TransposeAlphabet(Translator *tr, char *text) | |||
| return strlen(text); | |||
| } | |||
| /* Find an entry in the word_dict file for a specified word. | |||
| Returns NULL if no match, else returns 'word_end' | |||
| @@ -2866,8 +2760,6 @@ static const char *LookupDict2(Translator *tr, const char *word, const char *wor | |||
| return 0; | |||
| } | |||
| /* Lookup a specified word in the word dictionary. | |||
| Returns phonetic data in 'phonetic' and bits in 'flags' | |||
| @@ -2925,7 +2817,6 @@ int LookupDictList(Translator *tr, char **wordptr, char *ph_out, unsigned int *f | |||
| found = LookupDict2(tr, word, word1, ph_out, flags, end_flags, wtab); | |||
| if (flags[0] & FLAG_MAX3) { | |||
| if (strcmp(ph_out, tr->phonemes_repeat) == 0) { | |||
| tr->phonemes_repeat_count++; | |||
| @@ -2938,7 +2829,6 @@ int LookupDictList(Translator *tr, char **wordptr, char *ph_out, unsigned int *f | |||
| } else | |||
| tr->phonemes_repeat_count = 0; | |||
| if ((found == 0) && (flags[1] & FLAG_ACCENT)) { | |||
| int letter; | |||
| word2 = word; | |||
| @@ -3000,7 +2890,6 @@ int LookupDictList(Translator *tr, char **wordptr, char *ph_out, unsigned int *f | |||
| return 0; | |||
| } | |||
| extern char word_phonemes[N_WORD_PHONEMES]; // a word translated into phoneme codes | |||
| int Lookup(Translator *tr, const char *word, char *ph_out) | |||
| @@ -3030,7 +2919,6 @@ int Lookup(Translator *tr, const char *word, char *ph_out) | |||
| return flags0; | |||
| } | |||
| int LookupFlags(Translator *tr, const char *word, unsigned int **flags_out) | |||
| { | |||
| char buf[100]; | |||
| @@ -3043,8 +2931,6 @@ int LookupFlags(Translator *tr, const char *word, unsigned int **flags_out) | |||
| return flags[0]; | |||
| } | |||
| int RemoveEnding(Translator *tr, char *word, int end_type, char *word_copy) | |||
| { | |||
| /* Removes a standard suffix from a word, once it has been indicated by the dictionary rules. | |||
| @@ -346,14 +346,12 @@ int delete_espeak_command(t_espeak_command *the_command) | |||
| free(the_command->u.my_text.text); | |||
| } | |||
| break; | |||
| case ET_MARK: | |||
| if (the_command->u.my_mark.text) | |||
| free(the_command->u.my_mark.text); | |||
| if (the_command->u.my_mark.index_mark) | |||
| free((void *)(the_command->u.my_mark.index_mark)); | |||
| break; | |||
| case ET_TERMINATED_MSG: | |||
| { | |||
| // if the terminated msg is pending, | |||
| @@ -367,28 +365,23 @@ int delete_espeak_command(t_espeak_command *the_command) | |||
| sync_espeak_terminated_msg(data->unique_identifier, data->user_data); | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| case ET_KEY: | |||
| if (the_command->u.my_key.key_name) | |||
| free((void *)(the_command->u.my_key.key_name)); | |||
| break; | |||
| case ET_CHAR: | |||
| case ET_PARAMETER: | |||
| // No allocation | |||
| break; | |||
| case ET_PUNCTUATION_LIST: | |||
| if (the_command->u.my_punctuation_list) | |||
| free((void *)(the_command->u.my_punctuation_list)); | |||
| break; | |||
| case ET_VOICE_NAME: | |||
| if (the_command->u.my_voice_name) | |||
| free((void *)(the_command->u.my_voice_name)); | |||
| break; | |||
| case ET_VOICE_SPEC: | |||
| { | |||
| espeak_VOICE *data = &(the_command->u.my_voice_spec); | |||
| @@ -402,8 +395,7 @@ int delete_espeak_command(t_espeak_command *the_command) | |||
| if (data->identifier) | |||
| free((void *)data->identifier); | |||
| } | |||
| break; | |||
| break; | |||
| default: | |||
| assert(0); | |||
| } | |||
| @@ -434,8 +426,7 @@ void process_espeak_command(t_espeak_command *the_command) | |||
| data->position, data->position_type, | |||
| data->end_position, data->flags, data->user_data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_MARK: | |||
| { | |||
| t_espeak_mark *data = &(the_command->u.my_mark); | |||
| @@ -443,57 +434,49 @@ void process_espeak_command(t_espeak_command *the_command) | |||
| data->index_mark, data->end_position, data->flags, | |||
| data->user_data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_TERMINATED_MSG: | |||
| { | |||
| t_espeak_terminated_msg *data = &(the_command->u.my_terminated_msg); | |||
| sync_espeak_terminated_msg(data->unique_identifier, data->user_data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_KEY: | |||
| { | |||
| const char *data = the_command->u.my_key.key_name; | |||
| sync_espeak_Key(data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_CHAR: | |||
| { | |||
| const wchar_t data = the_command->u.my_char.character; | |||
| sync_espeak_Char(data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_PARAMETER: | |||
| { | |||
| t_espeak_parameter *data = &(the_command->u.my_param); | |||
| SetParameter(data->parameter, data->value, data->relative); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_PUNCTUATION_LIST: | |||
| { | |||
| const wchar_t *data = the_command->u.my_punctuation_list; | |||
| sync_espeak_SetPunctuationList(data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_VOICE_NAME: | |||
| { | |||
| const char *data = the_command->u.my_voice_name; | |||
| SetVoiceByName(data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_VOICE_SPEC: | |||
| { | |||
| espeak_VOICE *data = &(the_command->u.my_voice_spec); | |||
| SetVoiceByProperties(data); | |||
| } | |||
| break; | |||
| break; | |||
| default: | |||
| assert(0); | |||
| break; | |||
| @@ -518,22 +501,19 @@ void display_espeak_command(t_espeak_command *the_command) | |||
| t_espeak_text *data = &(the_command->u.my_text); | |||
| SHOW("display_espeak_command > (0x%x) uid=%d, TEXT=%s, user_data=0x%x\n", the_command, data->unique_identifier, (char *)data->text, (int)(data->user_data)); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_MARK: | |||
| { | |||
| t_espeak_mark *data = &(the_command->u.my_mark); | |||
| SHOW("display_espeak_command > (0x%x) uid=%d, MARK=%s, user_data=0x%x\n", the_command, data->unique_identifier, (char *)data->text, (int)(data->user_data)); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_KEY: | |||
| { | |||
| const char *data = the_command->u.my_key.key_name; | |||
| SHOW("display_espeak_command > (0x%x) KEY=%c\n", the_command, data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_TERMINATED_MSG: | |||
| { | |||
| t_espeak_terminated_msg *data = &(the_command->u.my_terminated_msg); | |||
| @@ -542,44 +522,38 @@ void display_espeak_command(t_espeak_command *the_command) | |||
| the_command, data->unique_identifier, data->user_data, | |||
| the_command->state); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_CHAR: | |||
| { | |||
| const wchar_t data = the_command->u.my_char.character; | |||
| SHOW("display_espeak_command > (0x%x) CHAR=%c\n", the_command, (char)data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_PARAMETER: | |||
| { | |||
| t_espeak_parameter *data = &(the_command->u.my_param); | |||
| SHOW("display_espeak_command > (0x%x) PARAMETER=%d, value=%d, relative=%d\n", | |||
| the_command, data->parameter, data->value, data->relative); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_PUNCTUATION_LIST: | |||
| { | |||
| const wchar_t *data = the_command->u.my_punctuation_list; | |||
| sync_espeak_SetPunctuationList(data); | |||
| SHOW("display_espeak_command > (0x%x) PUNCTLIST=%s\n", the_command, (char *)data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_VOICE_NAME: | |||
| { | |||
| const char *data = the_command->u.my_voice_name; | |||
| SHOW("display_espeak_command > (0x%x) VOICE_NAME=%s\n", the_command, data); | |||
| } | |||
| break; | |||
| break; | |||
| case ET_VOICE_SPEC: | |||
| { | |||
| SHOW("display_espeak_command > (0x%x) VOICE_SPEC", the_command); | |||
| } | |||
| break; | |||
| break; | |||
| default: | |||
| assert(0); | |||
| break; | |||
| @@ -54,7 +54,6 @@ enum { MIN_TIMEOUT_IN_MS = 10, | |||
| ACTIVITY_TIMEOUT = 50, // in ms, check that the stream is active | |||
| MAX_ACTIVITY_CHECK = 6 }; | |||
| typedef struct t_node { | |||
| void *data; | |||
| struct t_node *next; | |||
| @@ -190,7 +189,6 @@ static void event_notify(espeak_EVENT *event) | |||
| my_callback(NULL, 0, events); | |||
| a_old_uid = event->unique_identifier; | |||
| break; | |||
| case espeakEVENT_MSG_TERMINATED: | |||
| case espeakEVENT_MARK: | |||
| case espeakEVENT_WORD: | |||
| @@ -207,11 +205,10 @@ static void event_notify(espeak_EVENT *event) | |||
| my_callback(NULL, 0, events); | |||
| a_old_uid = event->unique_identifier; | |||
| } | |||
| break; | |||
| default: | |||
| break; | |||
| case espeakEVENT_LIST_TERMINATED: | |||
| case espeakEVENT_PLAY: | |||
| default: | |||
| break; | |||
| } | |||
| } | |||
| @@ -231,13 +228,11 @@ static int event_delete(espeak_EVENT *event) | |||
| case espeakEVENT_MSG_TERMINATED: | |||
| event_notify(event); | |||
| break; | |||
| case espeakEVENT_MARK: | |||
| case espeakEVENT_PLAY: | |||
| if (event->id.name) | |||
| free((void *)(event->id.name)); | |||
| break; | |||
| default: | |||
| break; | |||
| } | |||
| @@ -38,7 +38,6 @@ | |||
| #include "wave.h" | |||
| #include "debug.h" | |||
| // my_mutex: protects my_thread_is_talking, | |||
| // my_stop_is_required, and the command fifo | |||
| static pthread_mutex_t my_mutex; | |||
| @@ -34,7 +34,6 @@ | |||
| #include "voice.h" | |||
| #include "translate.h" | |||
| /* Note this module is mostly old code that needs to be rewritten to | |||
| provide a more flexible intonation system. | |||
| */ | |||
| @@ -55,15 +54,11 @@ typedef struct { | |||
| static SYLLABLE *syllable_tab; | |||
| static int tone_pitch_env; /* used to return pitch envelope */ | |||
| /* Pitch data for tone types */ | |||
| /*****************************/ | |||
| #define PITCHfall 0 | |||
| #define PITCHrise 2 | |||
| #define PITCHfrise 4 // and 3 must be for the variant preceded by 'r' | |||
| @@ -204,9 +199,6 @@ static unsigned char env_risefallrise[128] = { | |||
| 0x50, 0x5a, 0x64, 0x70, 0x7c, 0x83, 0x85, 0x88, 0x8a, 0x8c, 0x8e, 0x8f, 0x91, 0x92, 0x93, 0x93 | |||
| }; | |||
| unsigned char *envelope_data[N_ENVELOPE_DATA] = { | |||
| env_fall, env_fall, | |||
| env_rise, env_rise, | |||
| @@ -221,8 +213,6 @@ unsigned char *envelope_data[N_ENVELOPE_DATA] = { | |||
| env_risefallrise, env_risefallrise | |||
| }; | |||
| /* indexed by stress */ | |||
| static int min_drop[] = { 6, 7, 9, 9, 20, 20, 20, 25 }; | |||
| @@ -234,11 +224,9 @@ static signed char oflow[] = { 0, 40, 24, 8, 0 }; | |||
| static signed char oflow_emf[] = { 10, 52, 32, 20, 10 }; | |||
| static signed char oflow_less[] = { 6, 38, 24, 14, 4 }; | |||
| #define N_TONE_HEAD_TABLE 13 | |||
| #define N_TONE_NUCLEUS_TABLE 13 | |||
| typedef struct { | |||
| unsigned char pre_start; | |||
| unsigned char pre_end; | |||
| @@ -254,7 +242,6 @@ typedef struct { | |||
| signed char *overflow; | |||
| } TONE_HEAD; | |||
| typedef struct { | |||
| unsigned char pitch_env0; /* pitch envelope, tonic syllable at end */ | |||
| unsigned char tonic_max0; | |||
| @@ -306,8 +293,6 @@ static TONE_NUCLEUS tone_nucleus_table[N_TONE_NUCLEUS_TABLE] = { | |||
| { PITCHfall, 70, 18, PITCHfall, 70, 24, NULL, 32, 20, 0 }, // 12 test | |||
| }; | |||
| /* index by 0=. 1=, 2=?, 3=! 4=none, 5=emphasized */ | |||
| unsigned char punctuation_to_tone[INTONATION_TYPES][PUNCT_INTONATIONS] = { | |||
| { 0, 1, 2, 3, 0, 4 }, | |||
| @@ -320,17 +305,14 @@ unsigned char punctuation_to_tone[INTONATION_TYPES][PUNCT_INTONATIONS] = { | |||
| { 12, 12, 12, 12, 0, 0 } | |||
| }; | |||
| int n_tunes = 0; | |||
| TUNE *tunes = NULL; | |||
| #define SECONDARY 3 | |||
| #define PRIMARY 4 | |||
| #define PRIMARY_STRESSED 6 | |||
| #define PRIMARY_LAST 7 | |||
| static int number_pre; | |||
| static int number_body; | |||
| static int number_tail; | |||
| @@ -339,7 +321,6 @@ static int tone_posn; | |||
| static int tone_posn2; | |||
| static int no_tonic; | |||
| static void count_pitch_vowels(int start, int end, int clause_end) | |||
| { | |||
| int ix; | |||
| @@ -370,7 +351,6 @@ static void count_pitch_vowels(int start, int end, int clause_end) | |||
| last_primary = ix; | |||
| } | |||
| } | |||
| if (number_pre < 0) | |||
| @@ -391,9 +371,6 @@ static void count_pitch_vowels(int start, int end, int clause_end) | |||
| } | |||
| } | |||
| /* Count number of primary stresses up to tonic syllable or body_reset */ | |||
| static int count_increments(int ix, int end_ix, int min_stress) | |||
| { | |||
| @@ -411,9 +388,6 @@ static int count_increments(int ix, int end_ix, int min_stress) | |||
| return count; | |||
| } | |||
| // Set the pitch of a vowel in syllable_tab | |||
| static void set_pitch(SYLLABLE *syl, int base, int drop) | |||
| { | |||
| @@ -441,7 +415,6 @@ static void set_pitch(SYLLABLE *syl, int base, int drop) | |||
| syl->flags |= flags; | |||
| } | |||
| static int CountUnstressed(int start, int end, int limit) | |||
| { | |||
| int ix; | |||
| @@ -521,7 +494,6 @@ static int SetHeadIntonation(TUNE *tune, int syl_ix, int end_ix, int control) | |||
| increment = pitch_range / (n_steps -1); | |||
| else | |||
| increment = 0; | |||
| } else if (syl_ix == head_final) { | |||
| // a pitch has been specified for the last primary stress before the nucleus | |||
| pitch = tune->head_last << 8; | |||
| @@ -567,11 +539,8 @@ static int SetHeadIntonation(TUNE *tune, int syl_ix, int end_ix, int control) | |||
| syl_ix++; | |||
| } | |||
| return syl_ix; | |||
| } | |||
| /* Calculate pitches until next RESET or tonic syllable, or end. | |||
| Increment pitch if stress is >= min_stress. | |||
| Used for tonic segment */ | |||
| @@ -667,8 +636,6 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_HEAD *th, TONE_NUCLEUS *t | |||
| return ix; | |||
| } | |||
| static void SetPitchGradient(int start_ix, int end_ix, int start_pitch, int end_pitch) | |||
| { | |||
| // Set a linear pitch change over a number of syllables. | |||
| @@ -714,8 +681,6 @@ static void SetPitchGradient(int start_ix, int end_ix, int start_pitch, int end_ | |||
| } | |||
| } | |||
| // Calculate pitch values for the vowels in this tone group | |||
| static int calc_pitches2(int start, int end, int tune_number) | |||
| { | |||
| @@ -767,8 +732,6 @@ static int calc_pitches2(int start, int end, int tune_number) | |||
| return tone_pitch_env; | |||
| } | |||
| // Calculate pitch values for the vowels in this tone group | |||
| static int calc_pitches(int control, int start, int end, int tune_number) | |||
| { | |||
| @@ -833,11 +796,6 @@ static int calc_pitches(int control, int start, int end, int tune_number) | |||
| return tone_pitch_env; | |||
| } | |||
| static void CalcPitches_Tone(Translator *tr, int clause_tone) | |||
| { | |||
| // clause_tone: 0=. 1=, 2=?, 3=! 4=none | |||
| @@ -883,7 +841,6 @@ static void CalcPitches_Tone(Translator *tr, int clause_tone) | |||
| p->tone_ph = PhonemeCode('7'); // change default tone (tone 1) to falling tone at end of clause | |||
| } | |||
| pause = 1; | |||
| tone_promoted = 0; | |||
| @@ -915,7 +872,6 @@ static void CalcPitches_Tone(Translator *tr, int clause_tone) | |||
| p->tone_ph = tone_ph; | |||
| tph = phoneme_tab[tone_ph]; | |||
| } else | |||
| tone_promoted = 0; | |||
| @@ -980,12 +936,8 @@ static void CalcPitches_Tone(Translator *tr, int clause_tone) | |||
| p->pitch2 = pitch_adjust + phoneme_tab[tone_ph]->end_type; | |||
| } | |||
| } | |||
| } | |||
| void CalcPitches(Translator *tr, int clause_type) | |||
| { | |||
| // clause_type: 0=. 1=, 2=?, 3=! 4=none | |||
| @@ -1030,14 +982,11 @@ void CalcPitches(Translator *tr, int clause_type) | |||
| if (n_st == 0) | |||
| return; // nothing to do | |||
| if (tr->langopts.tone_language == 1) { | |||
| CalcPitches_Tone(tr, clause_type); | |||
| return; | |||
| } | |||
| option = tr->langopts.intonation_group; | |||
| if (option >= INTONATION_TYPES) | |||
| option = 1; | |||
| @@ -1132,7 +1081,6 @@ void CalcPitches(Translator *tr, int clause_type) | |||
| calc_pitches(option, st_start, st_ix, group_tone); | |||
| } | |||
| // unpack pitch data | |||
| st_ix = 0; | |||
| for (ix = ph_start; ix < ph_end; ix++) { | |||
| @@ -1171,5 +1119,4 @@ void CalcPitches(Translator *tr, int clause_type) | |||
| st_ix++; | |||
| } | |||
| } | |||
| } | |||
| @@ -47,14 +47,12 @@ extern WGEN_DATA wdata; | |||
| static int nsamples; | |||
| static int sample_count; | |||
| #ifdef _MSC_VER | |||
| #define getrandom(min, max) ((rand()%(int)(((max)+1)-(min)))+(min)) | |||
| #else | |||
| #define getrandom(min, max) ((rand()%(long)(((max)+1)-(min)))+(min)) | |||
| #endif | |||
| /* function prototypes for functions private to this file */ | |||
| static void flutter(klatt_frame_ptr); | |||
| @@ -152,8 +150,6 @@ static double resonator2(resonator_ptr r, double input) | |||
| return (double)x; | |||
| } | |||
| static double antiresonator2(resonator_ptr r, double input) | |||
| { | |||
| register double x = (double)r->a * (double)input + (double)r->b * (double)r->p1 + (double)r->c * (double)r->p2; | |||
| @@ -166,8 +162,6 @@ static double antiresonator2(resonator_ptr r, double input) | |||
| return (double)x; | |||
| } | |||
| /* | |||
| function FLUTTER | |||
| @@ -196,8 +190,6 @@ static void flutter(klatt_frame_ptr frame) | |||
| time_count++; | |||
| } | |||
| /* | |||
| function SAMPLED_SOURCE | |||
| @@ -245,16 +237,12 @@ static double sampled_source(int source_num) | |||
| return result; | |||
| } | |||
| /* | |||
| function PARWAVE | |||
| Converts synthesis parameters to a waveform. | |||
| */ | |||
| static int parwave(klatt_frame_ptr frame) | |||
| { | |||
| double temp; | |||
| @@ -460,10 +448,6 @@ static int parwave(klatt_frame_ptr frame) | |||
| return 0; | |||
| } | |||
| void KlattReset(int control) | |||
| { | |||
| int r_ix; | |||
| @@ -488,7 +472,6 @@ void KlattReset(int control) | |||
| kt_globals.rsn[r_ix].p1 = 0; | |||
| kt_globals.rsn[r_ix].p2 = 0; | |||
| } | |||
| } | |||
| for (r_ix = 0; r_ix <= R6p; r_ix++) { | |||
| @@ -497,7 +480,6 @@ void KlattReset(int control) | |||
| } | |||
| } | |||
| /* | |||
| function FRAME_INIT | |||
| @@ -553,7 +535,6 @@ static void frame_init(klatt_frame_ptr frame) | |||
| kt_globals.rsn[F_NZ].b_inc = (kt_globals.rsn_next[F_NZ].b - kt_globals.rsn[F_NZ].b) / 64.0; | |||
| kt_globals.rsn[F_NZ].c_inc = (kt_globals.rsn_next[F_NZ].c - kt_globals.rsn[F_NZ].c) / 64.0; | |||
| /* Set coefficients of parallel resonators, and amplitude of outputs */ | |||
| for (ix = 0; ix <= 6; ix++) { | |||
| @@ -564,11 +545,8 @@ static void frame_init(klatt_frame_ptr frame) | |||
| /* output low-pass filter */ | |||
| setabc((long)0.0, (long)(kt_globals.samrate/2), &(kt_globals.rsn[Rout])); | |||
| } | |||
| /* | |||
| function IMPULSIVE_SOURCE | |||
| @@ -578,7 +556,6 @@ static void frame_init(klatt_frame_ptr frame) | |||
| to Kopen. | |||
| */ | |||
| static double impulsive_source() | |||
| { | |||
| static double doublet[] = { 0.0, 13000000.0, -13000000.0 }; | |||
| @@ -592,8 +569,6 @@ static double impulsive_source() | |||
| return resonator(&(kt_globals.rsn[RGL]), vwave); | |||
| } | |||
| /* | |||
| function NATURAL_SOURCE | |||
| @@ -617,10 +592,6 @@ static double natural_source() | |||
| return 0.0; | |||
| } | |||
| /* | |||
| function PITCH_SYNC_PAR_RESET | |||
| @@ -708,7 +679,6 @@ static void pitch_synch_par_reset(klatt_frame_ptr frame) | |||
| kt_globals.nopen = 40; | |||
| } | |||
| /* Reset a & b, which determine shape of "natural" glottal waveform */ | |||
| kt_globals.pulse_shape_b = B0[kt_globals.nopen-40]; | |||
| @@ -765,8 +735,6 @@ static void pitch_synch_par_reset(klatt_frame_ptr frame) | |||
| } | |||
| } | |||
| /* | |||
| function SETABC | |||
| @@ -774,7 +742,6 @@ static void pitch_synch_par_reset(klatt_frame_ptr frame) | |||
| equation constants. | |||
| */ | |||
| static void setabc(long int f, long int bw, resonator_ptr rp) | |||
| { | |||
| double r; | |||
| @@ -795,7 +762,6 @@ static void setabc(long int f, long int bw, resonator_ptr rp) | |||
| rp->a = 1.0 - rp->b - rp->c; | |||
| } | |||
| /* | |||
| function SETZEROABC | |||
| @@ -838,7 +804,6 @@ static void setzeroabc(long int f, long int bw, resonator_ptr rp) | |||
| } | |||
| } | |||
| /* | |||
| function GEN_NOISE | |||
| @@ -847,7 +812,6 @@ static void setzeroabc(long int f, long int bw, resonator_ptr rp) | |||
| the origin in the z-plane, i.e. output = input + (0.75 * lastoutput) | |||
| */ | |||
| static double gen_noise(double noise) | |||
| { | |||
| long temp; | |||
| @@ -862,7 +826,6 @@ static double gen_noise(double noise) | |||
| return noise; | |||
| } | |||
| /* | |||
| function DBTOLIN | |||
| @@ -881,7 +844,6 @@ static double gen_noise(double noise) | |||
| steps. | |||
| */ | |||
| static double DBtoLIN(long dB) | |||
| { | |||
| static short amptable[88] = { | |||
| @@ -902,10 +864,6 @@ static double DBtoLIN(long dB) | |||
| return (double)(amptable[dB]) * 0.001; | |||
| } | |||
| extern voice_t *wvoice; | |||
| static klatt_peaks_t peaks[N_PEAKS]; | |||
| static int end_wave; | |||
| @@ -913,9 +871,6 @@ static int klattp[N_KLATTP]; | |||
| static double klattp1[N_KLATTP]; | |||
| static double klattp_inc[N_KLATTP]; | |||
| int Wavegen_Klatt(int resume) | |||
| { | |||
| int pk; | |||
| @@ -1005,7 +960,6 @@ int Wavegen_Klatt(int resume) | |||
| return 0; | |||
| } | |||
| void SetSynth_Klatt(int length, int modn, frame_t *fr1, frame_t *fr2, voice_t *v, int control) | |||
| { | |||
| int ix; | |||
| @@ -1122,7 +1076,6 @@ void SetSynth_Klatt(int length, int modn, frame_t *fr1, frame_t *fr2, voice_t *v | |||
| } | |||
| } | |||
| int Wavegen_Klatt2(int length, int modulation, int resume, frame_t *fr1, frame_t *fr2) | |||
| { | |||
| if (resume == 0) | |||
| @@ -1131,8 +1084,6 @@ int Wavegen_Klatt2(int length, int modulation, int resume, frame_t *fr1, frame_t | |||
| return Wavegen_Klatt(resume); | |||
| } | |||
| void KlattInit() | |||
| { | |||
| @@ -34,7 +34,6 @@ | |||
| #include "mbrowrap.h" | |||
| /* | |||
| * mbrola instance parameters | |||
| */ | |||
| @@ -38,7 +38,6 @@ | |||
| #include "voice.h" | |||
| #include "translate.h" | |||
| #define M_LIGATURE 0x8000 | |||
| #define M_NAME 0 | |||
| #define M_SMALLCAP 1 | |||
| @@ -65,7 +64,6 @@ | |||
| #define M_RETROFLEX 20 | |||
| #define M_HOOK 21 | |||
| #define M_MIDDLE_DOT M_DOT_ABOVE // duplicate of M_DOT_ABOVE | |||
| #define M_IMPLOSIVE M_HOOK | |||
| @@ -74,7 +72,6 @@ static char *digit_lookup; | |||
| static int speak_missing_thousands; | |||
| static int number_control; | |||
| typedef struct { | |||
| const char *name; | |||
| int accent_flags; // bit 0, say before the letter name | |||
| @@ -108,7 +105,6 @@ static ACCENTS accents_tab[] = { | |||
| { "_hok", 0 }, // hook | |||
| }; | |||
| #define CAPITAL 0 | |||
| #define LETTER(ch, mod1, mod2) (ch-59)+(mod1 << 6)+(mod2 << 11) | |||
| #define LIGATURE(ch1, ch2, mod1) (ch1-59)+((ch2-59) << 6)+(mod1 << 12)+M_LIGATURE | |||
| @@ -130,13 +126,11 @@ static ACCENTS accents_tab[] = { | |||
| #define L_RTAP 72 // U+27E | |||
| #define L_RLONG 73 // U+27C | |||
| static const short non_ascii_tab[] = { | |||
| 0, 0x3b1, 0x259, 0x25b, 0x3b3, 0x3b9, 0x153, 0x3c9, | |||
| 0x3c6, 0x283, 0x3c5, 0x292, 0x294, 0x27e, 0x27c | |||
| }; | |||
| // characters U+00e0 to U+017f | |||
| static const unsigned short letter_accents_0e0[] = { | |||
| LETTER('a', M_GRAVE, 0), // U+00e0 | |||
| @@ -299,10 +293,8 @@ static const unsigned short letter_accents_0e0[] = { | |||
| CAPITAL, | |||
| LETTER('z', M_CARON, 0), | |||
| LETTER('s', M_NAME, 0), // long-s // U+17f | |||
| }; | |||
| // characters U+0250 to U+029F | |||
| static const unsigned short letter_accents_250[] = { | |||
| LETTER('a', M_TURNED, 0), // U+250 | |||
| @@ -415,7 +407,6 @@ static int LookupLetter2(Translator *tr, unsigned int letter, char *ph_buf) | |||
| return ph_buf[0]; | |||
| } | |||
| void LookupAccentedLetter(Translator *tr, unsigned int letter, char *ph_buf) | |||
| { | |||
| // lookup the character in the accents table | |||
| @@ -451,14 +442,12 @@ void LookupAccentedLetter(Translator *tr, unsigned int letter, char *ph_buf) | |||
| accent2 = (accent_data >> 11) & 0xf; | |||
| } | |||
| if ((accent1 == 0) && !(accent_data & M_LIGATURE)) { | |||
| // just a letter name, not an accented character or ligature | |||
| return; | |||
| } | |||
| if ((flags1 = Lookup(tr, accents_tab[accent1].name, ph_accent1)) != 0) { | |||
| if (LookupLetter2(tr, basic_letter, ph_letter1) != 0) { | |||
| if (accent2 != 0) { | |||
| flags2 = Lookup(tr, accents_tab[accent2].name, ph_accent2); | |||
| @@ -485,8 +474,6 @@ void LookupAccentedLetter(Translator *tr, unsigned int letter, char *ph_buf) | |||
| } | |||
| } | |||
| void LookupLetter(Translator *tr, unsigned int letter, int next_byte, char *ph_buf1, int control) | |||
| { | |||
| // control, bit 0: not the first letter of a word | |||
| @@ -554,10 +541,8 @@ void LookupLetter(Translator *tr, unsigned int letter, int next_byte, char *ph_b | |||
| dict_flags[0] = 0; | |||
| dict_flags[1] = 0; | |||
| SetWordStress(tr, ph_buf1, dict_flags, -1, control & 1); | |||
| } | |||
| // unicode ranges for non-ascii digits 0-9 | |||
| static const int number_ranges[] = { | |||
| 0x660, 0x6f0, // arabic | |||
| @@ -566,7 +551,6 @@ static const int number_ranges[] = { | |||
| 0 | |||
| }; // these must be in ascending order | |||
| int NonAsciiNumber(int letter) | |||
| { | |||
| // Change non-ascii digit into ascii digit '0' to '9', (or -1 if not) | |||
| @@ -654,10 +638,8 @@ static unsigned short derived_letters[] = { | |||
| 0, 0 | |||
| }; | |||
| static const char *hex_letters[] = { "'e:j", "b'i:", "s'i:", "d'i:", "'i:", "'ef" }; // names, using phonemes available to all languages | |||
| int IsSuperscript(int letter) | |||
| { | |||
| // is this a subscript or superscript letter ? | |||
| @@ -673,8 +655,6 @@ int IsSuperscript(int letter) | |||
| return 0; | |||
| } | |||
| int TranslateLetter(Translator *tr, char *word, char *phonemes, int control) | |||
| { | |||
| // get pronunciation for an isolated letter | |||
| @@ -797,7 +777,6 @@ int TranslateLetter(Translator *tr, char *word, char *phonemes, int control) | |||
| } | |||
| } | |||
| // caution: SetWordStress() etc don't expect phonSWITCH + phoneme table number | |||
| if (ph_buf[0] == 0) { | |||
| @@ -918,8 +897,6 @@ int TranslateLetter(Translator *tr, char *word, char *phonemes, int control) | |||
| return n_bytes; | |||
| } | |||
| void SetSpellingStress(Translator *tr, char *phonemes, int control, int n_chars) | |||
| { | |||
| // Individual letter names, reduce the stress of some. | |||
| @@ -971,17 +948,13 @@ void SetSpellingStress(Translator *tr, char *phonemes, int control, int n_chars) | |||
| *phonemes = 0; | |||
| } | |||
| // Numbers | |||
| static char ph_ordinal2[12]; | |||
| static char ph_ordinal2x[12]; | |||
| static int CheckDotOrdinal(Translator *tr, char *word, char *word_end, WORD_TAB *wtab, int roman) | |||
| { | |||
| int ordinal = 0; | |||
| int c2; | |||
| int nextflags; | |||
| @@ -1027,7 +1000,6 @@ static int CheckDotOrdinal(Translator *tr, char *word, char *word_end, WORD_TAB | |||
| return ordinal; | |||
| } | |||
| static int hu_number_e(const char *word, int thousandplex, int value) | |||
| { | |||
| // lang-hu: variant form of numbers when followed by hyphen and a suffix starting with 'a' or 'e' (but not a, e, az, ez, azt, ezt, att. ett | |||
| @@ -1044,8 +1016,6 @@ static int hu_number_e(const char *word, int thousandplex, int value) | |||
| return 0; | |||
| } | |||
| int TranslateRoman(Translator *tr, char *word, char *ph_out, WORD_TAB *wtab) | |||
| { | |||
| int c; | |||
| @@ -1123,7 +1093,6 @@ int TranslateRoman(Translator *tr, char *word, char *ph_out, WORD_TAB *wtab) | |||
| if (acc > tr->langopts.max_roman) | |||
| return 0; | |||
| Lookup(tr, "_roman", ph_roman); // precede by "roman" if _rom is defined in *_list | |||
| p = &ph_out[0]; | |||
| @@ -1165,7 +1134,6 @@ int TranslateRoman(Translator *tr, char *word, char *ph_out, WORD_TAB *wtab) | |||
| return 1; | |||
| } | |||
| static const char *M_Variant(int value) | |||
| { | |||
| // returns M, or perhaps MA or MB for some cases | |||
| @@ -1181,24 +1149,20 @@ static const char *M_Variant(int value) | |||
| if ((teens == 0) && ((value % 10) == 1)) | |||
| return "1M"; | |||
| break; | |||
| case 2: // lang=cs,sk | |||
| if ((value >= 2) && (value <= 4)) | |||
| return "0MA"; | |||
| break; | |||
| case 3: // lang=pl | |||
| if ((teens == 0) && (((value % 10) >= 2) && ((value % 10) <= 4))) | |||
| return "0MA"; | |||
| break; | |||
| case 4: // lang=lt | |||
| if ((teens == 1) || ((value % 10) == 0)) | |||
| return "0MB"; | |||
| if ((value % 10) == 1) | |||
| return "0MA"; | |||
| break; | |||
| case 5: // lang=bs,hr,sr | |||
| if (teens == 0) { | |||
| if ((value % 10) == 1) | |||
| @@ -1211,7 +1175,6 @@ static const char *M_Variant(int value) | |||
| return "0M"; | |||
| } | |||
| static int LookupThousands(Translator *tr, int value, int thousandplex, int thousands_exact, char *ph_out) | |||
| { | |||
| // thousands_exact: bit 0 no hundreds,tens,or units, bit 1 ordinal numberr | |||
| @@ -1301,7 +1264,6 @@ static int LookupThousands(Translator *tr, int value, int thousandplex, int thou | |||
| return found_value; | |||
| } | |||
| static int LookupNum2(Translator *tr, int value, int thousandplex, const int control, char *ph_out) | |||
| { | |||
| // Lookup a 2 digit number | |||
| @@ -1410,7 +1372,6 @@ static int LookupNum2(Translator *tr, int value, int thousandplex, const int con | |||
| if (found) { | |||
| ph_tens[0] = 0; | |||
| } else { | |||
| if (is_ordinal) { | |||
| sprintf(string, "_%dX%c", tens, ord_type); | |||
| if (Lookup(tr, string, ph_tens) != 0) { | |||
| @@ -1548,7 +1509,6 @@ static int LookupNum2(Translator *tr, int value, int thousandplex, const int con | |||
| return used_and; | |||
| } | |||
| static int LookupNum3(Translator *tr, int value, char *ph_out, int suppress_null, int thousandplex, int control) | |||
| { | |||
| // Translate a 3 digit number | |||
| @@ -1709,7 +1669,6 @@ static int LookupNum3(Translator *tr, int value, char *ph_out, int suppress_null | |||
| } | |||
| } | |||
| buf2[0] = 0; | |||
| if ((tensunits != 0) || (suppress_null == 0)) { | |||
| @@ -1751,7 +1710,6 @@ static int LookupNum3(Translator *tr, int value, char *ph_out, int suppress_null | |||
| return 0; | |||
| } | |||
| bool CheckThousandsGroup(char *word, int group_len) | |||
| { | |||
| // Is this a group of 3 digits which looks like a thousands group? | |||
| @@ -1767,7 +1725,6 @@ bool CheckThousandsGroup(char *word, int group_len) | |||
| return true; | |||
| } | |||
| static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned int *flags, WORD_TAB *wtab, int control) | |||
| { | |||
| // Number translation with various options | |||
| @@ -1880,7 +1837,6 @@ static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned | |||
| ph_append[0] = 0; | |||
| ph_buf2[0] = 0; | |||
| if ((word[0] == '0') && (prev_thousands == 0) && (word[1] != ' ') && (word[1] != tr->langopts.decimal_sep)) { | |||
| if ((n_digits == 2) && (word[3] == ':') && IsDigit09(word[5]) && isspace(word[7])) { | |||
| // looks like a time 02:30, omit the leading zero | |||
| @@ -2020,6 +1976,7 @@ static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned | |||
| { | |||
| case NUM_DFRACTION_4: | |||
| max_decimal_count = 5; | |||
| // fallthrough | |||
| case NUM_DFRACTION_2: | |||
| // French/Polish decimal fraction | |||
| while (word[n_digits] == '0') { | |||
| @@ -2034,7 +1991,6 @@ static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned | |||
| n_digits += decimal_count; | |||
| } | |||
| break; | |||
| case NUM_DFRACTION_1: // italian, say "hundredths" if leading zero | |||
| case NUM_DFRACTION_5: // hungarian, always say "tenths" etc. | |||
| case NUM_DFRACTION_6: // kazakh, always say "tenths" etc, before the decimal fraction | |||
| @@ -2053,7 +2009,6 @@ static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned | |||
| strcat(ph_out, ph_buf); | |||
| n_digits += decimal_count; | |||
| break; | |||
| case NUM_DFRACTION_3: | |||
| // Romanian decimal fractions | |||
| if ((decimal_count <= 4) && (word[n_digits] != '0')) { | |||
| @@ -2062,7 +2017,6 @@ static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned | |||
| n_digits += decimal_count; | |||
| } | |||
| break; | |||
| case NUM_DFRACTION_7: | |||
| // alternative form of decimal fraction digits, except the final digit | |||
| while (decimal_count-- > 1) { | |||
| @@ -2113,8 +2067,6 @@ static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned | |||
| return 1; | |||
| } | |||
| int TranslateNumber(Translator *tr, char *word1, char *ph_out, unsigned int *flags, WORD_TAB *wtab, int control) | |||
| { | |||
| if ((option_sayas == SAYAS_DIGITS1) || (wtab[0].flags & FLAG_INDIVIDUAL_DIGITS)) | |||
| @@ -32,15 +32,11 @@ | |||
| #include "synthesize.h" | |||
| #include "translate.h" | |||
| const unsigned char pause_phonemes[8] = { 0, phonPAUSE_VSHORT, phonPAUSE_SHORT, phonPAUSE, phonPAUSE_LONG, phonGLOTTALSTOP, phonPAUSE_LONG, phonPAUSE_LONG }; | |||
| extern int n_ph_list2; | |||
| extern PHONEME_LIST2 ph_list2[N_PHONEME_LIST]; // first stage of text->phonemes | |||
| static int SubstitutePhonemes(Translator *tr, PHONEME_LIST *plist_out) | |||
| { | |||
| // Copy the phonemes list and perform any substitutions that are required for the | |||
| @@ -100,11 +96,8 @@ static int SubstitutePhonemes(Translator *tr, PHONEME_LIST *plist_out) | |||
| return n_plist_out; | |||
| } | |||
| void MakePhonemeList(Translator *tr, int post_pause, int start_sentence) | |||
| { | |||
| int ix = 0; | |||
| int j; | |||
| int insert_ph = 0; | |||
| @@ -44,14 +44,12 @@ | |||
| #include <locale.h> | |||
| #define N_XML_BUF 500 | |||
| static const char *xmlbase = ""; // base URL from <speak> | |||
| static int namedata_ix = 0; | |||
| static int n_namedata = 0; | |||
| char *namedata = NULL; | |||
| static FILE *f_input = NULL; | |||
| static int ungot_char2 = 0; | |||
| unsigned char *p_textinput; | |||
| @@ -116,7 +114,6 @@ static const unsigned short punct_chars[] = { ',', '.', '?', '!', ':', ';', | |||
| 0 }; | |||
| // indexed by (entry num. in punct_chars) + 1 | |||
| // bits 0-7 pause x 10mS, bits 12-14 intonation type, bit 15 don't need following space or bracket | |||
| static const unsigned int punct_attributes[] = { 0, | |||
| @@ -168,7 +165,6 @@ static const unsigned int punct_attributes[] = { 0, | |||
| CLAUSE_SEMICOLON, // spare | |||
| 0 }; | |||
| // stack for language and voice properties | |||
| // frame 0 is for the defaults, before any ssml tags. | |||
| typedef struct { | |||
| @@ -188,7 +184,6 @@ static espeak_VOICE base_voice; | |||
| static char base_voice_variant_name[40] = { 0 }; | |||
| static char current_voice_id[40] = { 0 }; | |||
| #define N_PARAM_STACK 20 | |||
| static int n_param_stack; | |||
| PARAM_STACK param_stack[N_PARAM_STACK]; | |||
| @@ -214,7 +209,6 @@ const int param_defaults[N_SPEECH_PARAM] = { | |||
| 0, // voice type | |||
| }; | |||
| // additional Latin characters beyond the ascii character set | |||
| #define MAX_WALPHA 0x24f | |||
| // indexed by character - 0x80 | |||
| @@ -284,7 +278,6 @@ static const short wchar_toupper[] = { | |||
| 0, 0 | |||
| }; | |||
| #ifdef NEED_WCHAR_FUNCTIONS | |||
| // use ctype.h functions for Latin1 (character < 0x100) | |||
| @@ -421,7 +414,6 @@ float wcstod(const wchar_t *str, wchar_t **tailptr) | |||
| } | |||
| #endif | |||
| // use internal data for iswalpha up to U+024F | |||
| // iswalpha() on Windows is unreliable (U+AA, U+BA). | |||
| int iswalpha2(int c) | |||
| @@ -513,7 +505,6 @@ static int IsRomanU(unsigned int c) | |||
| return 0; | |||
| } | |||
| static void GetC_unget(int c) | |||
| { | |||
| // This is only called with UTF8 input, not wchar input | |||
| @@ -537,7 +528,6 @@ int Eof(void) | |||
| return end_of_input; | |||
| } | |||
| static int GetC_get(void) | |||
| { | |||
| unsigned int c; | |||
| @@ -581,7 +571,6 @@ static int GetC_get(void) | |||
| return 0; | |||
| } | |||
| static int GetC(void) | |||
| { | |||
| // Returns a unicode wide character | |||
| @@ -660,13 +649,11 @@ static int GetC(void) | |||
| return c1; | |||
| } | |||
| static void UngetC(int c) | |||
| { | |||
| ungot_char = c; | |||
| } | |||
| const char *WordToString2(unsigned int word) | |||
| { | |||
| // Convert a language mnemonic word into a string | |||
| @@ -683,7 +670,6 @@ const char *WordToString2(unsigned int word) | |||
| return buf; | |||
| } | |||
| static const char *LookupSpecial(Translator *tr, const char *string, char *text_out) | |||
| { | |||
| unsigned int flags[2]; | |||
| @@ -701,7 +687,6 @@ static const char *LookupSpecial(Translator *tr, const char *string, char *text_ | |||
| return NULL; | |||
| } | |||
| static const char *LookupCharName(Translator *tr, int c, int only) | |||
| { | |||
| // Find the phoneme string (in ascii) to speak the name of character c | |||
| @@ -786,7 +771,6 @@ int Read4Bytes(FILE *f) | |||
| return acc; | |||
| } | |||
| static int LoadSoundFile(const char *fname, int index) | |||
| { | |||
| FILE *f; | |||
| @@ -862,7 +846,6 @@ static int LoadSoundFile(const char *fname, int index) | |||
| return 0; | |||
| } | |||
| static int LookupSoundicon(int c) | |||
| { | |||
| // Find the sound icon number for a punctuation chatacter | |||
| @@ -880,7 +863,6 @@ static int LookupSoundicon(int c) | |||
| return -1; | |||
| } | |||
| static int LoadSoundFile2(const char *fname) | |||
| { | |||
| // Load a sound file into one of the reserved slots in the sound icon table | |||
| @@ -907,8 +889,6 @@ static int LoadSoundFile2(const char *fname) | |||
| return slot; | |||
| } | |||
| static int AnnouncePunctuation(Translator *tr, int c1, int *c2_ptr, char *output, int *bufix, int end_clause) | |||
| { | |||
| // announce punctuation names | |||
| @@ -1037,7 +1017,6 @@ static int AnnouncePunctuation(Translator *tr, int c1, int *c2_ptr, char *output | |||
| // these tags have no effect if they are self-closing, eg. <voice /> | |||
| static char ignore_if_self_closing[] = { 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0 }; | |||
| static MNEM_TAB ssmltags[] = { | |||
| { "speak", SSML_SPEAK }, | |||
| { "voice", SSML_VOICE }, | |||
| @@ -1075,9 +1054,6 @@ static MNEM_TAB ssmltags[] = { | |||
| { NULL, 0 } | |||
| }; | |||
| static const char *VoiceFromStack() | |||
| { | |||
| // Use the voice properties from the SSML stack to choose a voice, and switch | |||
| @@ -1153,8 +1129,6 @@ static const char *VoiceFromStack() | |||
| return v_id; | |||
| } | |||
| static void ProcessParamStack(char *outbuf, int *outix) | |||
| { | |||
| // Set the speech parameters from the parameter stack | |||
| @@ -1165,7 +1139,6 @@ static void ProcessParamStack(char *outbuf, int *outix) | |||
| int new_parameters[N_SPEECH_PARAM]; | |||
| static char cmd_letter[N_SPEECH_PARAM] = { 0, 'S', 'A', 'P', 'R', 0, 'C', 0, 0, 0, 0, 0, 'F' }; // embedded command letters | |||
| for (param = 0; param < N_SPEECH_PARAM; param++) | |||
| new_parameters[param] = -1; | |||
| @@ -1185,11 +1158,9 @@ static void ProcessParamStack(char *outbuf, int *outix) | |||
| case espeakPUNCTUATION: | |||
| option_punctuation = value-1; | |||
| break; | |||
| case espeakCAPITALS: | |||
| option_capitals = value; | |||
| break; | |||
| case espeakRATE: | |||
| case espeakVOLUME: | |||
| case espeakPITCH: | |||
| @@ -1206,7 +1177,6 @@ static void ProcessParamStack(char *outbuf, int *outix) | |||
| } | |||
| } | |||
| static PARAM_STACK *PushParamStack(int tag_type) | |||
| { | |||
| int ix; | |||
| @@ -1222,7 +1192,6 @@ static PARAM_STACK *PushParamStack(int tag_type) | |||
| return sp; | |||
| } | |||
| static void PopParamStack(int tag_type, char *outbuf, int *outix) | |||
| { | |||
| // unwind the stack up to and including the previous tag of this type | |||
| @@ -1241,8 +1210,6 @@ static void PopParamStack(int tag_type, char *outbuf, int *outix) | |||
| ProcessParamStack(outbuf, outix); | |||
| } | |||
| static wchar_t *GetSsmlAttribute(wchar_t *pw, const char *name) | |||
| { | |||
| // Gets the value string for an attribute. | |||
| @@ -1273,7 +1240,6 @@ static wchar_t *GetSsmlAttribute(wchar_t *pw, const char *name) | |||
| return NULL; | |||
| } | |||
| static int attrcmp(const wchar_t *string1, const char *string2) | |||
| { | |||
| int ix; | |||
| @@ -1288,7 +1254,6 @@ static int attrcmp(const wchar_t *string1, const char *string2) | |||
| return 1; | |||
| } | |||
| static int attrlookup(const wchar_t *string1, const MNEM_TAB *mtab) | |||
| { | |||
| int ix; | |||
| @@ -1300,7 +1265,6 @@ static int attrlookup(const wchar_t *string1, const MNEM_TAB *mtab) | |||
| return mtab[ix].value; | |||
| } | |||
| static int attrnumber(const wchar_t *pw, int default_value, int type) | |||
| { | |||
| int value = 0; | |||
| @@ -1317,8 +1281,6 @@ static int attrnumber(const wchar_t *pw, int default_value, int type) | |||
| return value; | |||
| } | |||
| static int attrcopy_utf8(char *buf, const wchar_t *pw, int len) | |||
| { | |||
| // Convert attribute string into utf8, write to buf, and return its utf8 length | |||
| @@ -1340,8 +1302,6 @@ static int attrcopy_utf8(char *buf, const wchar_t *pw, int len) | |||
| return ix; | |||
| } | |||
| static int attr_prosody_value(int param_type, const wchar_t *pw, int *value_out) | |||
| { | |||
| int sign = 0; | |||
| @@ -1395,7 +1355,6 @@ static int attr_prosody_value(int param_type, const wchar_t *pw, int *value_out) | |||
| return sign; // -1, 0, or 1 | |||
| } | |||
| int AddNameData(const char *name, int wide) | |||
| { | |||
| // Add the name to the namedata and return its position | |||
| @@ -1424,7 +1383,6 @@ int AddNameData(const char *name, int wide) | |||
| return ix; | |||
| } | |||
| void SetVoiceStack(espeak_VOICE *v, const char *variant_name) | |||
| { | |||
| SSML_STACK *sp; | |||
| @@ -1448,7 +1406,6 @@ void SetVoiceStack(espeak_VOICE *v, const char *variant_name) | |||
| memcpy(&base_voice, ¤t_voice_selected, sizeof(base_voice)); | |||
| } | |||
| static int GetVoiceAttributes(wchar_t *pw, int tag_type) | |||
| { | |||
| // Determines whether voice attribute are specified in this tag, and if so, whether this means | |||
| @@ -1519,7 +1476,6 @@ static int GetVoiceAttributes(wchar_t *pw, int tag_type) | |||
| return 0; | |||
| } | |||
| static void SetProsodyParameter(int param_type, wchar_t *attr1, PARAM_STACK *sp) | |||
| { | |||
| int value; | |||
| @@ -1570,7 +1526,6 @@ static void SetProsodyParameter(int param_type, wchar_t *attr1, PARAM_STACK *sp) | |||
| NULL, mnem_rate, mnem_volume, mnem_pitch, mnem_range | |||
| }; | |||
| if ((value = attrlookup(attr1, mnem_tabs[param_type])) >= 0) { | |||
| // mnemonic specifies a value as a percentage of the base pitch/range/rate/volume | |||
| sp->parameter[param_type] = (param_stack[0].parameter[param_type] * value)/100; | |||
| @@ -1589,7 +1544,6 @@ static void SetProsodyParameter(int param_type, wchar_t *attr1, PARAM_STACK *sp) | |||
| } | |||
| } | |||
| static int ReplaceKeyName(char *outbuf, int index, int *outix) | |||
| { | |||
| // Replace some key-names by single characters, so they can be pronounced in different languages | |||
| @@ -1615,7 +1569,6 @@ static int ReplaceKeyName(char *outbuf, int index, int *outix) | |||
| return 0; | |||
| } | |||
| static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outbuf, int self_closing) | |||
| { | |||
| // xml_buf is the tag and attributes with a zero terminator in place of the original '>' | |||
| @@ -1722,7 +1675,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| return 0; | |||
| } | |||
| voice_change_flag = 0; | |||
| terminator = CLAUSE_NONE; | |||
| ssml_sp = &ssml_stack[n_ssml_stack-1]; | |||
| @@ -1744,7 +1696,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| } | |||
| ProcessParamStack(outbuf, outix); | |||
| break; | |||
| case SSML_PROSODY: | |||
| sp = PushParamStack(tag_type); | |||
| @@ -1756,7 +1707,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| ProcessParamStack(outbuf, outix); | |||
| break; | |||
| case SSML_EMPHASIS: | |||
| sp = PushParamStack(tag_type); | |||
| value = 3; // default is "moderate" | |||
| @@ -1776,13 +1726,11 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| } | |||
| ProcessParamStack(outbuf, outix); | |||
| break; | |||
| case SSML_STYLE + SSML_CLOSE: | |||
| case SSML_PROSODY + SSML_CLOSE: | |||
| case SSML_EMPHASIS + SSML_CLOSE: | |||
| PopParamStack(tag_type, outbuf, outix); | |||
| break; | |||
| case SSML_PHONEME: | |||
| attr1 = GetSsmlAttribute(px, "alphabet"); | |||
| attr2 = GetSsmlAttribute(px, "ph"); | |||
| @@ -1795,7 +1743,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| outbuf[(*outix)++] = ']'; | |||
| } | |||
| break; | |||
| case SSML_SAYAS: | |||
| attr1 = GetSsmlAttribute(px, "interpret-as"); | |||
| attr2 = GetSsmlAttribute(px, "format"); | |||
| @@ -1821,7 +1768,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| sayas_start = *outix; | |||
| sayas_mode = value; // punctuation doesn't end clause during SAY-AS | |||
| break; | |||
| case SSML_SAYAS + SSML_CLOSE: | |||
| if (sayas_mode == SAYAS_KEY) { | |||
| outbuf[*outix] = 0; | |||
| @@ -1832,7 +1778,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| outbuf[(*outix)++] = 'Y'; | |||
| sayas_mode = 0; | |||
| break; | |||
| case SSML_SUB: | |||
| if ((attr1 = GetSsmlAttribute(px, "alias")) != NULL) { | |||
| // use the alias rather than the text | |||
| @@ -1840,16 +1785,13 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| *outix += attrcopy_utf8(&outbuf[*outix], attr1, n_outbuf-*outix); | |||
| } | |||
| break; | |||
| case SSML_IGNORE_TEXT: | |||
| ignore_text = 1; | |||
| break; | |||
| case SSML_SUB + SSML_CLOSE: | |||
| case SSML_IGNORE_TEXT + SSML_CLOSE: | |||
| ignore_text = 0; | |||
| break; | |||
| case SSML_MARK: | |||
| if ((attr1 = GetSsmlAttribute(px, "name")) != NULL) { | |||
| // add name to circular buffer of marker names | |||
| @@ -1869,7 +1811,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| } | |||
| } | |||
| break; | |||
| case SSML_AUDIO: | |||
| sp = PushParamStack(tag_type); | |||
| @@ -1908,12 +1849,10 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| else | |||
| audio_text = 1; | |||
| return CLAUSE_NONE; | |||
| case SSML_AUDIO + SSML_CLOSE: | |||
| PopParamStack(tag_type, outbuf, outix); | |||
| audio_text = 0; | |||
| return CLAUSE_NONE; | |||
| case SSML_BREAK: | |||
| value = 21; | |||
| terminator = CLAUSE_NONE; | |||
| @@ -1952,7 +1891,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| return terminator + value; | |||
| } | |||
| break; | |||
| case SSML_SPEAK: | |||
| if ((attr1 = GetSsmlAttribute(px, "xml:base")) != NULL) { | |||
| attrcopy_utf8(buf, attr1, sizeof(buf)); | |||
| @@ -1962,18 +1900,15 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| if (GetVoiceAttributes(px, tag_type) == 0) | |||
| return 0; // no voice change | |||
| return CLAUSE_VOICE; | |||
| case SSML_VOICE: | |||
| if (GetVoiceAttributes(px, tag_type) == 0) | |||
| return 0; // no voice change | |||
| return CLAUSE_VOICE; | |||
| case SSML_SPEAK + SSML_CLOSE: | |||
| // unwind stack until the previous <voice> or <speak> tag | |||
| while ((n_ssml_stack > 1) && (ssml_stack[n_ssml_stack-1].tag_type != SSML_SPEAK)) | |||
| n_ssml_stack--; | |||
| return CLAUSE_PERIOD + GetVoiceAttributes(px, tag_type); | |||
| case SSML_VOICE + SSML_CLOSE: | |||
| // unwind stack until the previous <voice> or <speak> tag | |||
| while ((n_ssml_stack > 1) && (ssml_stack[n_ssml_stack-1].tag_type != SSML_VOICE)) | |||
| @@ -1981,11 +1916,9 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| terminator = 0; // ?? Sentence intonation, but no pause ?? | |||
| return terminator + GetVoiceAttributes(px, tag_type); | |||
| case HTML_BREAK: | |||
| case HTML_BREAK + SSML_CLOSE: | |||
| return CLAUSE_COLON; | |||
| case SSML_SENTENCE: | |||
| if (ssml_sp->tag_type == SSML_SENTENCE) { | |||
| // new sentence implies end-of-sentence | |||
| @@ -1993,8 +1926,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| } | |||
| voice_change_flag |= GetVoiceAttributes(px, tag_type); | |||
| return CLAUSE_PARAGRAPH + voice_change_flag; | |||
| case SSML_PARAGRAPH: | |||
| if (ssml_sp->tag_type == SSML_SENTENCE) { | |||
| // new paragraph implies end-of-sentence or end-of-paragraph | |||
| @@ -2006,16 +1937,12 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| } | |||
| voice_change_flag |= GetVoiceAttributes(px, tag_type); | |||
| return CLAUSE_PARAGRAPH + voice_change_flag; | |||
| case SSML_SENTENCE + SSML_CLOSE: | |||
| if (ssml_sp->tag_type == SSML_SENTENCE) { | |||
| // end of a sentence which specified a language | |||
| voice_change_flag = GetVoiceAttributes(px, tag_type); | |||
| } | |||
| return CLAUSE_PERIOD + voice_change_flag; | |||
| case SSML_PARAGRAPH + SSML_CLOSE: | |||
| if ((ssml_sp->tag_type == SSML_SENTENCE) || (ssml_sp->tag_type == SSML_PARAGRAPH)) { | |||
| // End of a paragraph which specified a language. | |||
| @@ -2027,7 +1954,6 @@ static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outb | |||
| return 0; | |||
| } | |||
| static void RemoveChar(char *p) | |||
| { | |||
| // Replace a UTF-8 character by spaces | |||
| @@ -2036,7 +1962,6 @@ static void RemoveChar(char *p) | |||
| memset(p, ' ', utf8_in(&c, p)); | |||
| } | |||
| static MNEM_TAB xml_char_mnemonics[] = { | |||
| { "gt", '>' }, | |||
| { "lt", 0xe000 + '<' }, // private usage area, to avoid confusion with XML tag | |||
| @@ -2047,7 +1972,6 @@ static MNEM_TAB xml_char_mnemonics[] = { | |||
| { NULL, -1 } | |||
| }; | |||
| int ReadClause(Translator *tr, FILE *f_in, char *buf, short *charix, int *charix_top, int n_buf, int *tone_type, char *voice_change) | |||
| { | |||
| /* Find the end of the current clause. | |||
| @@ -2612,7 +2536,6 @@ int ReadClause(Translator *tr, FILE *f_in, char *buf, short *charix, int *charix | |||
| return CLAUSE_EOF; // end of file | |||
| } | |||
| void InitNamedata(void) | |||
| { | |||
| namedata_ix = 0; | |||
| @@ -2623,7 +2546,6 @@ void InitNamedata(void) | |||
| } | |||
| } | |||
| void InitText2(void) | |||
| { | |||
| int param; | |||
| @@ -37,7 +37,6 @@ extern int GetAmplitude(void); | |||
| extern void DoSonicSpeed(int value); | |||
| extern int saved_parameters[]; | |||
| // convert from words-per-minute to internal speed factor | |||
| // Use this to calibrate speed for wpm 80-350 | |||
| static unsigned char speed_lookup[] = { | |||
| @@ -99,7 +98,6 @@ static unsigned char speed_lookup[] = { | |||
| 9, 9, 8, 8, 8, // 355 | |||
| }; | |||
| // speed_factor1 adjustments for speeds 350 to 374: pauses | |||
| static unsigned char pause_factor_350[] = { | |||
| 22, 22, 22, 22, 22, 22, 22, 21, 21, 21, // 350 | |||
| @@ -137,8 +135,6 @@ static int speed1 = 130; | |||
| static int speed2 = 121; | |||
| static int speed3 = 118; | |||
| #if HAVE_SONIC_H | |||
| void SetSpeed(int control) | |||
| @@ -396,44 +392,35 @@ void SetParameter(int parameter, int value, int relative) | |||
| embedded_value[EMBED_S2] = new_value; | |||
| SetSpeed(3); | |||
| break; | |||
| case espeakVOLUME: | |||
| embedded_value[EMBED_A] = new_value; | |||
| GetAmplitude(); | |||
| break; | |||
| case espeakPITCH: | |||
| if (new_value > 99) new_value = 99; | |||
| if (new_value < 0) new_value = 0; | |||
| embedded_value[EMBED_P] = new_value; | |||
| break; | |||
| case espeakRANGE: | |||
| if (new_value > 99) new_value = 99; | |||
| embedded_value[EMBED_R] = new_value; | |||
| break; | |||
| case espeakLINELENGTH: | |||
| option_linelength = new_value; | |||
| break; | |||
| case espeakWORDGAP: | |||
| option_wordgap = new_value; | |||
| break; | |||
| case espeakINTONATION: | |||
| if ((new_value & 0xff) != 0) | |||
| translator->langopts.intonation_group = new_value & 0xff; | |||
| option_tone_flags = new_value; | |||
| break; | |||
| default: | |||
| break; | |||
| } | |||
| } | |||
| static void DoEmbedded2(int *embix) | |||
| { | |||
| // There were embedded commands in the text at this point | |||
| @@ -451,7 +438,6 @@ static void DoEmbedded2(int *embix) | |||
| } while ((word & 0x80) == 0); | |||
| } | |||
| void CalcLengths(Translator *tr) | |||
| { | |||
| int ix; | |||
| @@ -503,7 +489,6 @@ void CalcLengths(Translator *tr) | |||
| case phPAUSE: | |||
| last_pitch = 0; | |||
| break; | |||
| case phSTOP: | |||
| last_pitch = 0; | |||
| if (prev->type == phFRICATIVE) | |||
| @@ -525,7 +510,6 @@ void CalcLengths(Translator *tr) | |||
| if (p->synthflags & SFLAG_LENGTHEN) | |||
| p->prepause += tr->langopts.long_stop; | |||
| break; | |||
| case phVFRICATIVE: | |||
| case phFRICATIVE: | |||
| if (p->newword) { | |||
| @@ -558,7 +542,6 @@ void CalcLengths(Translator *tr) | |||
| p->length = (255 + prev->length)/2; | |||
| } | |||
| break; | |||
| case phVSTOP: | |||
| if (prev->type == phVFRICATIVE || prev->type == phFRICATIVE || (prev->ph->phflags & phSIBILANT) || (prev->type == phLIQUID)) | |||
| p->prepause = 30; | |||
| @@ -589,9 +572,7 @@ void CalcLengths(Translator *tr) | |||
| } | |||
| if ((tr->langopts.word_gap & 0x10) && (p->newword) && (p->prepause < 20)) | |||
| p->prepause = 20; | |||
| break; | |||
| case phLIQUID: | |||
| case phNASAL: | |||
| p->amp = tr->stress_amps[0]; // unless changed later | |||
| @@ -638,7 +619,6 @@ void CalcLengths(Translator *tr) | |||
| pre_voiced = 0; | |||
| } | |||
| break; | |||
| case phVOWEL: | |||
| min_drop = 0; | |||
| next2 = &phoneme_list[ix+2]; | |||
| @@ -740,7 +720,6 @@ void CalcLengths(Translator *tr) | |||
| } | |||
| } | |||
| if ((end_of_clause == 2) && !(tr->langopts.stress_flags & S_NO_EOC_LENGTHEN)) { | |||
| // this is the last syllable in the clause, lengthen it - more for short vowels | |||
| len = (p->ph->std_length * 2); | |||
| @@ -79,14 +79,12 @@ int (*phoneme_callback)(const char *) = NULL; | |||
| char path_home[N_PATH_HOME]; // this is the espeak-data directory | |||
| extern int saved_parameters[N_SPEECH_PARAM]; // Parameters saved on synthesis start | |||
| void WVoiceChanged(voice_t *wvoice) | |||
| { | |||
| // Voice change in wavegen | |||
| voice_samplerate = wvoice->samplerate; | |||
| } | |||
| #ifdef USE_ASYNC | |||
| static int dispatch_audio(short *outbuf, int length, espeak_EVENT *event) | |||
| @@ -150,13 +148,11 @@ static int dispatch_audio(short *outbuf, int length, espeak_EVENT *event) | |||
| a_wave_can_be_played = fifo_is_command_enabled(); | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| case AUDIO_OUTPUT_RETRIEVAL: | |||
| if (synth_callback) | |||
| synth_callback(outbuf, length, event); | |||
| break; | |||
| case AUDIO_OUTPUT_SYNCHRONOUS: | |||
| case AUDIO_OUTPUT_SYNCH_PLAYBACK: | |||
| break; | |||
| @@ -170,8 +166,6 @@ static int dispatch_audio(short *outbuf, int length, espeak_EVENT *event) | |||
| return a_wave_can_be_played == 0; // 1 = stop synthesis, -1 = error | |||
| } | |||
| static int create_events(short *outbuf, int length, espeak_EVENT *event, uint32_t the_write_pos) | |||
| { | |||
| int finished; | |||
| @@ -204,7 +198,6 @@ static int create_events(short *outbuf, int length, espeak_EVENT *event, uint32_ | |||
| return finished; | |||
| } | |||
| int sync_espeak_terminated_msg(uint32_t unique_identifier, void *user_data) | |||
| { | |||
| ENTER("sync_espeak_terminated_msg"); | |||
| @@ -237,7 +230,6 @@ int sync_espeak_terminated_msg(uint32_t unique_identifier, void *user_data) | |||
| #endif | |||
| static void select_output(espeak_AUDIO_OUTPUT output_type) | |||
| { | |||
| my_mode = output_type; | |||
| @@ -252,14 +244,11 @@ static void select_output(espeak_AUDIO_OUTPUT output_type) | |||
| // wave_init() is now called just before the first wave_write() | |||
| synchronous_mode = 0; | |||
| break; | |||
| case AUDIO_OUTPUT_RETRIEVAL: | |||
| synchronous_mode = 0; | |||
| break; | |||
| case AUDIO_OUTPUT_SYNCHRONOUS: | |||
| break; | |||
| case AUDIO_OUTPUT_SYNCH_PLAYBACK: | |||
| option_waveout = 0; | |||
| WavegenInitSound(); | |||
| @@ -267,9 +256,6 @@ static void select_output(espeak_AUDIO_OUTPUT output_type) | |||
| } | |||
| } | |||
| #pragma GCC visibility push(default) | |||
| int GetFileLength(const char *filename) | |||
| { | |||
| @@ -285,7 +271,6 @@ int GetFileLength(const char *filename) | |||
| } | |||
| #pragma GCC visibility pop | |||
| char *Alloc(int size) | |||
| { | |||
| char *p; | |||
| @@ -300,8 +285,6 @@ void Free(void *ptr) | |||
| free(ptr); | |||
| } | |||
| static void init_path(const char *path) | |||
| { | |||
| #ifdef PLATFORM_WINDOWS | |||
| @@ -329,7 +312,6 @@ static void init_path(const char *path) | |||
| RegQueryValueExA(RegKey, "path", 0, &var_type, buf, &size); | |||
| sprintf(path_home, "%s\\espeak-data", buf); | |||
| #else | |||
| char *env; | |||
| @@ -381,7 +363,6 @@ static int initialise(int control) | |||
| return 0; | |||
| } | |||
| static espeak_ERROR Synthesize(unsigned int unique_identifier, const void *text, int flags) | |||
| { | |||
| // Fill the buffer with output sound | |||
| @@ -511,7 +492,6 @@ static const char *label[] = { | |||
| }; | |||
| #endif | |||
| void MarkerEvent(int type, unsigned int char_position, int value, int value2, unsigned char *out_ptr) | |||
| { | |||
| // type: 1=word, 2=sentence, 3=named mark, 4=play audio, 5=end, 7=phoneme | |||
| @@ -551,14 +531,10 @@ void MarkerEvent(int type, unsigned int char_position, int value, int value2, un | |||
| ep->id.number = value; | |||
| } | |||
| espeak_ERROR sync_espeak_Synth(unsigned int unique_identifier, const void *text, size_t size, | |||
| unsigned int position, espeak_POSITION_TYPE position_type, | |||
| unsigned int end_position, unsigned int flags, void *user_data) | |||
| { | |||
| #ifdef DEBUG_ENABLED | |||
| ENTER("sync_espeak_Synth"); | |||
| SHOW("sync_espeak_Synth > position=%d, position_type=%d, end_position=%d, flags=%d, user_data=0x%x, text=%s\n", position, position_type, end_position, flags, user_data, text); | |||
| @@ -578,11 +554,9 @@ espeak_ERROR sync_espeak_Synth(unsigned int unique_identifier, const void *text, | |||
| case POS_CHARACTER: | |||
| skip_characters = position; | |||
| break; | |||
| case POS_WORD: | |||
| skip_words = position; | |||
| break; | |||
| case POS_SENTENCE: | |||
| skip_sentences = position; | |||
| break; | |||
| @@ -602,9 +576,6 @@ espeak_ERROR sync_espeak_Synth(unsigned int unique_identifier, const void *text, | |||
| return aStatus; | |||
| } | |||
| espeak_ERROR sync_espeak_Synth_Mark(unsigned int unique_identifier, const void *text, size_t size, | |||
| const char *index_mark, unsigned int end_position, | |||
| unsigned int flags, void *user_data) | |||
| @@ -623,15 +594,12 @@ espeak_ERROR sync_espeak_Synth_Mark(unsigned int unique_identifier, const void * | |||
| end_character_position = end_position; | |||
| aStatus = Synthesize(unique_identifier, text, flags | espeakSSML); | |||
| SHOW_TIME("LEAVE sync_espeak_Synth_Mark"); | |||
| return aStatus; | |||
| } | |||
| void sync_espeak_Key(const char *key) | |||
| { | |||
| // symbolic name, symbolicname_character - is there a system resource of symbolic names per language? | |||
| @@ -650,7 +618,6 @@ void sync_espeak_Key(const char *key) | |||
| Synthesize(0, key, 0); // speak key as a text string | |||
| } | |||
| void sync_espeak_Char(wchar_t character) | |||
| { | |||
| // is there a system resource of character names per language? | |||
| @@ -662,8 +629,6 @@ void sync_espeak_Char(wchar_t character) | |||
| Synthesize(0, buf, espeakSSML); | |||
| } | |||
| void sync_espeak_SetPunctuationList(const wchar_t *punctlist) | |||
| { | |||
| // Set the list of punctuation which are spoken for "some". | |||
| @@ -677,12 +642,8 @@ void sync_espeak_SetPunctuationList(const wchar_t *punctlist) | |||
| } | |||
| } | |||
| #pragma GCC visibility push(default) | |||
| ESPEAK_API void espeak_SetSynthCallback(t_espeak_callback *SynthCallback) | |||
| { | |||
| ENTER("espeak_SetSynthCallback"); | |||
| @@ -698,7 +659,6 @@ ESPEAK_API void espeak_SetUriCallback(int (*UriCallback)(int, const char *, cons | |||
| uri_callback = UriCallback; | |||
| } | |||
| ESPEAK_API void espeak_SetPhonemeCallback(int (*PhonemeCallback)(const char *)) | |||
| { | |||
| phoneme_callback = PhonemeCallback; | |||
| @@ -768,8 +728,6 @@ ESPEAK_API int espeak_Initialize(espeak_AUDIO_OUTPUT output_type, int buf_length | |||
| return samplerate; | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_Synth(const void *text, size_t size, | |||
| unsigned int position, | |||
| espeak_POSITION_TYPE position_type, | |||
| @@ -818,13 +776,10 @@ ESPEAK_API espeak_ERROR espeak_Synth(const void *text, size_t size, | |||
| delete_espeak_command(c1); | |||
| delete_espeak_command(c2); | |||
| } | |||
| #endif | |||
| return a_error; | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_Synth_Mark(const void *text, size_t size, | |||
| const char *index_mark, | |||
| unsigned int end_position, | |||
| @@ -843,7 +798,6 @@ ESPEAK_API espeak_ERROR espeak_Synth_Mark(const void *text, size_t size, | |||
| if (f_logespeak) | |||
| fprintf(f_logespeak, "\nSYNTH MARK %s posn %d flags 0x%x\n%s\n", index_mark, end_position, flags, (const char *)text); | |||
| if (unique_identifier == NULL) | |||
| unique_identifier = &temp_identifier; | |||
| *unique_identifier = 0; | |||
| @@ -874,13 +828,10 @@ ESPEAK_API espeak_ERROR espeak_Synth_Mark(const void *text, size_t size, | |||
| delete_espeak_command(c1); | |||
| delete_espeak_command(c2); | |||
| } | |||
| #endif | |||
| return a_error; | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_Key(const char *key) | |||
| { | |||
| ENTER("espeak_Key"); | |||
| @@ -901,12 +852,10 @@ ESPEAK_API espeak_ERROR espeak_Key(const char *key) | |||
| a_error = fifo_add_command(c); | |||
| if (a_error != EE_OK) | |||
| delete_espeak_command(c); | |||
| #endif | |||
| return a_error; | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_Char(wchar_t character) | |||
| { | |||
| ENTER("espeak_Char"); | |||
| @@ -934,7 +883,6 @@ ESPEAK_API espeak_ERROR espeak_Char(wchar_t character) | |||
| #endif | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_SetVoiceByName(const char *name) | |||
| { | |||
| ENTER("espeak_SetVoiceByName"); | |||
| @@ -942,8 +890,6 @@ ESPEAK_API espeak_ERROR espeak_SetVoiceByName(const char *name) | |||
| return SetVoiceByName(name); | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_SetVoiceByProperties(espeak_VOICE *voice_selector) | |||
| { | |||
| ENTER("espeak_SetVoiceByProperties"); | |||
| @@ -951,7 +897,6 @@ ESPEAK_API espeak_ERROR espeak_SetVoiceByProperties(espeak_VOICE *voice_selector | |||
| return SetVoiceByProperties(voice_selector); | |||
| } | |||
| ESPEAK_API int espeak_GetParameter(espeak_PARAMETER parameter, int current) | |||
| { | |||
| ENTER("espeak_GetParameter"); | |||
| @@ -961,7 +906,6 @@ ESPEAK_API int espeak_GetParameter(espeak_PARAMETER parameter, int current) | |||
| return param_defaults[parameter]; | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_SetParameter(espeak_PARAMETER parameter, int value, int relative) | |||
| { | |||
| ENTER("espeak_SetParameter"); | |||
| @@ -988,7 +932,6 @@ ESPEAK_API espeak_ERROR espeak_SetParameter(espeak_PARAMETER parameter, int valu | |||
| #endif | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_SetPunctuationList(const wchar_t *punctlist) | |||
| { | |||
| ENTER("espeak_SetPunctuationList"); | |||
| @@ -1013,7 +956,6 @@ ESPEAK_API espeak_ERROR espeak_SetPunctuationList(const wchar_t *punctlist) | |||
| #endif | |||
| } | |||
| ESPEAK_API void espeak_SetPhonemeTrace(int phonememode, FILE *stream) | |||
| { | |||
| ENTER("espeak_SetPhonemes"); | |||
| @@ -1033,10 +975,8 @@ ESPEAK_API void espeak_SetPhonemeTrace(int phonememode, FILE *stream) | |||
| f_trans = stream; | |||
| if (stream == NULL) | |||
| f_trans = stderr; | |||
| } | |||
| ESPEAK_API const char *espeak_TextToPhonemes(const void **textptr, int textmode, int phonememode) | |||
| { | |||
| /* phoneme_mode | |||
| @@ -1050,14 +990,12 @@ ESPEAK_API const char *espeak_TextToPhonemes(const void **textptr, int textmode, | |||
| return GetTranslatedPhonemeString(phonememode); | |||
| } | |||
| ESPEAK_API void espeak_CompileDictionary(const char *path, FILE *log, int flags) | |||
| { | |||
| ENTER("espeak_CompileDictionary"); | |||
| CompileDictionary(path, dictionary_name, log, NULL, flags); | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_Cancel(void) | |||
| { | |||
| #ifdef USE_ASYNC | |||
| @@ -1077,7 +1015,6 @@ ESPEAK_API espeak_ERROR espeak_Cancel(void) | |||
| return EE_OK; | |||
| } | |||
| ESPEAK_API int espeak_IsPlaying(void) | |||
| { | |||
| #ifdef USE_ASYNC | |||
| @@ -1090,7 +1027,6 @@ ESPEAK_API int espeak_IsPlaying(void) | |||
| #endif | |||
| } | |||
| ESPEAK_API espeak_ERROR espeak_Synchronize(void) | |||
| { | |||
| espeak_ERROR berr = err; | |||
| @@ -1104,7 +1040,6 @@ ESPEAK_API espeak_ERROR espeak_Synchronize(void) | |||
| return berr; | |||
| } | |||
| extern void FreePhData(void); | |||
| extern void FreeVoiceList(void); | |||
| @@ -1121,7 +1056,6 @@ ESPEAK_API espeak_ERROR espeak_Terminate(void) | |||
| wave_terminate(); | |||
| out_samplerate = 0; | |||
| } | |||
| #endif | |||
| Free(event_list); | |||
| event_list = NULL; | |||
| @@ -96,7 +96,6 @@ float polint(float xa[], float ya[], int n, float x) | |||
| return y; | |||
| } | |||
| static SpectFrame *SpectFrameCreate() | |||
| { | |||
| int ix; | |||
| @@ -138,8 +137,6 @@ static void SpectFrameDestroy(SpectFrame *frame) | |||
| free(frame); | |||
| } | |||
| int LoadFrame(SpectFrame *frame, FILE *stream, int file_format_type) | |||
| { | |||
| short ix; | |||
| @@ -199,8 +196,6 @@ int LoadFrame(SpectFrame *frame, FILE *stream, int file_format_type) | |||
| return 0; | |||
| } | |||
| double GetFrameRms(SpectFrame *frame, int seq_amplitude) | |||
| { | |||
| int h; | |||
| @@ -226,7 +221,6 @@ double GetFrameRms(SpectFrame *frame, int seq_amplitude) | |||
| return frame->rms; | |||
| } | |||
| SpectSeq *SpectSeqCreate() | |||
| { | |||
| SpectSeq *spect = malloc(sizeof(SpectSeq)); | |||
| @@ -263,7 +257,6 @@ void SpectSeqDestroy(SpectSeq *spect) | |||
| free(spect); | |||
| } | |||
| static float GetFrameLength(SpectSeq *spect, int frame) | |||
| { | |||
| int ix; | |||
| @@ -278,8 +271,6 @@ static float GetFrameLength(SpectSeq *spect, int frame) | |||
| return (spect->frames[ix]->time - spect->frames[frame]->time) * 1000.0 + adjust; | |||
| } | |||
| int LoadSpectSeq(SpectSeq *spect, const char *filename) | |||
| { | |||
| short n, temp; | |||
| @@ -360,7 +351,6 @@ int LoadSpectSeq(SpectSeq *spect, const char *filename) | |||
| frame_width = (int)((FRAME_WIDTH*spect->max_x)/MAX_DISPLAY_FREQ); | |||
| if (frame_width > FRAME_WIDTH) frame_width = FRAME_WIDTH; | |||
| // start times from zero | |||
| time_offset = spect->frames[0]->time; | |||
| for (ix = 0; ix < spect->numframes; ix++) | |||
| @@ -36,7 +36,6 @@ | |||
| #include "translate.h" | |||
| #include "voice.h" | |||
| #ifdef INCLUDE_MBROLA | |||
| extern int Read4Bytes(FILE *f); | |||
| @@ -69,11 +68,8 @@ PROCVI setNoError_MBR; | |||
| PROCIV getFreq_MBR; | |||
| PROCVF setVolumeRatio_MBR; | |||
| HINSTANCE hinstDllMBR = NULL; | |||
| BOOL load_MBR() | |||
| { | |||
| if (hinstDllMBR != NULL) | |||
| @@ -94,7 +90,6 @@ BOOL load_MBR() | |||
| return TRUE; | |||
| } | |||
| void unload_MBR() | |||
| { | |||
| if (hinstDllMBR) { | |||
| @@ -105,7 +100,6 @@ void unload_MBR() | |||
| #endif // windows | |||
| static MBROLA_TAB *mbrola_tab = NULL; | |||
| static int mbrola_control = 0; | |||
| static int mbr_name_prefix = 0; | |||
| @@ -190,7 +184,6 @@ espeak_ERROR LoadMbrolaTable(const char *mbrola_voice, const char *phtrans, int | |||
| return EE_OK; | |||
| } | |||
| static int GetMbrName(PHONEME_LIST *plist, PHONEME_TAB *ph, PHONEME_TAB *ph_prev, PHONEME_TAB *ph_next, int *name2, int *split, int *control) | |||
| { | |||
| // Look up a phoneme in the mbrola phoneme name translation table | |||
| @@ -267,7 +260,6 @@ static int GetMbrName(PHONEME_LIST *plist, PHONEME_TAB *ph, PHONEME_TAB *ph_prev | |||
| return mnem; | |||
| } | |||
| static char *WritePitch(int env, int pitch1, int pitch2, int split, int final) | |||
| { | |||
| // final=1: only give the final pitch value. | |||
| @@ -291,10 +283,8 @@ static char *WritePitch(int env, int pitch1, int pitch2, int split, int final) | |||
| output[0] = 0; | |||
| pitch_env = envelope_data[env]; | |||
| SetPitch2(voice, pitch1, pitch2, &pitch_base, &pitch_range); | |||
| env_split = (split * 128)/100; | |||
| if (env_split < 0) | |||
| env_split = 0-env_split; | |||
| @@ -324,7 +314,6 @@ static char *WritePitch(int env, int pitch1, int pitch2, int split, int final) | |||
| p1 = ((pitch_env[0]*pitch_range)>>8) + pitch_base; // Hz << 12 | |||
| p_end = ((pitch_env[127]*pitch_range)>>8) + pitch_base; | |||
| if (split >= 0) { | |||
| sprintf(buf, " 0 %d", p1/4096); | |||
| strcat(output, buf); | |||
| @@ -364,7 +353,6 @@ static char *WritePitch(int env, int pitch1, int pitch2, int split, int final) | |||
| return output; | |||
| } | |||
| int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbrola) | |||
| { | |||
| // Generate a mbrola pho file | |||
| @@ -479,7 +467,6 @@ int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbr | |||
| } | |||
| done = 1; | |||
| break; | |||
| case phSTOP: | |||
| released = 0; | |||
| if (next->type == phVOWEL) released = 1; | |||
| @@ -493,11 +480,9 @@ int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbr | |||
| len = (len * 1000)/samplerate; // convert to mS | |||
| len += PauseLength(p->prepause, 1); | |||
| break; | |||
| case phVSTOP: | |||
| len = (80 * speed.wav_factor)/256; | |||
| break; | |||
| case phFRICATIVE: | |||
| len = 0; | |||
| InterpretPhoneme(NULL, 0, p, &phdata, NULL); | |||
| @@ -507,7 +492,6 @@ int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbr | |||
| len = (len * 1000)/samplerate; // convert to mS | |||
| break; | |||
| case phNASAL: | |||
| if (next->type != phVOWEL) { | |||
| memset(&fmtp, 0, sizeof(fmtp)); | |||
| @@ -520,7 +504,6 @@ int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbr | |||
| final_pitch = WritePitch(p->env, p->pitch1, p->pitch2, 0, 1); | |||
| } | |||
| break; | |||
| case phLIQUID: | |||
| if (next->type == phPAUSE) { | |||
| len += 50; | |||
| @@ -572,7 +555,6 @@ int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbr | |||
| return 0; | |||
| } | |||
| int MbrolaGenerate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| { | |||
| FILE *f_mbrola = NULL; | |||
| @@ -591,7 +573,6 @@ int MbrolaGenerate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| return again; | |||
| } | |||
| int MbrolaFill(int length, int resume, int amplitude) | |||
| { | |||
| // Read audio data from Mbrola (length is in millisecs) | |||
| @@ -628,7 +609,6 @@ int MbrolaFill(int length, int resume, int amplitude) | |||
| return n_samples ? 1 : 0; | |||
| } | |||
| void MbrolaReset(void) | |||
| { | |||
| // Reset the Mbrola engine and flush the pending audio | |||
| @@ -659,5 +639,4 @@ void MbrolaReset(void) | |||
| { | |||
| } | |||
| #endif // INCLUDE_MBROLA | |||
| @@ -29,7 +29,6 @@ | |||
| #include <stdint.h> | |||
| #endif | |||
| #include "speak_lib.h" | |||
| #include "speech.h" | |||
| #include "phoneme.h" | |||
| @@ -72,8 +71,6 @@ int vowel_transition1; | |||
| int FormantTransition2(frameref_t *seq, int *n_frames, unsigned int data1, unsigned int data2, PHONEME_TAB *other_ph, int which); | |||
| static char *ReadPhFile(void *ptr, const char *fname, int *size) | |||
| { | |||
| FILE *f_in; | |||
| @@ -108,7 +105,6 @@ static char *ReadPhFile(void *ptr, const char *fname, int *size) | |||
| return p; | |||
| } | |||
| int LoadPhData(int *srate) | |||
| { | |||
| int ix; | |||
| @@ -168,7 +164,6 @@ int LoadPhData(int *srate) | |||
| return result; | |||
| } | |||
| void FreePhData(void) | |||
| { | |||
| Free(phoneme_tab_data); | |||
| @@ -181,7 +176,6 @@ void FreePhData(void) | |||
| tunes = NULL; | |||
| } | |||
| int PhonemeCode(unsigned int mnem) | |||
| { | |||
| int ix; | |||
| @@ -195,7 +189,6 @@ int PhonemeCode(unsigned int mnem) | |||
| return 0; | |||
| } | |||
| int LookupPhonemeString(const char *string) | |||
| { | |||
| int ix; | |||
| @@ -213,9 +206,6 @@ int LookupPhonemeString(const char *string) | |||
| return PhonemeCode(mnem); | |||
| } | |||
| frameref_t *LookupSpect(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params, int *n_frames, PHONEME_LIST *plist) | |||
| { | |||
| int ix; | |||
| @@ -235,7 +225,6 @@ frameref_t *LookupSpect(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params, | |||
| seqk = (SPECT_SEQK *)seq; | |||
| nf = seq->n_frames; | |||
| if (nf >= N_SEQ_FRAMES) | |||
| nf = N_SEQ_FRAMES - 1; | |||
| @@ -342,8 +331,6 @@ frameref_t *LookupSpect(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params, | |||
| return frames; | |||
| } | |||
| unsigned char *GetEnvelope(int index) | |||
| { | |||
| if (index == 0) { | |||
| @@ -353,7 +340,6 @@ unsigned char *GetEnvelope(int index) | |||
| return (unsigned char *)&phondata_ptr[index]; | |||
| } | |||
| static void SetUpPhonemeTable(int number, int recursing) | |||
| { | |||
| int ix; | |||
| @@ -382,7 +368,6 @@ static void SetUpPhonemeTable(int number, int recursing) | |||
| } | |||
| } | |||
| void SelectPhonemeTable(int number) | |||
| { | |||
| n_phoneme_tab = 0; | |||
| @@ -391,7 +376,6 @@ void SelectPhonemeTable(int number) | |||
| current_phoneme_table = number; | |||
| } | |||
| int LookupPhonemeTable(const char *name) | |||
| { | |||
| int ix; | |||
| @@ -408,7 +392,6 @@ int LookupPhonemeTable(const char *name) | |||
| return ix; | |||
| } | |||
| int SelectPhonemeTableName(const char *name) | |||
| { | |||
| // Look up a phoneme set by name, and select it if it exists | |||
| @@ -422,9 +405,6 @@ int SelectPhonemeTableName(const char *name) | |||
| return ix; | |||
| } | |||
| void LoadConfig(void) | |||
| { | |||
| // Load configuration file, if one exists | |||
| @@ -473,18 +453,13 @@ void LoadConfig(void) | |||
| fclose(f); | |||
| } | |||
| PHONEME_DATA this_ph_data; | |||
| static void InvalidInstn(PHONEME_TAB *ph, int instn) | |||
| { | |||
| fprintf(stderr, "Invalid instruction %.4x for phoneme '%s'\n", instn, WordToString(ph->mnemonic)); | |||
| } | |||
| static bool StressCondition(Translator *tr, PHONEME_LIST *plist, int condition, int control) | |||
| { | |||
| // condition: | |||
| @@ -533,7 +508,6 @@ static bool StressCondition(Translator *tr, PHONEME_LIST *plist, int condition, | |||
| } | |||
| static int CountVowelPosition(PHONEME_LIST *plist) | |||
| { | |||
| int count = 0; | |||
| @@ -548,7 +522,6 @@ static int CountVowelPosition(PHONEME_LIST *plist) | |||
| return count; | |||
| } | |||
| static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, USHORT *p_prog, WORD_PH_DATA *worddata) | |||
| { | |||
| int which; | |||
| @@ -599,7 +572,6 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| return false; | |||
| } | |||
| switch (which) | |||
| { | |||
| case 0: // prevPh | |||
| @@ -607,20 +579,16 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| plist--; | |||
| check_endtype = 1; | |||
| break; | |||
| case 1: // thisPh | |||
| break; | |||
| case 2: // nextPh | |||
| case 4: // nextPhW | |||
| plist++; | |||
| break; | |||
| case 3: // next2Ph | |||
| case 6: // next2PhW | |||
| plist += 2; | |||
| break; | |||
| case 7: | |||
| // nextVowel, not word boundary | |||
| for (which = 1;; which++) { | |||
| @@ -632,14 +600,12 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| } | |||
| } | |||
| break; | |||
| case 8: // prevVowel in this word | |||
| if ((worddata == NULL) || (worddata->prev_vowel.ph == NULL)) | |||
| return false; // no previous vowel | |||
| plist = &(worddata->prev_vowel); | |||
| check_endtype = 1; | |||
| break; | |||
| case 9: // next3PhW | |||
| for (ix = 1; ix <= 3; ix++) { | |||
| if (plist[ix].sourceix) | |||
| @@ -647,7 +613,6 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| } | |||
| plist = &plist[3]; | |||
| break; | |||
| case 10: // prev2PhW | |||
| if ((plist[0].sourceix) || (plist[-1].sourceix)) | |||
| return false; | |||
| @@ -688,17 +653,14 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| // phoneme type, vowel, nasal, fricative, etc | |||
| return ph->type == data; | |||
| break; | |||
| case 0x20: | |||
| // place of articulation | |||
| return ((ph->phflags >> 16) & 0xf) == data; | |||
| break; | |||
| case 0x40: | |||
| // is a bit set in phoneme flags | |||
| return (ph->phflags & (1 << data)) != 0; | |||
| break; | |||
| case 0x80: | |||
| switch (data) | |||
| { | |||
| @@ -708,20 +670,15 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| case 3: | |||
| case 4: | |||
| return StressCondition(tr, plist, data, 0); | |||
| case 5: // isBreak, Either pause phoneme, or (stop/vstop/vfric not followed by vowel or (liquid in same word)) | |||
| return (ph->type == phPAUSE) || (plist_this->synthflags & SFLAG_NEXT_PAUSE); | |||
| case 6: // isWordStart | |||
| return plist->sourceix != 0; | |||
| case 7: // notWordStart | |||
| return plist->sourceix == 0; | |||
| case 8: // isWordEnd | |||
| return plist[1].sourceix || (plist[1].ph->type == phPAUSE); | |||
| break; | |||
| case 9: // isAfterStress | |||
| if (plist->sourceix != 0) | |||
| return false; | |||
| @@ -732,10 +689,8 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| } while (plist->sourceix == 0); | |||
| break; | |||
| case 10: // isNotVowel | |||
| return ph->type != phVOWEL; | |||
| case 11: // isFinalVowel | |||
| for (;;) { | |||
| plist++; | |||
| @@ -746,16 +701,12 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| return false; | |||
| } | |||
| break; | |||
| case 12: // isVoiced | |||
| return (ph->type == phVOWEL) || (ph->type == phLIQUID) || (ph->phflags & phVOICED); | |||
| case 13: // isFirstVowel | |||
| return CountVowelPosition(plist) == 1; | |||
| case 14: // isSecondVowel | |||
| return CountVowelPosition(plist) == 2; | |||
| case 15: // isSeqFlag1 | |||
| // is this preceded by a sequence if 1 or more vowels which have 'flag1' ? (lang=hi) | |||
| if (plist->sourceix != 0) | |||
| @@ -774,7 +725,6 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| break; | |||
| } | |||
| return count > 0; | |||
| case 0x10: // isTranslationGiven | |||
| return (plist->synthflags & SFLAG_DICTIONARY) != 0; | |||
| } | |||
| @@ -797,7 +747,6 @@ static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, | |||
| return false; | |||
| } | |||
| static void SwitchOnVowelType(PHONEME_LIST *plist, PHONEME_DATA *phdata, USHORT **p_prog, int instn_type) | |||
| { | |||
| USHORT *prog; | |||
| @@ -821,7 +770,6 @@ static void SwitchOnVowelType(PHONEME_LIST *plist, PHONEME_DATA *phdata, USHORT | |||
| *p_prog += 12; | |||
| } | |||
| int NumInstnWords(USHORT *prog) | |||
| { | |||
| int instn; | |||
| @@ -844,20 +792,17 @@ int NumInstnWords(USHORT *prog) | |||
| return n+1; | |||
| } | |||
| return 1; | |||
| case 6: | |||
| type2 = (instn & 0xf00) >> 9; | |||
| if ((type2 == 5) || (type2 == 6)) | |||
| return 12; // switch on vowel type | |||
| return 1; | |||
| case 2: | |||
| case 3: | |||
| // a condition, check for a 2-word instruction | |||
| if (((n = instn & 0x0f00) == 0x600) || (n == 0x0d00)) | |||
| return 2; | |||
| return 1; | |||
| default: | |||
| // instn_type 11 to 15, 2 words | |||
| instn2 = prog[2]; | |||
| @@ -871,8 +816,6 @@ int NumInstnWords(USHORT *prog) | |||
| } | |||
| } | |||
| void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_DATA *phdata, WORD_PH_DATA *worddata) | |||
| { | |||
| // control: | |||
| @@ -963,7 +906,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| } else | |||
| InvalidInstn(ph, instn); | |||
| break; | |||
| case 1: | |||
| if (tr == NULL) | |||
| break; // ignore if in synthesis stage | |||
| @@ -976,7 +918,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| } | |||
| } | |||
| break; | |||
| case 2: | |||
| case 3: | |||
| // conditions | |||
| @@ -1011,7 +952,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| } | |||
| prog--; | |||
| break; | |||
| case 6: | |||
| // JUMP | |||
| switch (instn2 >> 1) | |||
| @@ -1033,7 +973,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| break; | |||
| } | |||
| break; | |||
| case 9: | |||
| data = ((instn & 0xf) << 16) + prog[1]; | |||
| prog++; | |||
| @@ -1046,19 +985,16 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| prog = &phoneme_index[data] - 1; | |||
| } | |||
| break; | |||
| case 2: | |||
| // pitch envelope | |||
| phdata->pitch_env = data; | |||
| break; | |||
| case 3: | |||
| // amplitude envelope | |||
| phdata->amp_env = data; | |||
| break; | |||
| } | |||
| break; | |||
| case 10: // Vowelin, Vowelout | |||
| if (instn2 == 1) | |||
| ix = 0; | |||
| @@ -1069,7 +1005,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| phdata->vowel_transition[ix+1] = (prog[2] << 16) + prog[3]; | |||
| prog += 3; | |||
| break; | |||
| case 11: // FMT | |||
| case 12: // WAV | |||
| case 13: // VowelStart | |||
| @@ -1099,7 +1034,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| } | |||
| } | |||
| break; | |||
| default: | |||
| InvalidInstn(ph, instn); | |||
| break; | |||
| @@ -1128,7 +1062,6 @@ void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_ | |||
| } | |||
| } | |||
| void InterpretPhoneme2(int phcode, PHONEME_DATA *phdata) | |||
| { | |||
| // Examine the program of a single isolated phoneme | |||
| @@ -36,11 +36,9 @@ | |||
| #include "voice.h" | |||
| #include "translate.h" | |||
| extern FILE *f_log; | |||
| static void SmoothSpect(void); | |||
| // list of phonemes in a clause | |||
| int n_phoneme_list = 0; | |||
| PHONEME_LIST phoneme_list[N_PHONEME_LIST+1]; | |||
| @@ -73,12 +71,9 @@ SOUND_ICON soundicon_tab[N_SOUNDICON_TAB]; | |||
| #define VOWEL_FRONT_LENGTH 50 | |||
| // a dummy phoneme_list entry which looks like a pause | |||
| static PHONEME_LIST next_pause; | |||
| const char *WordToString(unsigned int word) | |||
| { | |||
| // Convert a phoneme mnemonic word into a string | |||
| @@ -91,8 +86,6 @@ const char *WordToString(unsigned int word) | |||
| return buf; | |||
| } | |||
| void SynthesizeInit() | |||
| { | |||
| last_pitch_cmd = 0; | |||
| @@ -105,8 +98,6 @@ void SynthesizeInit() | |||
| next_pause.newword = 0; | |||
| } | |||
| static void EndAmplitude(void) | |||
| { | |||
| if (amp_length > 0) { | |||
| @@ -116,8 +107,6 @@ static void EndAmplitude(void) | |||
| } | |||
| } | |||
| static void EndPitch(int voice_break) | |||
| { | |||
| // posssible end of pitch envelope, fill in the length | |||
| @@ -137,8 +126,6 @@ static void EndPitch(int voice_break) | |||
| } | |||
| } | |||
| static void DoAmplitude(int amp, unsigned char *amp_env) | |||
| { | |||
| intptr_t *q; | |||
| @@ -154,8 +141,6 @@ static void DoAmplitude(int amp, unsigned char *amp_env) | |||
| WcmdqInc(); | |||
| } | |||
| static void DoPitch(unsigned char *env, int pitch1, int pitch2) | |||
| { | |||
| intptr_t *q; | |||
| @@ -182,8 +167,6 @@ static void DoPitch(unsigned char *env, int pitch1, int pitch2) | |||
| WcmdqInc(); | |||
| } | |||
| int PauseLength(int pause, int control) | |||
| { | |||
| unsigned int len; | |||
| @@ -202,7 +185,6 @@ int PauseLength(int pause, int control) | |||
| return len; | |||
| } | |||
| static void DoPause(int length, int control) | |||
| { | |||
| // length in nominal mS | |||
| @@ -236,10 +218,8 @@ static void DoPause(int length, int control) | |||
| } | |||
| } | |||
| extern int seq_len_adjust; // temporary fix to advance the start point for playing the wav sample | |||
| static int DoSample2(int index, int which, int std_length, int control, int length_mod, int amp) | |||
| { | |||
| int length; | |||
| @@ -337,7 +317,6 @@ static int DoSample2(int index, int which, int std_length, int control, int leng | |||
| q[3] = wav_scale + (amp << 8); | |||
| WcmdqInc(); | |||
| while (length > len4*3) { | |||
| x = len4; | |||
| if (wav_scale == 0) | |||
| @@ -370,8 +349,6 @@ static int DoSample2(int index, int which, int std_length, int control, int leng | |||
| return length; | |||
| } | |||
| int DoSample3(PHONEME_DATA *phdata, int length_mod, int amp) | |||
| { | |||
| int amp2; | |||
| @@ -398,9 +375,6 @@ int DoSample3(PHONEME_DATA *phdata, int length_mod, int amp) | |||
| return len; | |||
| } | |||
| static frame_t *AllocFrame() | |||
| { | |||
| // Allocate a temporary spectrum frame for the wavegen queue. Use a pool which is big | |||
| @@ -417,7 +391,6 @@ static frame_t *AllocFrame() | |||
| return &frame_pool[ix]; | |||
| } | |||
| static void set_frame_rms(frame_t *fr, int new_rms) | |||
| { | |||
| // Each frame includes its RMS amplitude value, so to set a new | |||
| @@ -461,8 +434,6 @@ static void set_frame_rms(frame_t *fr, int new_rms) | |||
| } | |||
| } | |||
| static void formants_reduce_hf(frame_t *fr, int level) | |||
| { | |||
| // change height of peaks 2 to 8, percentage | |||
| @@ -478,7 +449,6 @@ static void formants_reduce_hf(frame_t *fr, int level) | |||
| } | |||
| } | |||
| static frame_t *CopyFrame(frame_t *frame1, int copy) | |||
| { | |||
| // create a copy of the specified frame in temporary buffer | |||
| @@ -498,7 +468,6 @@ static frame_t *CopyFrame(frame_t *frame1, int copy) | |||
| return frame2; | |||
| } | |||
| static frame_t *DuplicateLastFrame(frameref_t *seq, int n_frames, int length) | |||
| { | |||
| frame_t *fr; | |||
| @@ -510,7 +479,6 @@ static frame_t *DuplicateLastFrame(frameref_t *seq, int n_frames, int length) | |||
| return fr; | |||
| } | |||
| static void AdjustFormants(frame_t *fr, int target, int min, int max, int f1_adj, int f3_adj, int hf_reduce, int flags) | |||
| { | |||
| int x; | |||
| @@ -551,7 +519,6 @@ static void AdjustFormants(frame_t *fr, int target, int min, int max, int f1_adj | |||
| formants_reduce_hf(fr, hf_reduce); | |||
| } | |||
| static int VowelCloseness(frame_t *fr) | |||
| { | |||
| // return a value 0-3 depending on the vowel's f1 | |||
| @@ -566,7 +533,6 @@ static int VowelCloseness(frame_t *fr) | |||
| return 0; | |||
| } | |||
| int FormantTransition2(frameref_t *seq, int *n_frames, unsigned int data1, unsigned int data2, PHONEME_TAB *other_ph, int which) | |||
| { | |||
| int ix; | |||
| @@ -694,8 +660,6 @@ int FormantTransition2(frameref_t *seq, int *n_frames, unsigned int data1, unsig | |||
| return 0; | |||
| } | |||
| static void SmoothSpect(void) | |||
| { | |||
| // Limit the rate of frequence change of formants, to reduce chirping | |||
| @@ -806,7 +770,6 @@ static void SmoothSpect(void) | |||
| break; | |||
| if (q[0] <= WCMD_SPECT2) { | |||
| len = q[1] & 0xffff; | |||
| frame1 = (frame_t *)q[2]; | |||
| @@ -867,7 +830,6 @@ static void SmoothSpect(void) | |||
| syllable_start = syllable_end; | |||
| } | |||
| static void StartSyllable(void) | |||
| { | |||
| // start of syllable, if not already started | |||
| @@ -875,8 +837,6 @@ static void StartSyllable(void) | |||
| syllable_end = wcmdq_tail; | |||
| } | |||
| int DoSpect2(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params, PHONEME_LIST *plist, int modulation) | |||
| { | |||
| // which: 0 not a vowel, 1 start of vowel, 2 body and end of vowel | |||
| @@ -1058,13 +1018,9 @@ int DoSpect2(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params, PHONEME_L | |||
| WcmdqInc(); | |||
| } | |||
| return total_len; | |||
| } | |||
| void DoMarker(int type, int char_posn, int length, int value) | |||
| { | |||
| // This could be used to return an index to the word currently being spoken | |||
| @@ -1077,7 +1033,6 @@ void DoMarker(int type, int char_posn, int length, int value) | |||
| } | |||
| } | |||
| void DoPhonemeMarker(int type, int char_posn, int length, char *name) | |||
| { | |||
| // This could be used to return an index to the word currently being spoken | |||
| @@ -1094,7 +1049,6 @@ void DoPhonemeMarker(int type, int char_posn, int length, char *name) | |||
| } | |||
| } | |||
| #if HAVE_SONIC_H | |||
| void DoSonicSpeed(int value) | |||
| { | |||
| @@ -1105,7 +1059,6 @@ void DoSonicSpeed(int value) | |||
| } | |||
| #endif | |||
| void DoVoiceChange(voice_t *v) | |||
| { | |||
| // allocate memory for a copy of the voice data, and free it in wavegenfill() | |||
| @@ -1118,7 +1071,6 @@ void DoVoiceChange(voice_t *v) | |||
| WcmdqInc(); | |||
| } | |||
| void DoEmbedded(int *embix, int sourceix) | |||
| { | |||
| // There were embedded commands in the text at this point | |||
| @@ -1142,7 +1094,6 @@ void DoEmbedded(int *embix, int sourceix) | |||
| SetEmbedded((command & 0x60) + EMBED_S2, value); // adjusts embedded_value[EMBED_S2] | |||
| SetSpeed(2); | |||
| break; | |||
| case EMBED_I: // play dynamically loaded wav data (sound icon) | |||
| if ((int)value < n_soundicon_tab) { | |||
| if (soundicon_tab[value].length != 0) { | |||
| @@ -1155,15 +1106,12 @@ void DoEmbedded(int *embix, int sourceix) | |||
| } | |||
| } | |||
| break; | |||
| case EMBED_M: // named marker | |||
| DoMarker(espeakEVENT_MARK, (sourceix & 0x7ff) + clause_start_char, 0, value); | |||
| break; | |||
| case EMBED_U: // play sound | |||
| DoMarker(espeakEVENT_PLAY, count_characters+1, 0, value); // always occurs at end of clause | |||
| break; | |||
| default: | |||
| DoPause(10, 0); // ensure a break in the speech | |||
| wcmdq[wcmdq_tail][0] = WCMD_EMBEDDED; | |||
| @@ -1175,8 +1123,6 @@ void DoEmbedded(int *embix, int sourceix) | |||
| } while ((word & 0x80) == 0); | |||
| } | |||
| int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| { | |||
| static int ix; | |||
| @@ -1291,7 +1237,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| DoPause(p->length, 0); | |||
| p->std_length = p->ph->std_length; | |||
| break; | |||
| case phSTOP: | |||
| released = 0; | |||
| ph = p->ph; | |||
| @@ -1322,7 +1267,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| phdata.pd_control |= pd_DONTLENGTHEN; | |||
| DoSample3(&phdata, 0, 0); | |||
| break; | |||
| case phFRICATIVE: | |||
| InterpretPhoneme(NULL, 0, p, &phdata, &worddata); | |||
| @@ -1330,7 +1274,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| DoSample3(&phdata, p->length, 0); // play it twice for [s:] etc. | |||
| DoSample3(&phdata, p->length, 0); | |||
| break; | |||
| case phVSTOP: | |||
| ph = p->ph; | |||
| memset(&fmtp, 0, sizeof(fmtp)); | |||
| @@ -1387,7 +1330,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| DoPause(12, 0); | |||
| } | |||
| break; | |||
| case phVFRICATIVE: | |||
| if (next->type == phVOWEL) { | |||
| DoAmplitude(p->amp, NULL); | |||
| @@ -1418,7 +1360,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| DoSpect2(p->ph, 0, &fmtp, p, 0); | |||
| DoSpect2(p->ph, 0, &fmtp, p, 0); | |||
| break; | |||
| case phNASAL: | |||
| memset(&fmtp, 0, sizeof(fmtp)); | |||
| if (!(p->synthflags & SFLAG_SEQCONTINUE)) { | |||
| @@ -1446,7 +1387,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| } | |||
| break; | |||
| case phLIQUID: | |||
| memset(&fmtp, 0, sizeof(fmtp)); | |||
| modulation = 0; | |||
| @@ -1473,9 +1413,7 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| fmtp.wav_addr = phdata.sound_addr[pd_ADDWAV]; | |||
| fmtp.wav_amp = phdata.sound_param[pd_ADDWAV]; | |||
| DoSpect2(p->ph, 0, &fmtp, p, modulation); | |||
| break; | |||
| case phVOWEL: | |||
| ph = p->ph; | |||
| stress = p->stresslevel & 0xf; | |||
| @@ -1576,7 +1514,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| } | |||
| DoSpect2(ph, 2, &fmtp, p, modulation); | |||
| break; | |||
| } | |||
| ix++; | |||
| @@ -1590,9 +1527,6 @@ int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume) | |||
| return 0; // finished the phoneme list | |||
| } | |||
| static int timer_on = 0; | |||
| static int paused = 0; | |||
| @@ -1612,14 +1546,11 @@ int SynthOnTimer() | |||
| return 0; | |||
| } | |||
| int SynthStatus() | |||
| { | |||
| return timer_on | paused; | |||
| } | |||
| int SpeakNextClause(FILE *f_in, const void *text_in, int control) | |||
| { | |||
| // Speak text from file (f_in) or memory (text_in) | |||
| @@ -37,8 +37,6 @@ | |||
| #include "synthesize.h" | |||
| #include "translate.h" | |||
| #define L_qa 0x716100 | |||
| #define L_grc 0x677263 // grc Ancient Greek | |||
| #define L_jbo 0x6a626f // jbo Lojban | |||
| @@ -74,7 +72,6 @@ | |||
| #define OFFSET_KOREAN 0x1100 | |||
| #define OFFSET_ETHIOPIC 0x1200 | |||
| // character ranges must be listed in ascending unicode order | |||
| ALPHABET alphabets[] = { | |||
| { "_el", OFFSET_GREEK, 0x380, 0x3ff, L('e', 'l'), AL_DONT_NAME | AL_NOT_LETTERS | AL_WORDS }, | |||
| @@ -108,7 +105,6 @@ ALPHABET alphabets[] = { | |||
| { NULL, 0, 0, 0, 0, 0 } | |||
| }; | |||
| ALPHABET *AlphabetFromName(const char *name) | |||
| { | |||
| ALPHABET *alphabet; | |||
| @@ -120,7 +116,6 @@ ALPHABET *AlphabetFromName(const char *name) | |||
| return NULL; | |||
| } | |||
| ALPHABET *AlphabetFromChar(int c) | |||
| { | |||
| // Find the alphabet from a character. | |||
| @@ -138,12 +133,8 @@ ALPHABET *AlphabetFromChar(int c) | |||
| return NULL; | |||
| } | |||
| static void Translator_Russian(Translator *tr); | |||
| static void SetLetterVowel(Translator *tr, int c) | |||
| { | |||
| tr->letter_bits[c] = (tr->letter_bits[c] & 0x40) | 0x81; // keep value for group 6 (front vowels e,i,y) | |||
| @@ -200,7 +191,6 @@ static const unsigned short chars_ignore_zwnj_hyphen[] = { | |||
| const char string_ordinal[] = { 0xc2, 0xba, 0 }; // masculine ordinal character, UTF-8 | |||
| static Translator *NewTranslator(void) | |||
| { | |||
| Translator *tr; | |||
| @@ -268,7 +258,6 @@ static Translator *NewTranslator(void) | |||
| SetLetterBits(tr, 6, "eiy"); // Letter group Y, front vowels | |||
| SetLetterBits(tr, 7, "aeiouy"); // vowels, including y | |||
| tr->char_plus_apostrophe = empty_wstring; | |||
| tr->punct_within_word = punct_in_word; | |||
| tr->chars_ignore = chars_ignore_default; | |||
| @@ -350,8 +339,6 @@ static const short pairs_ru[] = { | |||
| 0x7fff | |||
| }; | |||
| static const unsigned int replace_cyrillic_latin[] = | |||
| { 0x430, 'a', | |||
| 0x431, 'b', | |||
| @@ -388,7 +375,6 @@ static const unsigned int replace_cyrillic_latin[] = | |||
| 0x45c, 0x107, | |||
| 0 }; // ѓ ѕ ќ | |||
| static const unsigned char ru_vowels[] = { 0x10, 0x15, 0x31, 0x18, 0x1e, 0x23, 0x2b, 0x2d, 0x2e, 0x2f, 0xb9, 0xc9, 0x91, 0x8f, 0x36, 0 }; // also kazakh | |||
| static const unsigned char ru_consonants[] = { 0x11, 0x12, 0x13, 0x14, 0x16, 0x17, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1f, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2c, 0x73, 0x7b, 0x83, 0x9b, 0 }; | |||
| @@ -418,7 +404,6 @@ static void SetCyrillicLetters(Translator *tr) | |||
| SetLetterBits(tr, LETTERGP_VOWEL2, (char *)ru_vowels); | |||
| } | |||
| void SetIndicLetters(Translator *tr) | |||
| { | |||
| // Set letter types for Indic scripts, Devanagari, Tamill, etc | |||
| @@ -444,7 +429,6 @@ void SetIndicLetters(Translator *tr) | |||
| tr->langopts.suffix_add_e = tr->letter_bits_offset + 0x4d; // virama | |||
| } | |||
| void SetupTranslator(Translator *tr, const short *lengths, const unsigned char *amps) | |||
| { | |||
| if (lengths != NULL) | |||
| @@ -453,7 +437,6 @@ void SetupTranslator(Translator *tr, const short *lengths, const unsigned char * | |||
| memcpy(tr->stress_amps, amps, sizeof(tr->stress_amps)); | |||
| } | |||
| Translator *SelectTranslator(const char *name) | |||
| { | |||
| int name2 = 0; | |||
| @@ -495,8 +478,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_SWAP_TENS | NUM_HUNDRED_AND | NUM_SINGLE_AND | NUM_ROMAN | NUM_1900; | |||
| tr->langopts.accents = 1; | |||
| } | |||
| break; | |||
| break; | |||
| case L('a', 'm'): // Amharic, Ethiopia | |||
| { | |||
| SetupTranslator(tr, stress_lengths_fr, stress_amps_fr); | |||
| @@ -507,11 +489,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1; // disable check for unpronouncable words | |||
| tr->langopts.numbers = NUM_OMIT_1_HUNDRED; | |||
| } | |||
| break; | |||
| break; | |||
| case L('a', 'r'): // Arabic | |||
| tr->transpose_min = 0x620; // for ar_list, use 6-bit character codes | |||
| tr->transpose_max = 0x65f; | |||
| @@ -520,7 +498,6 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_SWAP_TENS | NUM_AND_UNITS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_AND_HUNDRED | NUM_THOUSAND_AND | NUM_OMIT_1_THOUSAND; | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1; // disable check for unpronouncable words | |||
| break; | |||
| case L('b', 'g'): // Bulgarian | |||
| { | |||
| SetCyrillicLetters(tr); | |||
| @@ -533,8 +510,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_OMIT_1_HUNDRED | NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_SINGLE_AND | NUM_ROMAN | NUM_ROMAN_ORDINAL | NUM_ROMAN_CAPITALS; | |||
| tr->langopts.thousands_sep = ' '; // don't allow dot as thousands separator | |||
| } | |||
| break; | |||
| break; | |||
| case L('b', 'n'): // Bengali | |||
| case L('a', 's'): // Assamese | |||
| case L_mni: // Manipuri (temporary placement - it's not indo-european) | |||
| @@ -563,8 +539,7 @@ Translator *SelectTranslator(const char *name) | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| case L('b', 'o'): // Tibet | |||
| { | |||
| tr->langopts.stress_rule = STRESSPOSN_1L; | |||
| @@ -576,8 +551,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1; // disable check for unpronouncable words | |||
| tr->langopts.numbers = 1; | |||
| } | |||
| break; | |||
| break; | |||
| case L('c', 'y'): // Welsh | |||
| { | |||
| static const short stress_lengths_cy[8] = { 170, 220, 180, 180, 0, 0, 250, 270 }; | |||
| @@ -599,8 +573,7 @@ Translator *SelectTranslator(const char *name) | |||
| SetLetterVowel(tr, 'w'); // add letter to vowels and remove from consonants | |||
| SetLetterVowel(tr, 'y'); | |||
| } | |||
| break; | |||
| break; | |||
| case L('d', 'a'): // Danish | |||
| { | |||
| static const short stress_lengths_da[8] = { 160, 140, 200, 200, 0, 0, 220, 230 }; | |||
| @@ -611,9 +584,7 @@ Translator *SelectTranslator(const char *name) | |||
| SetLetterVowel(tr, 'y'); | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_SWAP_TENS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_ORDINAL_DOT | NUM_1900 | NUM_ROMAN | NUM_ROMAN_CAPITALS | NUM_ROMAN_ORDINAL; | |||
| } | |||
| break; | |||
| break; | |||
| case L('d', 'e'): | |||
| { | |||
| static const short stress_lengths_de[8] = { 150, 130, 200, 200, 0, 0, 270, 270 }; | |||
| @@ -630,8 +601,7 @@ Translator *SelectTranslator(const char *name) | |||
| SetLetterVowel(tr, 'y'); | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 2; // use de_rules for unpronouncable rules | |||
| } | |||
| break; | |||
| break; | |||
| case L('d', 'v'): // Divehi (Maldives) | |||
| { | |||
| SetupTranslator(tr, stress_lengths_ta, stress_amps_ta); | |||
| @@ -644,8 +614,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.break_numbers = 0x14a8; // 1000, 100,000 10,000,000 | |||
| tr->langopts.numbers = 1; | |||
| } | |||
| break; | |||
| break; | |||
| case L('e', 'n'): | |||
| { | |||
| static const short stress_lengths_en[8] = { 182, 140, 220, 220, 0, 0, 248, 275 }; | |||
| @@ -659,8 +628,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 2; // use en_rules for unpronouncable rules | |||
| SetLetterBits(tr, 6, "aeiouy"); // Group Y: vowels, including y | |||
| } | |||
| break; | |||
| break; | |||
| case L('e', 'l'): // Greek | |||
| case L_grc: // Ancient Greek | |||
| { | |||
| @@ -702,8 +670,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1; | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| case L('e', 'o'): | |||
| { | |||
| static const short stress_lengths_eo[8] = { 150, 140, 180, 180, 0, 0, 200, 200 }; | |||
| @@ -722,8 +689,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_ALLOW_SPACE | NUM_ROMAN; | |||
| } | |||
| break; | |||
| break; | |||
| case L('e', 's'): // Spanish | |||
| case L('a', 'n'): // Aragonese | |||
| case L('c', 'a'): // Catalan | |||
| @@ -768,8 +734,7 @@ Translator *SelectTranslator(const char *name) | |||
| } else | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 2; // use es_rules for unpronouncable rules | |||
| } | |||
| break; | |||
| break; | |||
| case L('e', 'u'): // basque | |||
| { | |||
| static const short stress_lengths_eu[8] = { 200, 200, 200, 200, 0, 0, 210, 230 }; // very weak stress | |||
| @@ -780,9 +745,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_SUFFIX] = 1; | |||
| tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_VIGESIMAL; | |||
| } | |||
| break; | |||
| break; | |||
| case L('f', 'a'): // Farsi | |||
| { | |||
| // Convert characters in the range 0x620 to 0x6cc to the range 1 to 63. | |||
| @@ -810,12 +773,10 @@ Translator *SelectTranslator(const char *name) | |||
| tr->chars_ignore = chars_ignore_zwnj_hyphen; // replace ZWNJ by hyphen | |||
| } | |||
| break; | |||
| break; | |||
| case L('e', 't'): // Estonian | |||
| tr->charset_a0 = charsets[4]; // ISO-8859-4 | |||
| // drop through to Finnish | |||
| // drop through to Finnish | |||
| case L('f', 'i'): // Finnish | |||
| { | |||
| static const unsigned char stress_amps_fi[8] = { 18, 16, 22, 22, 20, 22, 22, 22 }; | |||
| @@ -833,8 +794,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.spelling_stress = 1; | |||
| tr->langopts.intonation_group = 3; // less intonation, don't raise pitch at comma | |||
| } | |||
| break; | |||
| break; | |||
| case L('f', 'r'): // french | |||
| { | |||
| SetupTranslator(tr, stress_lengths_fr, stress_amps_fr); | |||
| @@ -847,8 +807,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_OMIT_1_HUNDRED | NUM_NOPAUSE | NUM_ROMAN | NUM_ROMAN_CAPITALS | NUM_ROMAN_AFTER | NUM_VIGESIMAL | NUM_DFRACTION_4; | |||
| SetLetterVowel(tr, 'y'); | |||
| } | |||
| break; | |||
| break; | |||
| case L('g', 'a'): // irish | |||
| case L('g', 'd'): // scots gaelic | |||
| { | |||
| @@ -859,8 +818,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 3; // don't count apostrophe | |||
| tr->langopts.param[LOPT_IT_LENGTHEN] = 1; // remove [:] phoneme from non-stressed syllables (Lang=gd) | |||
| } | |||
| break; | |||
| break; | |||
| case L('h', 'i'): // Hindi | |||
| case L('n', 'e'): // Nepali | |||
| case L('o', 'r'): // Oriya | |||
| @@ -896,9 +854,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->letter_bits_offset = OFFSET_ORIYA; | |||
| SetIndicLetters(tr); | |||
| } | |||
| break; | |||
| break; | |||
| case L('h', 'r'): // Croatian | |||
| case L('b', 's'): // Bosnian | |||
| case L('s', 'r'): // Serbian | |||
| @@ -930,16 +886,12 @@ Translator *SelectTranslator(const char *name) | |||
| SetLetterVowel(tr, 'y'); | |||
| SetLetterVowel(tr, 'r'); | |||
| } | |||
| break; | |||
| break; | |||
| case L('h', 't'): // Haitian Creole | |||
| tr->langopts.stress_rule = STRESSPOSN_1R; // stress on final syllable | |||
| tr->langopts.stress_flags = S_NO_AUTO_2 | S_FINAL_DIM; // don't use secondary stress | |||
| tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_OMIT_1_HUNDRED | NUM_NOPAUSE | NUM_ROMAN | NUM_VIGESIMAL | NUM_DFRACTION_4; | |||
| break; | |||
| case L('h', 'u'): // Hungarian | |||
| { | |||
| static const unsigned char stress_amps_hu[8] = { 17, 17, 19, 19, 20, 22, 22, 21 }; | |||
| @@ -964,8 +916,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.spelling_stress = 1; | |||
| SetLengthMods(tr, 3); // all equal | |||
| } | |||
| break; | |||
| break; | |||
| case L('h', 'y'): // Armenian | |||
| { | |||
| static const short stress_lengths_hy[8] = { 250, 200, 250, 250, 0, 0, 250, 250 }; | |||
| @@ -987,8 +938,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.max_initial_consonants = 6; | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_OMIT_1_HUNDRED; | |||
| } | |||
| break; | |||
| break; | |||
| case L('i', 'd'): // Indonesian | |||
| case L('m', 's'): // Malay | |||
| { | |||
| @@ -1001,8 +951,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.stress_flags = S_FINAL_DIM_ONLY | S_FINAL_NO_2; | |||
| tr->langopts.accents = 2; // "capital" after letter name | |||
| } | |||
| break; | |||
| break; | |||
| case L('i', 's'): // Icelandic | |||
| { | |||
| static const short stress_lengths_is[8] = { 180, 160, 200, 200, 0, 0, 240, 250 }; | |||
| @@ -1022,8 +971,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_SINGLE_AND | NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_1900; | |||
| tr->langopts.numbers2 = 0x2; | |||
| } | |||
| break; | |||
| break; | |||
| case L('i', 't'): // Italian | |||
| { | |||
| static const short stress_lengths_it[8] = | |||
| @@ -1049,8 +997,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.accents = 2; // Say "Capital" after the letter. | |||
| SetLetterVowel(tr, 'y'); | |||
| } | |||
| break; | |||
| break; | |||
| case L_jbo: // Lojban | |||
| { | |||
| static const short stress_lengths_jbo[8] = { 145, 145, 170, 160, 0, 0, 330, 350 }; | |||
| @@ -1064,8 +1011,7 @@ Translator *SelectTranslator(const char *name) | |||
| SetLetterVowel(tr, 'y'); | |||
| tr->langopts.max_lengthmod = 368; | |||
| } | |||
| break; | |||
| break; | |||
| case L('k', 'a'): // Georgian | |||
| { | |||
| // character codes offset by 0x1080 | |||
| @@ -1088,8 +1034,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.alt_alphabet = OFFSET_CYRILLIC; | |||
| tr->langopts.alt_alphabet_lang = L('r', 'u'); | |||
| } | |||
| break; | |||
| break; | |||
| case L('k', 'k'): // Kazakh | |||
| { | |||
| static const unsigned char stress_amps_tr[8] = { 18, 16, 20, 21, 20, 21, 21, 20 }; | |||
| @@ -1112,8 +1057,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.max_initial_consonants = 2; | |||
| SetLengthMods(tr, 3); // all equal | |||
| } | |||
| break; | |||
| break; | |||
| case L('k', 'l'): // Greenlandic | |||
| { | |||
| SetupTranslator(tr, stress_lengths_equal, stress_amps_equal); | |||
| @@ -1121,8 +1065,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.stress_flags = S_NO_AUTO_2; | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_SWAP_TENS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_ORDINAL_DOT | NUM_1900 | NUM_ROMAN | NUM_ROMAN_CAPITALS | NUM_ROMAN_ORDINAL; | |||
| } | |||
| break; | |||
| break; | |||
| case L('k', 'o'): // Korean, TEST | |||
| { | |||
| static const char ko_ivowels[] = { 0x63, 0x64, 0x67, 0x68, 0x6d, 0x72, 0x74, 0x75, 0 }; // y and i vowels | |||
| @@ -1142,8 +1085,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.break_numbers = 0x1111110; | |||
| tr->langopts.max_digits = 20; | |||
| } | |||
| break; | |||
| break; | |||
| case L('k', 'u'): // Kurdish | |||
| { | |||
| static const unsigned char stress_amps_ku[8] = { 18, 18, 20, 20, 20, 22, 22, 21 }; | |||
| @@ -1157,8 +1099,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_OMIT_1_HUNDRED | NUM_AND_HUNDRED; | |||
| tr->langopts.max_initial_consonants = 2; | |||
| } | |||
| break; | |||
| break; | |||
| case L('l', 'a'): // Latin | |||
| { | |||
| tr->charset_a0 = charsets[4]; // ISO-8859-4, includes a,e,i,o,u-macron | |||
| @@ -1170,8 +1111,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_ROMAN; | |||
| tr->langopts.max_roman = 5000; | |||
| } | |||
| break; | |||
| break; | |||
| case L('l', 't'): // Lithuanian | |||
| { | |||
| tr->charset_a0 = charsets[4]; // ISO-8859-4 | |||
| @@ -1184,8 +1124,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers2 = NUM2_THOUSANDS_VAR4; | |||
| tr->langopts.max_roman = 5000; | |||
| } | |||
| break; | |||
| break; | |||
| case L('l', 'v'): // latvian | |||
| { | |||
| static const unsigned char stress_amps_lv[8] = { 17, 13, 20, 20, 20, 22, 22, 21 }; | |||
| @@ -1199,8 +1138,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_DFRACTION_4 | NUM_ORDINAL_DOT; | |||
| tr->langopts.stress_flags = S_FINAL_DIM_ONLY | S_FINAL_NO_2 | S_EO_CLAUSE1; | |||
| } | |||
| break; | |||
| break; | |||
| case L('m', 'k'): // Macedonian | |||
| { | |||
| static wchar_t vowels_cyrillic[] = { 0x440, // also include 'р' [R] | |||
| @@ -1217,8 +1155,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_AND_UNITS | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_DFRACTION_2; | |||
| tr->langopts.numbers2 = 0x8a; // variant numbers before thousands,milliards | |||
| } | |||
| break; | |||
| break; | |||
| case L('m', 't'): // Maltese | |||
| { | |||
| tr->charset_a0 = charsets[3]; // ISO-8859-3 | |||
| @@ -1226,8 +1163,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.stress_rule = STRESSPOSN_2R; // penultimate | |||
| tr->langopts.numbers = 1; | |||
| } | |||
| break; | |||
| break; | |||
| case L('n', 'l'): // Dutch | |||
| { | |||
| static const short stress_lengths_nl[8] = { 160, 135, 210, 210, 0, 0, 260, 280 }; | |||
| @@ -1244,8 +1180,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.stress_flags = S_FIRST_PRIMARY; | |||
| memcpy(tr->stress_lengths, stress_lengths_nl, sizeof(tr->stress_lengths)); | |||
| } | |||
| break; | |||
| break; | |||
| case L('n', 'o'): // Norwegian | |||
| { | |||
| static const short stress_lengths_no[8] = { 160, 140, 200, 200, 0, 0, 220, 230 }; | |||
| @@ -1255,8 +1190,7 @@ Translator *SelectTranslator(const char *name) | |||
| SetLetterVowel(tr, 'y'); | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_HUNDRED_AND | NUM_ALLOW_SPACE | NUM_1900 | NUM_ORDINAL_DOT; | |||
| } | |||
| break; | |||
| break; | |||
| case L('o', 'm'): // Oromo | |||
| { | |||
| static const unsigned char stress_amps_om[] = { 18, 15, 20, 20, 20, 22, 22, 22 }; | |||
| @@ -1268,8 +1202,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_OMIT_1_HUNDRED | NUM_HUNDRED_AND; | |||
| tr->langopts.numbers2 = 0x200; // say "thousands" before its number | |||
| } | |||
| break; | |||
| break; | |||
| case L('p', 'l'): // Polish | |||
| { | |||
| static const short stress_lengths_pl[8] = { 160, 190, 175, 175, 0, 0, 200, 210 }; | |||
| @@ -1287,8 +1220,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_COMBINE_WORDS] = 4 + 0x100; // combine 'nie' (marked with $alt2) with some 1-syllable (and 2-syllable) words (marked with $alt) | |||
| SetLetterVowel(tr, 'y'); | |||
| } | |||
| break; | |||
| break; | |||
| case L('p', 't'): // Portuguese | |||
| { | |||
| static const short stress_lengths_pt[8] = { 170, 115, 210, 240, 0, 0, 260, 280 }; | |||
| @@ -1308,8 +1240,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.param[LOPT_ALT] = 2; // call ApplySpecialAttributes2() if a word has $alt or $alt2 | |||
| tr->langopts.accents = 2; // 'capital' after letter name | |||
| } | |||
| break; | |||
| break; | |||
| case L('r', 'o'): // Romanian | |||
| { | |||
| static const short stress_lengths_ro[8] = { 170, 170, 180, 180, 0, 0, 240, 260 }; | |||
| @@ -1324,12 +1255,10 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_DFRACTION_3 | NUM_AND_UNITS | NUM_ROMAN; | |||
| tr->langopts.numbers2 = 0x1e; // variant numbers before all thousandplex | |||
| } | |||
| break; | |||
| break; | |||
| case L('r', 'u'): // Russian | |||
| Translator_Russian(tr); | |||
| break; | |||
| case L('r', 'w'): // Kiryarwanda | |||
| { | |||
| tr->langopts.stress_rule = STRESSPOSN_2R; | |||
| @@ -1339,8 +1268,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_DFRACTION_2 | NUM_AND_HUNDRED; | |||
| tr->langopts.numbers2 = 0x200; // say "thousands" before its number | |||
| } | |||
| break; | |||
| break; | |||
| case L('s', 'k'): // Slovak | |||
| case L('c', 's'): // Czech | |||
| { | |||
| @@ -1370,8 +1298,7 @@ Translator *SelectTranslator(const char *name) | |||
| ResetLetterBits(tr, 0x20); | |||
| SetLetterBits(tr, 5, sk_voiced); | |||
| } | |||
| break; | |||
| break; | |||
| case L('s', 'i'): // Sinhala | |||
| { | |||
| SetupTranslator(tr, stress_lengths_ta, stress_amps_ta); | |||
| @@ -1396,8 +1323,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers2 = NUM2_PERCENT_BEFORE; | |||
| tr->langopts.break_numbers = 0x14aa8; // for languages which have numbers for 100,000 and 100,00,000, eg Hindi | |||
| } | |||
| break; | |||
| break; | |||
| case L('s', 'l'): // Slovenian | |||
| tr->charset_a0 = charsets[2]; // ISO-8859-2 | |||
| tr->langopts.stress_rule = STRESSPOSN_2R; // Temporary | |||
| @@ -1412,7 +1338,6 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.thousands_sep = ' '; // don't allow dot as thousands separator | |||
| tr->langopts.replace_chars = replace_cyrillic_latin; | |||
| break; | |||
| case L('s', 'q'): // Albanian | |||
| { | |||
| static const short stress_lengths_sq[8] = { 150, 150, 180, 180, 0, 0, 300, 300 }; | |||
| @@ -1426,9 +1351,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_DFRACTION_4; | |||
| tr->langopts.accents = 2; // "capital" after letter name | |||
| } | |||
| break; | |||
| break; | |||
| case L('s', 'v'): // Swedish | |||
| { | |||
| static const unsigned char stress_amps_sv[] = { 16, 16, 20, 20, 20, 22, 22, 21 }; | |||
| @@ -1440,8 +1363,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_1900; | |||
| tr->langopts.accents = 1; | |||
| } | |||
| break; | |||
| break; | |||
| case L('s', 'w'): // Swahili | |||
| case L('t', 'n'): // Setswana | |||
| { | |||
| @@ -1460,8 +1382,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_AND_UNITS | NUM_HUNDRED_AND | NUM_SINGLE_AND | NUM_OMIT_1_HUNDRED; | |||
| tr->langopts.break_numbers = 0x49249268; // for languages which have numbers for 100,000 and 1,000,000 | |||
| } | |||
| break; | |||
| break; | |||
| case L('t', 'a'): // Tamil | |||
| case L('k', 'n'): // Kannada | |||
| case L('m', 'l'): // Malayalam | |||
| @@ -1501,8 +1422,7 @@ Translator *SelectTranslator(const char *name) | |||
| SetIndicLetters(tr); // call this after setting OFFSET_ | |||
| SetLetterBitsRange(tr, LETTERGP_B, 0x4e, 0x4e); // chillu-virama (unofficial) | |||
| } | |||
| break; | |||
| break; | |||
| case L('t', 'r'): // Turkish | |||
| case L('a', 'z'): // Azerbaijan | |||
| { | |||
| @@ -1523,8 +1443,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_DFRACTION_2; | |||
| tr->langopts.max_initial_consonants = 2; | |||
| } | |||
| break; | |||
| break; | |||
| case L('t', 't'): // Tatar | |||
| { | |||
| SetCyrillicLetters(tr); | |||
| @@ -1533,15 +1452,13 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.stress_flags = S_NO_AUTO_2; // no automatic secondary stress | |||
| tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_DFRACTION_4; | |||
| } | |||
| break; | |||
| break; | |||
| case L('u', 'k'): // Ukrainian | |||
| { | |||
| SetCyrillicLetters(tr); | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 0x432; // [v] don't count this character at start of word | |||
| } | |||
| break; | |||
| break; | |||
| case L('u', 'r'): // Urdu | |||
| case L('s', 'd'): // Sindhi | |||
| { | |||
| @@ -1550,8 +1467,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_SWAP_TENS; | |||
| tr->langopts.break_numbers = 0x52a8; // for languages which have numbers for 100,000 and 100,00,000, eg Hindi | |||
| } | |||
| break; | |||
| break; | |||
| case L('v', 'i'): // Vietnamese | |||
| { | |||
| static const short stress_lengths_vi[8] = { 150, 150, 180, 180, 210, 230, 230, 240 }; | |||
| @@ -1582,13 +1498,11 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_HUNDRED_AND_DIGIT | NUM_DFRACTION_4 | NUM_ZERO_HUNDRED; | |||
| } | |||
| break; | |||
| break; | |||
| case L('w', 'o'): | |||
| tr->langopts.stress_rule = STRESSPOSN_1L; | |||
| tr->langopts.numbers = NUM_AND_UNITS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_SINGLE_STRESS; | |||
| break; | |||
| case L('z', 'h'): | |||
| case L_zhy: | |||
| { | |||
| @@ -1614,8 +1528,7 @@ Translator *SelectTranslator(const char *name) | |||
| tr->langopts.break_numbers = 0x00018; | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| default: | |||
| tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1; // disable check for unpronouncable words | |||
| break; | |||
| @@ -1627,7 +1540,6 @@ Translator *SelectTranslator(const char *name) | |||
| return tr; | |||
| } | |||
| void ProcessLanguageOptions(LANGUAGE_OPTIONS *langopts) | |||
| { | |||
| if (langopts->numbers & NUM_DECIMAL_COMMA) { | |||
| @@ -1639,7 +1551,6 @@ void ProcessLanguageOptions(LANGUAGE_OPTIONS *langopts) | |||
| langopts->thousands_sep = 0; // don't allow thousands separator, except space | |||
| } | |||
| static void Translator_Russian(Translator *tr) | |||
| { | |||
| static const unsigned char stress_amps_ru[] = { 16, 16, 18, 18, 20, 24, 24, 22 }; | |||
| @@ -1660,5 +1571,4 @@ static void Translator_Russian(Translator *tr) | |||
| tr->langopts.numbers2 = 0x2 + NUM2_THOUSANDS_VAR1; // variant numbers before thousands | |||
| tr->langopts.phoneme_change = 1; | |||
| tr->langopts.testing = 2; | |||
| } | |||
| @@ -39,7 +39,6 @@ | |||
| #define WORD_STRESS_CHAR '*' | |||
| Translator *translator = NULL; // the main translator | |||
| Translator *translator2 = NULL; // secondary translator for certain words | |||
| static char translator2_language[20] = { 0 }; | |||
| @@ -82,7 +81,6 @@ static int any_stressed_words; | |||
| int pre_pause; | |||
| ALPHABET *current_alphabet; | |||
| // these were previously in translator class | |||
| #ifdef PLATFORM_WINDOWS | |||
| char word_phonemes[N_WORD_PHONEMES*2]; // longer, because snprint() is not available | |||
| @@ -92,8 +90,6 @@ char word_phonemes[N_WORD_PHONEMES]; // a word translated into phoneme codes | |||
| int n_ph_list2; | |||
| PHONEME_LIST2 ph_list2[N_PHONEME_LIST]; // first stage of text->phonemes | |||
| wchar_t option_punctlist[N_PUNCTLIST] = { 0 }; | |||
| char ctrl_embedded = '\001'; // to allow an alternative CTRL for embedded commands | |||
| int option_multibyte = espeakCHARS_AUTO; // 0=auto, 1=utf8, 2=8bit, 3=wchar, 4=16bit | |||
| @@ -112,7 +108,6 @@ static char source[N_TR_SOURCE+40]; // extra space for embedded command & vo | |||
| int n_replace_phonemes; | |||
| REPLACE_PHONEMES replace_phonemes[N_REPLACE_PHONEMES]; | |||
| // brackets, also 0x2014 to 0x021f which don't need to be in this list | |||
| static const unsigned short brackets[] = { | |||
| '(', ')', '[', ']', '{', '}', '<', '>', '"', '\'', '`', | |||
| @@ -349,7 +344,6 @@ static unsigned char length_mods_equal[100] = { | |||
| 110, 120, 100, 110, 110, 110, 110, 110, 110, 110 | |||
| }; | |||
| static unsigned char *length_mod_tabs[6] = { | |||
| length_mods_en, | |||
| length_mods_en, // 1 | |||
| @@ -359,7 +353,6 @@ static unsigned char *length_mod_tabs[6] = { | |||
| length_mods_equal // 5 | |||
| }; | |||
| void SetLengthMods(Translator *tr, int value) | |||
| { | |||
| int value2; | |||
| @@ -369,8 +362,6 @@ void SetLengthMods(Translator *tr, int value) | |||
| tr->langopts.length_mods0 = length_mod_tabs[value2]; | |||
| } | |||
| int IsAlpha(unsigned int c) | |||
| { | |||
| // Replacement for iswalph() which also checks for some in-word symbols | |||
| @@ -457,7 +448,6 @@ int IsSpace(unsigned int c) | |||
| return iswspace(c); | |||
| } | |||
| void DeleteTranslator(Translator *tr) | |||
| { | |||
| if (tr->data_dictlist != NULL) | |||
| @@ -465,7 +455,6 @@ void DeleteTranslator(Translator *tr) | |||
| Free(tr); | |||
| } | |||
| int lookupwchar(const unsigned short *list, int c) | |||
| { | |||
| // Is the character c in the list ? | |||
| @@ -478,7 +467,6 @@ int lookupwchar(const unsigned short *list, int c) | |||
| return 0; | |||
| } | |||
| int lookupwchar2(const unsigned short *list, int c) | |||
| { | |||
| // Replace character c by another character. | |||
| @@ -492,7 +480,6 @@ int lookupwchar2(const unsigned short *list, int c) | |||
| return 0; | |||
| } | |||
| int IsBracket(int c) | |||
| { | |||
| if ((c >= 0x2014) && (c <= 0x201f)) | |||
| @@ -500,7 +487,6 @@ int IsBracket(int c) | |||
| return lookupwchar(brackets, c); | |||
| } | |||
| int utf8_out(unsigned int c, char *buf) | |||
| { | |||
| // write a unicode character into a buffer as utf8 | |||
| @@ -534,7 +520,6 @@ int utf8_out(unsigned int c, char *buf) | |||
| return n_bytes+1; | |||
| } | |||
| int utf8_nbytes(const char *buf) | |||
| { | |||
| // Returns the number of bytes for the first UTF-8 character in buf | |||
| @@ -548,7 +533,6 @@ int utf8_nbytes(const char *buf) | |||
| return 4; | |||
| } | |||
| int utf8_in2(int *c, const char *buf, int backwards) | |||
| { | |||
| // Read a unicode characater from a UTF8 string | |||
| @@ -586,7 +570,6 @@ int utf8_in2(int *c, const char *buf, int backwards) | |||
| return n_bytes+1; | |||
| } | |||
| #pragma GCC visibility push(default) | |||
| int utf8_in(int *c, const char *buf) | |||
| { | |||
| @@ -596,7 +579,6 @@ int utf8_in(int *c, const char *buf) | |||
| } | |||
| #pragma GCC visibility pop | |||
| char *strchr_w(const char *s, int c) | |||
| { | |||
| // return NULL for any non-ascii character | |||
| @@ -605,7 +587,6 @@ char *strchr_w(const char *s, int c) | |||
| return strchr((char *)s, c); // (char *) is needed for Borland compiler | |||
| } | |||
| int IsAllUpper(const char *word) | |||
| { | |||
| int c; | |||
| @@ -617,7 +598,6 @@ int IsAllUpper(const char *word) | |||
| return 1; | |||
| } | |||
| static char *SpeakIndividualLetters(Translator *tr, char *word, char *phonemes, int spell_word) | |||
| { | |||
| int posn = 0; | |||
| @@ -643,8 +623,6 @@ static char *SpeakIndividualLetters(Translator *tr, char *word, char *phonemes, | |||
| return word; | |||
| } | |||
| static int CheckDottedAbbrev(char *word1, WORD_TAB *wtab) | |||
| { | |||
| int wc; | |||
| @@ -701,7 +679,6 @@ static int CheckDottedAbbrev(char *word1, WORD_TAB *wtab) | |||
| return count; | |||
| } | |||
| extern char *phondata_ptr; | |||
| int ChangeEquivalentPhonemes(Translator *tr, int lang2, char *phonemes) | |||
| @@ -783,9 +760,6 @@ int ChangeEquivalentPhonemes(Translator *tr, int lang2, char *phonemes) | |||
| return 1; | |||
| } | |||
| int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wtab, char *word_out) | |||
| { | |||
| // word1 is terminated by space (0x20) character | |||
| @@ -908,7 +882,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| if (!found) | |||
| found = LookupDictList(tr, &word1, phonemes, dictionary_flags, FLAG_ALLOW_TEXTMODE, wtab); // the original word | |||
| if ((dictionary_flags[0] & (FLAG_ALLOW_DOT | FLAG_NEEDS_DOT)) && (wordx[1] == '.')) | |||
| wordx[1] = ' '; // remove a Dot after this word | |||
| @@ -951,7 +924,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| } | |||
| } | |||
| // if textmode, LookupDictList() replaces word1 by the new text and returns found=0 | |||
| if (phonemes[0] == phonSWITCH) { | |||
| @@ -1196,9 +1168,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| } | |||
| } | |||
| if ((end_type != 0) && !(end_type & SUFX_P)) { | |||
| end_type1 = end_type; | |||
| strcpy(phonemes2, phonemes); | |||
| @@ -1293,9 +1262,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| memcpy(wordx, word_copy, strlen(word_copy)); | |||
| } | |||
| wordx[-1] = c_temp; | |||
| } | |||
| } | |||
| @@ -1312,7 +1278,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| wflags |= emphasize_allcaps; | |||
| /* determine stress pattern for this word */ | |||
| /******************************************/ | |||
| add_suffix_phonemes = 0; | |||
| @@ -1400,7 +1365,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| ChangeWordStress(tr, word_phonemes, 3); | |||
| } | |||
| // dictionary flags for this word give a clue about which alternative pronunciations of | |||
| // following words to use. | |||
| if (end_type1 & SUFX_F) { | |||
| @@ -1461,8 +1425,6 @@ int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wt | |||
| return dictionary_flags[0]; | |||
| } | |||
| static void SetPlist2(PHONEME_LIST2 *p, unsigned char phcode) | |||
| { | |||
| p->phcode = phcode; | |||
| @@ -1484,7 +1446,6 @@ static int CountSyllables(unsigned char *phonemes) | |||
| return count; | |||
| } | |||
| void Word_EmbeddedCmd() | |||
| { | |||
| // Process embedded commands for emphasis, sayas, and break | |||
| @@ -1516,7 +1477,6 @@ void Word_EmbeddedCmd() | |||
| } while (((embedded_cmd & 0x80) == 0) && (embedded_read < embedded_ix)); | |||
| } | |||
| int SetTranslator2(const char *new_language) | |||
| { | |||
| // Set translator2 to a second language | |||
| @@ -1569,8 +1529,6 @@ int SetTranslator2(const char *new_language) | |||
| return new_phoneme_tab; | |||
| } | |||
| static int TranslateWord2(Translator *tr, char *word, WORD_TAB *wtab, int pre_pause, int next_pause) | |||
| { | |||
| int flags = 0; | |||
| @@ -2020,8 +1978,6 @@ static int TranslateWord2(Translator *tr, char *word, WORD_TAB *wtab, int pre_pa | |||
| return flags; | |||
| } | |||
| static int EmbeddedCommand(unsigned int *source_index_out) | |||
| { | |||
| // An embedded command to change the pitch, volume, etc. | |||
| @@ -2079,8 +2035,6 @@ static int EmbeddedCommand(unsigned int *source_index_out) | |||
| return 1; | |||
| } | |||
| static int SubstituteChar(Translator *tr, unsigned int c, unsigned int next_in, int *insert, int *wordflags) | |||
| { | |||
| int ix; | |||
| @@ -2139,10 +2093,8 @@ static int SubstituteChar(Translator *tr, unsigned int c, unsigned int next_in, | |||
| *wordflags |= FLAG_CHAR_REPLACED; | |||
| return new_c; | |||
| } | |||
| static int TranslateChar(Translator *tr, char *ptr, int prev_in, unsigned int c, unsigned int next_in, int *insert, int *wordflags) | |||
| { | |||
| // To allow language specific examination and replacement of characters | |||
| @@ -2192,7 +2144,6 @@ static int TranslateChar(Translator *tr, char *ptr, int prev_in, unsigned int c, | |||
| case L('n', 'l'): | |||
| // look for 'n and replace by a special character (unicode: schwa) | |||
| if (!iswalpha2(prev_in)) { | |||
| utf8_in(&next2, &ptr[1]); | |||
| @@ -2213,7 +2164,6 @@ static int TranslateChar(Translator *tr, char *ptr, int prev_in, unsigned int c, | |||
| return SubstituteChar(tr, c, next_in, insert, wordflags); | |||
| } | |||
| static const char *UCase_ga[] = { "bp", "bhf", "dt", "gc", "hA", "mb", "nd", "ng", "ts", "tA", "nA", NULL }; | |||
| int UpperCaseInWord(Translator *tr, char *word, int c) | |||
| @@ -2238,7 +2188,6 @@ int UpperCaseInWord(Translator *tr, char *word, int c) | |||
| return 0; | |||
| } | |||
| void *TranslateClause(Translator *tr, FILE *f_text, const void *vp_input, int *tone_out, char **voice_change) | |||
| { | |||
| int ix; | |||
| @@ -2820,7 +2769,6 @@ void *TranslateClause(Translator *tr, FILE *f_text, const void *vp_input, int *t | |||
| } | |||
| words[0].flags |= FLAG_FIRST_WORD; | |||
| for (ix = 0; ix < word_count; ix++) { | |||
| int nx; | |||
| int c_temp; | |||
| @@ -2989,7 +2937,6 @@ void *TranslateClause(Translator *tr, FILE *f_text, const void *vp_input, int *t | |||
| embedded_list[embedded_ix] = 0x80; | |||
| } | |||
| prev_clause_pause = clause_pause; | |||
| if (tone_out != NULL) | |||
| @@ -2999,7 +2946,6 @@ void *TranslateClause(Translator *tr, FILE *f_text, const void *vp_input, int *t | |||
| if (terminator & CLAUSE_BIT_SENTENCE) | |||
| new_sentence = 1; // next clause is a new sentence | |||
| if (voice_change != NULL) { | |||
| // return new voice name if an embedded voice change command terminated the clause | |||
| if (terminator & CLAUSE_BIT_VOICE) | |||
| @@ -3017,10 +2963,6 @@ void *TranslateClause(Translator *tr, FILE *f_text, const void *vp_input, int *t | |||
| return (void *)p_textinput; | |||
| } | |||
| void InitText(int control) | |||
| { | |||
| count_sentences = 0; | |||
| @@ -46,7 +46,6 @@ | |||
| #include "voice.h" | |||
| #include "translate.h" | |||
| MNEM_TAB genders[] = { | |||
| { "unknown", 0 }, | |||
| { "male", 1 }, | |||
| @@ -60,8 +59,6 @@ int tone_points[12] = { 600, 170, 1200, 135, 2000, 110, 3000, 110, -1, 0 }; | |||
| static int formant_rate_22050[9] = { 240, 170, 170, 170, 170, 170, 170, 170, 170 }; // values for 22kHz sample rate | |||
| int formant_rate[9]; // values adjusted for actual sample rate | |||
| #define DEFAULT_LANGUAGE_PRIORITY 5 | |||
| #define N_VOICES_LIST 250 | |||
| static int n_voices_list = 0; | |||
| @@ -70,7 +67,6 @@ static int len_path_voices; | |||
| espeak_VOICE current_voice_selected; | |||
| enum { | |||
| V_NAME = 1, | |||
| V_LANGUAGE, | |||
| @@ -118,8 +114,6 @@ enum { | |||
| V_CONSONANTS | |||
| }; | |||
| static MNEM_TAB options_tab[] = { | |||
| { "reduce_t", LOPT_REDUCE_T }, | |||
| { "bracket", LOPT_BRACKET_PAUSE }, | |||
| @@ -183,7 +177,6 @@ static MNEM_TAB dict_dialects[] = { | |||
| { NULL, 0 } | |||
| }; | |||
| #define N_VOICE_VARIANTS 12 | |||
| const char variants_either[N_VOICE_VARIANTS] = { 1, 2, 12, 3, 13, 4, 14, 5, 11, 0 }; | |||
| const char variants_male[N_VOICE_VARIANTS] = { 1, 2, 3, 4, 5, 6, 0 }; | |||
| @@ -193,7 +186,6 @@ const char *variant_lists[3] = { variants_either, variants_male, variants_female | |||
| static voice_t voicedata; | |||
| voice_t *voice = &voicedata; | |||
| static char *fgets_strip(char *buf, int size, FILE *f_in) | |||
| { | |||
| // strip trailing spaces, and truncate lines at // comment | |||
| @@ -218,7 +210,6 @@ static char *fgets_strip(char *buf, int size, FILE *f_in) | |||
| return buf; | |||
| } | |||
| static int LookupTune(const char *name) | |||
| { | |||
| int ix; | |||
| @@ -230,8 +221,6 @@ static int LookupTune(const char *name) | |||
| return -1; | |||
| } | |||
| static void SetToneAdjust(voice_t *voice, int *tone_pts) | |||
| { | |||
| int ix; | |||
| @@ -266,7 +255,6 @@ static void SetToneAdjust(voice_t *voice, int *tone_pts) | |||
| } | |||
| } | |||
| void ReadTonePoints(char *string, int *tone_pts) | |||
| { | |||
| // tone_pts[] is int[12] | |||
| @@ -281,9 +269,6 @@ void ReadTonePoints(char *string, int *tone_pts) | |||
| &tone_pts[8], &tone_pts[9]); | |||
| } | |||
| static espeak_VOICE *ReadVoiceFile(FILE *f_in, const char *fname, const char *leafname) | |||
| { | |||
| // Read a Voice file, allocate a VOICE_DATA and set data from the | |||
| @@ -295,7 +280,6 @@ static espeak_VOICE *ReadVoiceFile(FILE *f_in, const char *fname, const char *le | |||
| char vlanguage[80]; | |||
| char languages[300]; // allow space for several alternate language names and priorities | |||
| unsigned int len; | |||
| int langix = 0; | |||
| int n_languages = 0; | |||
| @@ -378,9 +362,6 @@ static espeak_VOICE *ReadVoiceFile(FILE *f_in, const char *fname, const char *le | |||
| return voice_data; | |||
| } | |||
| void VoiceReset(int tone_only) | |||
| { | |||
| // Set voice to the default values | |||
| @@ -449,7 +430,6 @@ void VoiceReset(int tone_only) | |||
| } | |||
| } | |||
| static void VoiceFormant(char *p) | |||
| { | |||
| // Set parameters for a formant | |||
| @@ -476,10 +456,6 @@ static void VoiceFormant(char *p) | |||
| voice->freqadd[formant] = freqadd; | |||
| } | |||
| static void PhonemeReplacement(int type, char *p) | |||
| { | |||
| int n; | |||
| @@ -501,8 +477,6 @@ static void PhonemeReplacement(int type, char *p) | |||
| replace_phonemes[n_replace_phonemes++].type = flags; | |||
| } | |||
| static int Read8Numbers(char *data_in, int *data) | |||
| { | |||
| // Read 8 integer numbers | |||
| @@ -511,7 +485,6 @@ static int Read8Numbers(char *data_in, int *data) | |||
| &data[0], &data[1], &data[2], &data[3], &data[4], &data[5], &data[6], &data[7]); | |||
| } | |||
| static unsigned int StringToWord2(const char *string) | |||
| { | |||
| // Convert a language name string to a word such as L('e','n') | |||
| @@ -524,7 +497,6 @@ static unsigned int StringToWord2(const char *string) | |||
| return value; | |||
| } | |||
| voice_t *LoadVoice(const char *vname, int control) | |||
| { | |||
| // control, bit 0 1= no_default | |||
| @@ -583,7 +555,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| static const char *voices_europe = | |||
| "an bg bs ca cs cy da de el en en-us es et eu fi fr fr-be ga hr hu is it lt lv mk nl no pl pt-pt ro ru sk sq sr sv "; | |||
| strncpy0(voicename, vname, sizeof(voicename)); | |||
| if (control & 0x10) { | |||
| strcpy(buf, vname); | |||
| @@ -639,7 +610,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| strcpy(new_dictionary, language_type); | |||
| strcpy(phonemes_name, language_type); | |||
| if (!tone_only) { | |||
| voice = &voicedata; | |||
| strncpy0(voice_identifier, vname, sizeof(voice_identifier)); | |||
| @@ -662,7 +632,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| if (!tone_only) | |||
| SelectPhonemeTableName(phonemes_name); // set up phoneme_tab | |||
| while ((f_voice != NULL) && (fgets_strip(buf, sizeof(buf), f_voice) != NULL)) { | |||
| // isolate the attribute name | |||
| for (p = buf; (*p != 0) && !isspace(*p); p++) ; | |||
| @@ -715,15 +684,13 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| strncpy0(voice->language_name, language_name, sizeof(voice->language_name)); | |||
| } | |||
| } | |||
| break; | |||
| break; | |||
| case V_NAME: | |||
| if (tone_only == 0) { | |||
| while (isspace(*p)) p++; | |||
| strncpy0(voice_name, p, sizeof(voice_name)); | |||
| } | |||
| break; | |||
| case V_GENDER: | |||
| { | |||
| int age = 0; | |||
| @@ -732,8 +699,7 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| current_voice_selected.gender = LookupMnem(genders, vgender); | |||
| current_voice_selected.age = age; | |||
| } | |||
| break; | |||
| break; | |||
| case V_TRANSLATOR: | |||
| if (tone_only) break; | |||
| @@ -745,19 +711,15 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| new_translator = SelectTranslator(translator_name); | |||
| langopts = &new_translator->langopts; | |||
| break; | |||
| case V_DICTIONARY: // dictionary | |||
| sscanf(p, "%s", new_dictionary); | |||
| break; | |||
| case V_PHONEMES: // phoneme table | |||
| sscanf(p, "%s", phonemes_name); | |||
| break; | |||
| case V_FORMANT: | |||
| VoiceFormant(p); | |||
| break; | |||
| case V_PITCH: | |||
| { | |||
| double factor; | |||
| @@ -768,26 +730,21 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| factor = (double)(pitch1 - 82)/82; | |||
| voice->formant_factor = (int)((1+factor/4) * 256); // nominal formant shift for a different voice pitch | |||
| } | |||
| break; | |||
| break; | |||
| case V_STRESSLENGTH: // stressLength | |||
| stress_lengths_set = Read8Numbers(p, stress_lengths); | |||
| break; | |||
| case V_STRESSAMP: // stressAmp | |||
| stress_amps_set = Read8Numbers(p, stress_amps); | |||
| break; | |||
| case V_STRESSADD: // stressAdd | |||
| stress_add_set = Read8Numbers(p, stress_add); | |||
| break; | |||
| case V_INTONATION: // intonation | |||
| sscanf(p, "%d %d", &option_tone_flags, &option_tone2); | |||
| if ((option_tone_flags & 0xff) != 0) | |||
| langopts->intonation_group = option_tone_flags & 0xff; | |||
| break; | |||
| case V_TUNES: | |||
| n = sscanf(p, "%s %s %s %s %s %s", names[0], names[1], names[2], names[3], names[4], names[5]); | |||
| langopts->intonation_group = 0; | |||
| @@ -801,7 +758,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| langopts->tunes[ix] = value; | |||
| } | |||
| break; | |||
| case V_DICTRULES: // conditional dictionary rules and list entries | |||
| case V_NUMBERS: | |||
| case V_STRESSOPT: | |||
| @@ -829,7 +785,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| } | |||
| ProcessLanguageOptions(langopts); | |||
| break; | |||
| case V_REPLACE: | |||
| if (phonemes_set == 0) { | |||
| // must set up a phoneme table before we can lookup phoneme mnemonics | |||
| @@ -838,23 +793,19 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| } | |||
| PhonemeReplacement(key, p); | |||
| break; | |||
| case V_WORDGAP: // words | |||
| sscanf(p, "%d %d", &langopts->word_gap, &langopts->vowel_pause); | |||
| break; | |||
| case V_STRESSRULE: | |||
| sscanf(p, "%d %d %d %d", &langopts->stress_rule, | |||
| &langopts->stress_flags, | |||
| &langopts->unstressed_wd1, | |||
| &langopts->unstressed_wd2); | |||
| break; | |||
| case V_CHARSET: | |||
| if ((sscanf(p, "%d", &value) == 1) && (value < N_CHARSETS)) | |||
| new_translator->charset_a0 = charsets[value]; | |||
| break; | |||
| case V_OPTION: | |||
| value2 = 0; | |||
| if (((sscanf(p, "%s %d %d", option_name, &value, &value2) >= 2) && ((ix = LookupMnem(options_tab, option_name)) >= 0)) || | |||
| @@ -864,24 +815,20 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| } else | |||
| fprintf(stderr, "Bad voice option: %s %s\n", buf, p); | |||
| break; | |||
| case V_ECHO: | |||
| // echo. suggest: 135mS 11% | |||
| value = 0; | |||
| voice->echo_amp = 0; | |||
| sscanf(p, "%d %d", &voice->echo_delay, &voice->echo_amp); | |||
| break; | |||
| case V_FLUTTER: // flutter | |||
| if (sscanf(p, "%d", &value) == 1) | |||
| voice->flutter = value * 32; | |||
| break; | |||
| case V_ROUGHNESS: // roughness | |||
| if (sscanf(p, "%d", &value) == 1) | |||
| voice->roughness = value; | |||
| break; | |||
| case V_CLARITY: // formantshape | |||
| if (sscanf(p, "%d", &value) == 1) { | |||
| if (value > 4) { | |||
| @@ -891,20 +838,17 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| voice->n_harmonic_peaks = 1+value; | |||
| } | |||
| break; | |||
| case V_TONE: | |||
| { | |||
| int tone_data[12]; | |||
| ReadTonePoints(p, tone_data); | |||
| SetToneAdjust(voice, tone_data); | |||
| } | |||
| break; | |||
| break; | |||
| case V_VOICING: | |||
| if (sscanf(p, "%d", &value) == 1) | |||
| voice->voicing = (value * 64)/100; | |||
| break; | |||
| case V_BREATH: | |||
| voice->breath[0] = Read8Numbers(p, &voice->breath[1]); | |||
| for (ix = 1; ix < 8; ix++) { | |||
| @@ -912,19 +856,15 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| voice->breath[ix] = -voice->breath[ix]; | |||
| } | |||
| break; | |||
| case V_BREATHW: | |||
| voice->breathw[0] = Read8Numbers(p, &voice->breathw[1]); | |||
| break; | |||
| case V_CONSONANTS: | |||
| value = sscanf(p, "%d %d", &voice->consonant_amp, &voice->consonant_ampv); | |||
| break; | |||
| case V_SPEED: | |||
| sscanf(p, "%d", &voice->speed_percent); | |||
| break; | |||
| case V_MBROLA: | |||
| { | |||
| int srate = 16000; | |||
| @@ -936,23 +876,19 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| } | |||
| voice->samplerate = srate; | |||
| } | |||
| break; | |||
| break; | |||
| case V_KLATT: | |||
| voice->klattv[0] = 1; // default source: IMPULSIVE | |||
| Read8Numbers(p, voice->klattv); | |||
| voice->klattv[KLATT_Kopen] -= 40; | |||
| break; | |||
| case V_FAST: | |||
| Read8Numbers(p, speed.fast_settings); | |||
| SetSpeed(3); | |||
| break; | |||
| case V_DICTMIN: | |||
| sscanf(p, "%d", &dict_min); | |||
| break; | |||
| case V_ALPHABET2: | |||
| { | |||
| ALPHABET *alphabet; | |||
| @@ -967,8 +903,7 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| } else | |||
| fprintf(stderr, "alphabet name '%s' not found\n", name1); | |||
| } | |||
| break; | |||
| break; | |||
| case V_DICTDIALECT: | |||
| // specify a dialect to use for foreign words, eg, en-us for _^_EN | |||
| if (sscanf(p, "%s", name1) == 1) { | |||
| @@ -978,7 +913,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| fprintf(stderr, "dictdialect name '%s' not recognized\n", name1); | |||
| } | |||
| break; | |||
| default: | |||
| if ((key & 0xff00) == 0x100) | |||
| sscanf(p, "%d", &langopts->param[key &0xff]); | |||
| @@ -1049,7 +983,6 @@ voice_t *LoadVoice(const char *vname, int control) | |||
| return voice; | |||
| } | |||
| static char *ExtractVoiceVariantName(char *vname, int variant_num, int add_dir) | |||
| { | |||
| // Remove any voice variant suffix (name or number) from a voice name | |||
| @@ -1088,8 +1021,6 @@ static char *ExtractVoiceVariantName(char *vname, int variant_num, int add_dir) | |||
| return variant_name; | |||
| } | |||
| voice_t *LoadVoiceVariant(const char *vname, int variant_num) | |||
| { | |||
| // Load a voice file. | |||
| @@ -1110,15 +1041,12 @@ voice_t *LoadVoiceVariant(const char *vname, int variant_num) | |||
| return v; | |||
| } | |||
| static int __cdecl VoiceNameSorter(const void *p1, const void *p2) | |||
| { | |||
| int ix; | |||
| espeak_VOICE *v1 = *(espeak_VOICE **)p1; | |||
| espeak_VOICE *v2 = *(espeak_VOICE **)p2; | |||
| if ((ix = strcmp(&v1->languages[1], &v2->languages[1])) != 0) // primary language name | |||
| return ix; | |||
| if ((ix = v1->languages[0] - v2->languages[0]) != 0) // priority number | |||
| @@ -1126,7 +1054,6 @@ static int __cdecl VoiceNameSorter(const void *p1, const void *p2) | |||
| return strcmp(v1->name, v2->name); | |||
| } | |||
| static int __cdecl VoiceScoreSorter(const void *p1, const void *p2) | |||
| { | |||
| int ix; | |||
| @@ -1138,7 +1065,6 @@ static int __cdecl VoiceScoreSorter(const void *p1, const void *p2) | |||
| return strcmp(v1->name, v2->name); | |||
| } | |||
| static int ScoreVoice(espeak_VOICE *voice_spec, const char *spec_language, int spec_n_parts, int spec_lang_len, espeak_VOICE *voice) | |||
| { | |||
| int ix; | |||
| @@ -1262,7 +1188,6 @@ static int ScoreVoice(espeak_VOICE *voice_spec, const char *spec_language, int s | |||
| return score; | |||
| } | |||
| static int SetVoiceScores(espeak_VOICE *voice_select, espeak_VOICE **voices, int control) | |||
| { | |||
| // control: bit0=1 include mbrola voices | |||
| @@ -1298,7 +1223,6 @@ static int SetVoiceScores(espeak_VOICE *voice_select, espeak_VOICE **voices, int | |||
| language[lang_len] = 0; | |||
| n_parts = -1; | |||
| } | |||
| } | |||
| // select those voices which match the specified language | |||
| @@ -1325,9 +1249,6 @@ static int SetVoiceScores(espeak_VOICE *voice_select, espeak_VOICE **voices, int | |||
| return nv; | |||
| } | |||
| espeak_VOICE *SelectVoiceByName(espeak_VOICE **voices, const char *name2) | |||
| { | |||
| int ix; | |||
| @@ -1380,9 +1301,6 @@ espeak_VOICE *SelectVoiceByName(espeak_VOICE **voices, const char *name2) | |||
| return voices[match_name]; | |||
| } | |||
| char const *SelectVoice(espeak_VOICE *voice_select, int *found) | |||
| { | |||
| // Returns a path within espeak-voices, with a possible +variant suffix | |||
| @@ -1513,8 +1431,6 @@ char const *SelectVoice(espeak_VOICE *voice_select, int *found) | |||
| return vp->identifier; | |||
| } | |||
| static void GetVoices(const char *path) | |||
| { | |||
| FILE *f_voice; | |||
| @@ -1600,7 +1516,6 @@ static void GetVoices(const char *path) | |||
| } | |||
| } while (FindNextFileA(hFind, &FindFileData) != 0); | |||
| FindClose(hFind); | |||
| #else | |||
| DIR *dir; | |||
| struct dirent *ent; | |||
| @@ -1640,8 +1555,6 @@ static void GetVoices(const char *path) | |||
| #endif | |||
| } | |||
| espeak_ERROR SetVoiceByName(const char *name) | |||
| { | |||
| espeak_VOICE *v; | |||
| @@ -1692,8 +1605,6 @@ espeak_ERROR SetVoiceByName(const char *name) | |||
| return EE_INTERNAL_ERROR; // voice name not found | |||
| } | |||
| espeak_ERROR SetVoiceByProperties(espeak_VOICE *voice_selector) | |||
| { | |||
| const char *voice_id; | |||
| @@ -1711,7 +1622,6 @@ espeak_ERROR SetVoiceByProperties(espeak_VOICE *voice_selector) | |||
| return EE_OK; | |||
| } | |||
| void FreeVoiceList() | |||
| { | |||
| int ix; | |||
| @@ -1724,15 +1634,12 @@ void FreeVoiceList() | |||
| n_voices_list = 0; | |||
| } | |||
| #pragma GCC visibility push(default) | |||
| ESPEAK_API const espeak_VOICE **espeak_ListVoices(espeak_VOICE *voice_spec) | |||
| { | |||
| char path_voices[sizeof(path_home)+12]; | |||
| #ifdef PLATFORM_RISCOS | |||
| if (n_voices_list == 0) { | |||
| sprintf(path_voices, "%s%cvoices", path_home, PATHSEP); | |||
| @@ -1741,7 +1648,6 @@ ESPEAK_API const espeak_VOICE **espeak_ListVoices(espeak_VOICE *voice_spec) | |||
| voices_list[n_voices_list] = NULL; // voices list terminator | |||
| } | |||
| return (const espeak_VOICE **)voices_list; | |||
| #else | |||
| int ix; | |||
| int j; | |||
| @@ -1762,7 +1668,6 @@ ESPEAK_API const espeak_VOICE **espeak_ListVoices(espeak_VOICE *voice_spec) | |||
| qsort(voices_list, n_voices_list, sizeof(espeak_VOICE *), | |||
| (int(__cdecl *)(const void *, const void *))VoiceNameSorter); | |||
| if (voice_spec) { | |||
| // select the voices which match the voice_spec, and sort them by preference | |||
| SetVoiceScores(voice_spec, voices, 1); | |||
| @@ -1780,8 +1685,6 @@ ESPEAK_API const espeak_VOICE **espeak_ListVoices(espeak_VOICE *voice_spec) | |||
| #endif | |||
| } | |||
| ESPEAK_API espeak_VOICE *espeak_GetCurrentVoice(void) | |||
| { | |||
| return ¤t_voice_selected; | |||
| @@ -50,7 +50,6 @@ struct timespec { | |||
| }; | |||
| #endif /* HAVE_STRUCT_TIMESPEC */ | |||
| enum { ONE_BILLION = 1000000000 }; | |||
| #ifdef USE_PORTAUDIO | |||
| @@ -64,9 +63,6 @@ enum { ONE_BILLION = 1000000000 }; | |||
| #define USE_PORTAUDIO 18 | |||
| #endif | |||
| #ifdef USE_PULSEAUDIO | |||
| // create some wrappers for runtime detection | |||
| @@ -206,7 +202,6 @@ int wave_get_remaining_time(uint32_t sample, uint32_t *time) | |||
| #endif // USE_PULSEAUDIO | |||
| static t_wave_callback *my_callback_is_output_enabled = NULL; | |||
| #define N_WAV_BUF 10 | |||
| @@ -392,7 +387,6 @@ static int pa_callback(const void *inputBuffer, void *outputBuffer, | |||
| return aResult; | |||
| } | |||
| void wave_flush(void *theHandler) | |||
| { | |||
| ENTER("wave_flush"); | |||
| @@ -421,7 +415,6 @@ static int wave_open_sound() | |||
| out_channels = 1; | |||
| #if USE_PORTAUDIO == 18 | |||
| PaDeviceID playbackDevice = Pa_GetDefaultOutputDeviceID(); | |||
| PaError err = Pa_OpenStream(&pa_stream, | |||
| @@ -892,7 +885,6 @@ int wave_is_busy(void *theHandler) | |||
| SHOW("wave_is_busy: %d\n", active); | |||
| return active == 1; | |||
| } | |||
| @@ -901,7 +893,6 @@ void wave_terminate() | |||
| ENTER("wave_terminate"); | |||
| Pa_Terminate(); | |||
| } | |||
| uint32_t wave_get_read_position(void *theHandler) | |||
| @@ -944,10 +935,8 @@ void *wave_test_get_write_buffer() | |||
| return myWrite; | |||
| } | |||
| #else | |||
| int wave_init(int srate) { | |||
| return 1; | |||
| } | |||
| @@ -1015,5 +1004,4 @@ void add_time_in_ms(struct timespec *ts, int time_in_ms) | |||
| ts->tv_nsec = (long int)t_ns; | |||
| } | |||
| #endif // USE_ASYNC | |||
| @@ -161,7 +161,6 @@ static void context_state_cb(pa_context *c, void *userdata) { | |||
| case PA_CONTEXT_FAILED: | |||
| pa_threaded_mainloop_signal(mainloop, 0); | |||
| break; | |||
| case PA_CONTEXT_UNCONNECTED: | |||
| case PA_CONTEXT_CONNECTING: | |||
| case PA_CONTEXT_AUTHORIZING: | |||
| @@ -176,13 +175,11 @@ static void stream_state_cb(pa_stream *s, void *userdata) { | |||
| switch (pa_stream_get_state(s)) | |||
| { | |||
| case PA_STREAM_READY: | |||
| case PA_STREAM_FAILED: | |||
| case PA_STREAM_TERMINATED: | |||
| pa_threaded_mainloop_signal(mainloop, 0); | |||
| break; | |||
| case PA_STREAM_UNCONNECTED: | |||
| case PA_STREAM_CREATING: | |||
| break; | |||
| @@ -312,7 +309,6 @@ fail: | |||
| static void pulse_write(void *ptr, int length) { | |||
| ENTER(__FUNCTION__); | |||
| SHOW("pulse_write > length=%d\n", length); | |||
| CHECK_CONNECTED_NO_RETVAL(); | |||
| @@ -327,9 +323,7 @@ static void pulse_write(void *ptr, int length) { | |||
| do_trigger = 0; | |||
| written += length; | |||
| fail: | |||
| pa_threaded_mainloop_unlock(mainloop); | |||
| } | |||
| @@ -362,7 +356,6 @@ static int drain(void) { | |||
| SHOW("pa_stream_drain() failed: %s\n", pa_strerror(pa_context_errno(context))); | |||
| else | |||
| ret = PULSE_OK; | |||
| fail: | |||
| SHOW_TIME("pa_operation_unref (call)"); | |||
| if (o) | |||
| @@ -374,7 +367,6 @@ fail: | |||
| return ret; | |||
| } | |||
| static void pulse_close(void) { | |||
| ENTER(__FUNCTION__); | |||
| @@ -404,7 +396,6 @@ static void pulse_close(void) { | |||
| } | |||
| static int pulse_open() | |||
| { | |||
| ENTER(__FUNCTION__); | |||
| @@ -533,16 +524,12 @@ static int pulse_open() | |||
| SHOW_TIME("pulse_open (ret true)"); | |||
| return PULSE_OK; | |||
| unlock_and_fail: | |||
| if (o) | |||
| pa_operation_unref(o); | |||
| pa_threaded_mainloop_unlock(mainloop); | |||
| fail: | |||
| if (ret == PULSE_NO_CONNECTION) { | |||
| if (context) { | |||
| SHOW_TIME("pa_context_disconnect (call)"); | |||
| @@ -562,7 +549,6 @@ fail: | |||
| SHOW_TIME("pulse_open (ret false)"); | |||
| return ret; | |||
| } | |||
| void wave_flush(void *theHandler) | |||
| @@ -634,7 +620,6 @@ size_t wave_write(void *theHandler, char *theMono16BitsWaveBuffer, size_t theSiz | |||
| } | |||
| pulse_write(aBuffer, bytes_to_write); | |||
| terminate: | |||
| pthread_mutex_unlock(&pulse_mutex); | |||
| SHOW("wave_write: theSize=%d", theSize); | |||
| @@ -745,10 +730,8 @@ void *wave_test_get_write_buffer() | |||
| return NULL; | |||
| } | |||
| #else | |||
| int wave_init(return 1; ) { | |||
| } | |||
| void *wave_open(const char *the_api) { | |||
| @@ -818,5 +801,4 @@ void add_time_in_ms(struct timespec *ts, int time_in_ms) | |||
| } | |||
| #endif // ifndef USE_PORTAUDIO | |||
| #endif // USE_ASYNC | |||
| @@ -30,8 +30,6 @@ | |||
| #include <stdint.h> | |||
| #endif | |||
| #include "speak_lib.h" | |||
| #include "speech.h" | |||
| #include "phoneme.h" | |||
| @@ -56,7 +54,6 @@ | |||
| #define N_SINTAB 2048 | |||
| #include "sintab.h" | |||
| #define PI 3.1415927 | |||
| #define PI2 6.283185307 | |||
| #define N_WAV_BUF 10 | |||
| @@ -94,7 +91,6 @@ static RESONATOR rbreath[N_PEAKS]; | |||
| static int harm_sqrt_n = 0; | |||
| #define N_LOWHARM 30 | |||
| static int harm_inc[N_LOWHARM]; // only for these harmonics do we interpolate amplitude between steps | |||
| static int *harmspect; | |||
| @@ -107,7 +103,6 @@ static int modulation_type = 0; | |||
| static int glottal_flag = 0; | |||
| static int glottal_reduce = 0; | |||
| WGEN_DATA wdata; | |||
| static int amp_ix; | |||
| @@ -126,7 +121,6 @@ static int hf_factor; | |||
| static double minus_pi_t; | |||
| static double two_pi_t; | |||
| unsigned char *out_ptr; | |||
| unsigned char *out_start; | |||
| unsigned char *out_end; | |||
| @@ -248,7 +242,6 @@ static unsigned char wavemult[N_WAVEMULT] = { | |||
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 | |||
| }; | |||
| // set from y = pow(2,x) * 128, x=-1 to 1 | |||
| unsigned char pitch_adjust_tab[MAX_PITCH_VALUE+1] = { | |||
| 64, 65, 66, 67, 68, 69, 70, 71, | |||
| @@ -266,7 +259,6 @@ unsigned char pitch_adjust_tab[MAX_PITCH_VALUE+1] = { | |||
| 242, 246, 249, 252, 254, 255 | |||
| }; | |||
| void WcmdqStop() | |||
| { | |||
| wcmdq_head = 0; | |||
| @@ -286,7 +278,6 @@ void WcmdqStop() | |||
| MbrolaReset(); | |||
| } | |||
| int WcmdqFree() | |||
| { | |||
| int i; | |||
| @@ -300,7 +291,6 @@ int WcmdqUsed() | |||
| return N_WCMDQ - WcmdqFree(); | |||
| } | |||
| void WcmdqInc() | |||
| { | |||
| wcmdq_tail++; | |||
| @@ -313,8 +303,6 @@ static void WcmdqIncHead() | |||
| if (wcmdq_head >= N_WCMDQ) wcmdq_head = 0; | |||
| } | |||
| #define PEAKSHAPEW 256 | |||
| unsigned char pk_shape1[PEAKSHAPEW+1] = { | |||
| @@ -359,7 +347,6 @@ static unsigned char pk_shape2[PEAKSHAPEW+1] = { | |||
| static unsigned char *pk_shape; | |||
| #ifdef USE_PORTAUDIO | |||
| // PortAudio interface | |||
| @@ -370,7 +357,6 @@ static int out_channels = 1; | |||
| unsigned char *outbuffer = NULL; | |||
| int outbuffer_size = 0; | |||
| #if USE_PORTAUDIO == 18 | |||
| static int WaveCallback(void *inputBuffer, void *outputBuffer, | |||
| unsigned long framesPerBuffer, PaTimestamp outTime, void *userData) | |||
| @@ -486,10 +472,8 @@ static int WaveCallback(const void *inputBuffer, void *outputBuffer, | |||
| #else | |||
| return result; | |||
| #endif | |||
| } | |||
| #if USE_PORTAUDIO == 19 | |||
| /* This is a fixed version of Pa_OpenDefaultStream() for use if the version in portaudio V19 | |||
| is broken */ | |||
| @@ -532,7 +516,6 @@ static PaError Pa_OpenDefaultStream2(PaStream **stream, | |||
| } | |||
| #endif | |||
| int WavegenOpenSound() | |||
| { | |||
| PaError err, err2; | |||
| @@ -590,8 +573,6 @@ int WavegenOpenSound() | |||
| return 0; | |||
| } | |||
| int WavegenCloseSound() | |||
| { | |||
| PaError active; | |||
| @@ -615,7 +596,6 @@ int WavegenCloseSound() | |||
| return 0; | |||
| } | |||
| int WavegenInitSound() | |||
| { | |||
| PaError err; | |||
| @@ -647,7 +627,6 @@ int WavegenInitSound() | |||
| } | |||
| #endif | |||
| void WavegenInit(int rate, int wavemult_fact) | |||
| { | |||
| int ix; | |||
| @@ -671,7 +650,6 @@ void WavegenInit(int rate, int wavemult_fact) | |||
| for (ix = 0; ix < N_EMBEDDED_VALUES; ix++) | |||
| embedded_value[ix] = embedded_default[ix]; | |||
| // set up window to generate a spread of harmonics from a | |||
| // single peak for HF peaks | |||
| wavemult_max = (samplerate * wavemult_fact)/(256 * 50); | |||
| @@ -695,7 +673,6 @@ void WavegenInit(int rate, int wavemult_fact) | |||
| #endif | |||
| } | |||
| int GetAmplitude(void) | |||
| { | |||
| int amp; | |||
| @@ -708,7 +685,6 @@ int GetAmplitude(void) | |||
| return general_amplitude; | |||
| } | |||
| static void WavegenSetEcho(void) | |||
| { | |||
| int delay; | |||
| @@ -749,8 +725,6 @@ static void WavegenSetEcho(void) | |||
| general_amplitude = ((general_amplitude * (500-amp))/500); | |||
| } | |||
| int PeaksToHarmspect(wavegen_peaks_t *peaks, int pitch, int *htab, int control) | |||
| { | |||
| // Calculate the amplitude of each harmonics from the formants | |||
| @@ -862,8 +836,6 @@ int PeaksToHarmspect(wavegen_peaks_t *peaks, int pitch, int *htab, int control) | |||
| return hmax; // highest harmonic number | |||
| } | |||
| static void AdvanceParameters() | |||
| { | |||
| // Called every 64 samples to increment the formant freq, height, and widths | |||
| @@ -926,7 +898,6 @@ static void AdvanceParameters() | |||
| #endif | |||
| } | |||
| #ifndef PLATFORM_RISCOS | |||
| static double resonator(RESONATOR *r, double input) | |||
| { | |||
| @@ -939,8 +910,6 @@ static double resonator(RESONATOR *r, double input) | |||
| return x; | |||
| } | |||
| static void setresonator(RESONATOR *rp, int freq, int bwidth, int init) | |||
| { | |||
| // freq Frequency of resonator in Hz | |||
| @@ -967,7 +936,6 @@ static void setresonator(RESONATOR *rp, int freq, int bwidth, int init) | |||
| } | |||
| #endif | |||
| void InitBreath(void) | |||
| { | |||
| #ifndef PLATFORM_RISCOS | |||
| @@ -981,8 +949,6 @@ void InitBreath(void) | |||
| #endif | |||
| } | |||
| static void SetBreath() | |||
| { | |||
| #ifndef PLATFORM_RISCOS | |||
| @@ -1001,7 +967,6 @@ static void SetBreath() | |||
| #endif | |||
| } | |||
| static int ApplyBreath(void) | |||
| { | |||
| int value = 0; | |||
| @@ -1023,8 +988,6 @@ static int ApplyBreath(void) | |||
| return value; | |||
| } | |||
| int Wavegen() | |||
| { | |||
| unsigned short waveph; | |||
| @@ -1248,7 +1211,6 @@ int Wavegen() | |||
| return 0; | |||
| } | |||
| static int PlaySilence(int length, int resume) | |||
| { | |||
| static int n_samples; | |||
| @@ -1283,8 +1245,6 @@ static int PlaySilence(int length, int resume) | |||
| return 0; | |||
| } | |||
| static int PlayWave(int length, int resume, unsigned char *data, int scale, int amp) | |||
| { | |||
| static int n_samples; | |||
| @@ -1338,7 +1298,6 @@ static int PlayWave(int length, int resume, unsigned char *data, int scale, int | |||
| return 0; | |||
| } | |||
| static int SetWithRange0(int value, int max) | |||
| { | |||
| if (value < 0) | |||
| @@ -1348,7 +1307,6 @@ static int SetWithRange0(int value, int max) | |||
| return value; | |||
| } | |||
| static void SetPitchFormants() | |||
| { | |||
| int ix; | |||
| @@ -1372,7 +1330,6 @@ static void SetPitchFormants() | |||
| wvoice->height[1] = (wvoice->height2[1] * (256 - factor))/256; | |||
| } | |||
| void SetEmbedded(int control, int value) | |||
| { | |||
| // there was an embedded command in the text at this point | |||
| @@ -1400,22 +1357,18 @@ void SetEmbedded(int control, int value) | |||
| case EMBED_P: | |||
| SetPitchFormants(); | |||
| break; | |||
| case EMBED_A: // amplitude | |||
| general_amplitude = GetAmplitude(); | |||
| break; | |||
| case EMBED_F: // emphasis | |||
| general_amplitude = GetAmplitude(); | |||
| break; | |||
| case EMBED_H: | |||
| WavegenSetEcho(); | |||
| break; | |||
| } | |||
| } | |||
| void WavegenSetVoice(voice_t *v) | |||
| { | |||
| static voice_t v2; | |||
| @@ -1438,7 +1391,6 @@ void WavegenSetVoice(voice_t *v) | |||
| MarkerEvent(espeakEVENT_SAMPLERATE, 0, wvoice->samplerate, 0, out_ptr); | |||
| } | |||
| static void SetAmplitude(int length, unsigned char *amp_env, int value) | |||
| { | |||
| amp_ix = 0; | |||
| @@ -1453,7 +1405,6 @@ static void SetAmplitude(int length, unsigned char *amp_env, int value) | |||
| amplitude_env = amp_env; | |||
| } | |||
| void SetPitch2(voice_t *voice, int pitch1, int pitch2, int *pitch_base, int *pitch_range) | |||
| { | |||
| int x; | |||
| @@ -1483,7 +1434,6 @@ void SetPitch2(voice_t *voice, int pitch1, int pitch2, int *pitch_base, int *pit | |||
| *pitch_range = base + (pitch2 * range)/2 - *pitch_base; | |||
| } | |||
| void SetPitch(int length, unsigned char *env, int pitch1, int pitch2) | |||
| { | |||
| // length in samples | |||
| @@ -1502,13 +1452,8 @@ void SetPitch(int length, unsigned char *env, int pitch1, int pitch2) | |||
| wdata.pitch = ((wdata.pitch_env[0] * wdata.pitch_range) >>8) + wdata.pitch_base; // Hz << 12 | |||
| flutter_amp = wvoice->flutter; | |||
| } | |||
| void SetSynth(int length, int modn, frame_t *fr1, frame_t *fr2, voice_t *v) | |||
| { | |||
| int ix; | |||
| @@ -1594,7 +1539,6 @@ void SetSynth(int length, int modn, frame_t *fr1, frame_t *fr2, voice_t *v) | |||
| } | |||
| } | |||
| static int Wavegen2(int length, int modulation, int resume, frame_t *fr1, frame_t *fr2) | |||
| { | |||
| if (resume == 0) | |||
| @@ -1614,8 +1558,6 @@ void Write4Bytes(FILE *f, int value) | |||
| } | |||
| } | |||
| int WavegenFill2(int fill_zeros) | |||
| { | |||
| // Pick up next wavegen commands from the queue | |||
| @@ -1654,7 +1596,6 @@ int WavegenFill2(int fill_zeros) | |||
| case WCMD_PITCH: | |||
| SetPitch(length, (unsigned char *)q[2], q[3] >> 16, q[3] & 0xffff); | |||
| break; | |||
| case WCMD_PAUSE: | |||
| if (resume == 0) | |||
| echo_complete -= length; | |||
| @@ -1665,7 +1606,6 @@ int WavegenFill2(int fill_zeros) | |||
| #endif | |||
| result = PlaySilence(length, resume); | |||
| break; | |||
| case WCMD_WAVE: | |||
| echo_complete = echo_length; | |||
| wdata.n_mix_wavefile = 0; | |||
| @@ -1674,7 +1614,6 @@ int WavegenFill2(int fill_zeros) | |||
| #endif | |||
| result = PlayWave(length, resume, (unsigned char *)q[2], q[3] & 0xff, q[3] >> 8); | |||
| break; | |||
| case WCMD_WAVE2: | |||
| // wave file to be played at the same time as synthesis | |||
| wdata.mix_wave_amp = q[3] >> 8; | |||
| @@ -1689,14 +1628,12 @@ int WavegenFill2(int fill_zeros) | |||
| wdata.mix_wavefile_offset = 0; | |||
| wdata.mix_wavefile = (unsigned char *)q[2]; | |||
| break; | |||
| case WCMD_SPECT2: // as WCMD_SPECT but stop any concurrent wave file | |||
| wdata.n_mix_wavefile = 0; // ... and drop through to WCMD_SPECT case | |||
| case WCMD_SPECT: | |||
| echo_complete = echo_length; | |||
| result = Wavegen2(length & 0xffff, q[1] >> 16, resume, (frame_t *)q[2], (frame_t *)q[3]); | |||
| break; | |||
| #ifdef INCLUDE_KLATT | |||
| case WCMD_KLATT2: // as WCMD_SPECT but stop any concurrent wave file | |||
| wdata.n_mix_wavefile = 0; // ... and drop through to WCMD_SPECT case | |||
| @@ -1705,36 +1642,29 @@ int WavegenFill2(int fill_zeros) | |||
| result = Wavegen_Klatt2(length & 0xffff, q[1] >> 16, resume, (frame_t *)q[2], (frame_t *)q[3]); | |||
| break; | |||
| #endif | |||
| case WCMD_MARKER: | |||
| marker_type = q[0] >> 8; | |||
| MarkerEvent(marker_type, q[1], q[2], q[3], out_ptr); | |||
| if (marker_type == 1) // word marker | |||
| current_source_index = q[1] & 0xffffff; | |||
| break; | |||
| case WCMD_AMPLITUDE: | |||
| SetAmplitude(length, (unsigned char *)q[2], q[3]); | |||
| break; | |||
| case WCMD_VOICE: | |||
| WavegenSetVoice((voice_t *)q[2]); | |||
| free((voice_t *)q[2]); | |||
| break; | |||
| case WCMD_EMBEDDED: | |||
| SetEmbedded(q[1], q[2]); | |||
| break; | |||
| case WCMD_MBROLA_DATA: | |||
| result = MbrolaFill(length, resume, (general_amplitude * wvoice->voicing)/64); | |||
| break; | |||
| case WCMD_FMT_AMPLITUDE: | |||
| if ((wdata.amplitude_fmt = q[1]) == 0) | |||
| wdata.amplitude_fmt = 100; // percentage, but value=0 means 100% | |||
| break; | |||
| #if HAVE_SONIC_H | |||
| case WCMD_SONIC_SPEED: | |||
| sonicSpeed = (double)q[1] / 1024; | |||
| @@ -1752,7 +1682,6 @@ int WavegenFill2(int fill_zeros) | |||
| return 0; | |||
| } | |||
| #if HAVE_SONIC_H | |||
| /* Speed up the audio samples with libsonic. */ | |||
| static int SpeedUp(short *outbuf, int length_in, int length_out, int end_of_text) | |||
| @@ -1775,7 +1704,6 @@ static int SpeedUp(short *outbuf, int length_in, int length_out, int end_of_text | |||
| } | |||
| #endif | |||
| /* Call WavegenFill2, and then speed up the output samples. */ | |||
| int WavegenFill(int fill_zeros) | |||
| { | |||
| @@ -52,8 +52,6 @@ | |||
| #include "voice.h" | |||
| #include "translate.h" | |||
| extern void Write4Bytes(FILE *f, int value); | |||
| char path_home[N_PATH_HOME]; // this is the espeak-data directory | |||
| @@ -123,13 +121,10 @@ static const char *help_text = | |||
| "\t List the available voices for the specified language.\n" | |||
| "\t If <language> is omitted, then list all voices.\n"; | |||
| void DisplayVoices(FILE *f_out, char *language); | |||
| USHORT voice_pcnt[N_PEAKS+1][3]; | |||
| void DisplayVoices(FILE *f_out, char *language) | |||
| { | |||
| int ix; | |||
| @@ -190,7 +185,6 @@ void DisplayVoices(FILE *f_out, char *language) | |||
| } | |||
| } | |||
| static int OpenWaveFile(const char *path, int rate) | |||
| { | |||
| // Set the length of 0x7ffff000 for --stdout | |||
| @@ -228,9 +222,6 @@ static int OpenWaveFile(const char *path, int rate) | |||
| return 1; | |||
| } | |||
| static void CloseWaveFile() | |||
| { | |||
| unsigned int pos; | |||
| @@ -250,12 +241,8 @@ static void CloseWaveFile() | |||
| fclose(f_wave); | |||
| f_wave = NULL; | |||
| } | |||
| static int WavegenFile(void) | |||
| { | |||
| int finished; | |||
| @@ -291,11 +278,8 @@ static int WavegenFile(void) | |||
| return finished; | |||
| } | |||
| static void init_path(char *argv0, char *path_specified) | |||
| { | |||
| if (path_specified) { | |||
| sprintf(path_home, "%s/espeak-data", path_specified); | |||
| return; | |||
| @@ -348,7 +332,6 @@ static void init_path(char *argv0, char *path_specified) | |||
| #endif | |||
| } | |||
| static int initialise(void) | |||
| { | |||
| int param; | |||
| @@ -367,7 +350,6 @@ static int initialise(void) | |||
| } | |||
| #endif | |||
| if ((result = LoadPhData(&srate)) != 1) { | |||
| if (result == -1) { | |||
| fprintf(stderr, "Failed to load espeak-data\n"); | |||
| @@ -386,8 +368,6 @@ static int initialise(void) | |||
| return 0; | |||
| } | |||
| #ifdef NEED_GETOPT | |||
| struct option { | |||
| char *name; | |||
| @@ -525,88 +505,69 @@ int main(int argc, char **argv) | |||
| if ((sscanf(optarg2, "%d", &value) == 1) && (value <= 4)) | |||
| option_multibyte = value; | |||
| break; | |||
| case 'h': | |||
| init_path(argv[0], data_path); | |||
| printf("\nspeak text-to-speech: %s Data at: %s\n%s", version_string, path_home, help_text); | |||
| exit(0); | |||
| case 'k': | |||
| option_capitals = atoi(optarg2); | |||
| break; | |||
| case 'x': | |||
| phoneme_options |= espeakPHONEMES_SHOW; | |||
| break; | |||
| case 'X': | |||
| phoneme_options |= espeakPHONEMES_TRACE; | |||
| break; | |||
| case 'm': | |||
| option_ssml = 1; | |||
| break; | |||
| case 'p': | |||
| pitch_adjustment = atoi(optarg2); | |||
| if (pitch_adjustment > 99) pitch_adjustment = 99; | |||
| break; | |||
| case 'q': | |||
| quiet = 1; | |||
| break; | |||
| case 'f': | |||
| strncpy0(filename, optarg2, sizeof(filename)); | |||
| break; | |||
| case 'l': | |||
| value = 0; | |||
| value = atoi(optarg2); | |||
| option_linelength = value; | |||
| break; | |||
| case 'a': | |||
| amp = atoi(optarg2); | |||
| break; | |||
| case 's': | |||
| speed = atoi(optarg2); | |||
| break; | |||
| case 'g': | |||
| wordgap = atoi(optarg2); | |||
| break; | |||
| case 'v': | |||
| strncpy0(voicename, optarg2, sizeof(voicename)); | |||
| break; | |||
| case 'w': | |||
| option_waveout = 1; | |||
| strncpy0(wavefile, optarg2, sizeof(wavefile)); | |||
| break; | |||
| case 'z': | |||
| option_endpause = 0; | |||
| 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 | |||
| if (optarg2 != NULL) | |||
| strncpy0(voicename, optarg2, sizeof(voicename)); | |||
| flag_compile = c; | |||
| break; | |||
| case 0x103: // --punct | |||
| option_punctuation = 1; | |||
| if (optarg2 != NULL) { | |||
| @@ -616,34 +577,28 @@ int main(int argc, char **argv) | |||
| option_punctuation = 2; | |||
| } | |||
| break; | |||
| case 0x104: // --voices | |||
| init_path(argv[0], data_path); | |||
| DisplayVoices(stdout, optarg2); | |||
| exit(0); | |||
| case 0x106: // -- split | |||
| if (optarg2 == NULL) | |||
| samples_split = 30; // default 30 minutes | |||
| else | |||
| samples_split = atoi(optarg2); | |||
| break; | |||
| case 0x107: // --path | |||
| data_path = optarg2; | |||
| break; | |||
| case 0x108: // --phonout | |||
| if ((f_trans = fopen(optarg2, "w")) == NULL) { | |||
| fprintf(stderr, "Can't write to: %s\n", optarg2); | |||
| f_trans = stderr; | |||
| } | |||
| break; | |||
| case 0x109: // --pho | |||
| phoneme_options |= espeakPHONEMES_MBROLA; | |||
| break; | |||
| case 0x10a: // --ipa | |||
| phoneme_options |= espeakPHONEMES_IPA; | |||
| if (optarg2 != NULL) { | |||
| @@ -662,15 +617,12 @@ int main(int argc, char **argv) | |||
| phoneme_options |= espeakPHONEMES_TIE; | |||
| break; | |||
| } | |||
| } | |||
| break; | |||
| case 0x10b: // --version | |||
| init_path(argv[0], data_path); | |||
| printf("speak text-to-speech: %s Data at: %s\n", version_string, path_home); | |||
| exit(0); | |||
| case 0x10c: // --sep | |||
| phoneme_options |= espeakPHONEMES_SHOW; | |||
| if (optarg2 == 0) | |||
| @@ -680,7 +632,6 @@ int main(int argc, char **argv) | |||
| if (phonemes_separator == 'z') | |||
| phonemes_separator = 0x200c; // ZWNJ | |||
| break; | |||
| case 0x10d: // --tie | |||
| phoneme_options |= (espeakPHONEMES_SHOW | espeakPHONEMES_TIE); | |||
| if (optarg2 == 0) | |||
| @@ -690,7 +641,6 @@ int main(int argc, char **argv) | |||
| if (phonemes_separator == 'z') | |||
| phonemes_separator = 0x200d; // ZWJ | |||
| break; | |||
| default: | |||
| exit(0); | |||
| } | |||
| @@ -732,7 +682,6 @@ int main(int argc, char **argv) | |||
| exit(0); | |||
| } | |||
| SetParameter(espeakRATE, speed, 0); | |||
| SetParameter(espeakVOLUME, amp, 0); | |||
| SetParameter(espeakCAPITALS, option_capitals, 0); | |||