HomoFast-eSpeak-Persian/src/libespeak-ng/synthdata.c

/*
 * Copyright (C) 2005 to 2014 by Jonathan Duddington
 * email: [email protected]
 * Copyright (C) 2015-2017 Reece H. Dunn
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see: <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <espeak-ng/espeak_ng.h>
#include <espeak-ng/speak_lib.h>
#include <espeak-ng/encoding.h>

#include "synthdata.h"
#include "common.h"                    // for GetFileLength
#include "error.h"                    // for create_file_error_context, crea...
#include "phoneme.h"                  // for PHONEME_TAB, PHONEME_TAB_LIST
#include "speech.h"                   // for path_home, PATHSEP
#include "mbrola.h"                   // for mbrola_name
#include "soundicon.h"               // for soundicon_tab
#include "synthesize.h"               // for PHONEME_LIST, frameref_t, PHONE...
#include "translate.h"                // for Translator, LANGUAGE_OPTIONS
#include "voice.h"                    // for ReadTonePoints, tone_points, voice

int n_tunes = 0;
TUNE *tunes = NULL;

const int version_phdata  = 0x014801;

// copy the current phoneme table into here
int n_phoneme_tab;
static int current_phoneme_table;
PHONEME_TAB *phoneme_tab[N_PHONEME_TAB];

static unsigned short *phoneme_index = NULL;
static char *phondata_ptr = NULL;
unsigned char *wavefile_data = NULL;
static unsigned char *phoneme_tab_data = NULL;

static int n_phoneme_tables;
PHONEME_TAB_LIST phoneme_tab_list[N_PHONEME_TABS];
int phoneme_tab_number = 0;

int seq_len_adjust;

static espeak_ng_STATUS ReadPhFile(void **ptr, const char *fname, int *size, espeak_ng_ERROR_CONTEXT *context)
{
	if (!ptr) return EINVAL;

	FILE *f_in;
	int length;
	char buf[sizeof(path_home)+40];

	sprintf(buf, "%s%c%s", path_home, PATHSEP, fname);
	length = GetFileLength(buf);
	if (length < 0) // length == -errno
		return create_file_error_context(context, -length, buf);

	if ((f_in = fopen(buf, "rb")) == NULL)
		return create_file_error_context(context, errno, buf);

	if (*ptr != NULL)
		free(*ptr);

	if ((*ptr = malloc(length)) == NULL) {
		fclose(f_in);
		return ENOMEM;
	}
	if (fread(*ptr, 1, length, f_in) != length) {
		int error = errno;
		fclose(f_in);
		free(*ptr);
		return create_file_error_context(context, error, buf);
	}

	fclose(f_in);
	if (size != NULL)
		*size = length;
	return ENS_OK;
}

espeak_ng_STATUS LoadPhData(int *srate, espeak_ng_ERROR_CONTEXT *context)
{
	int ix;
	int version;
	int length = 0;
	int rate;
	unsigned char *p;

	espeak_ng_STATUS status;
	if ((status = ReadPhFile((void **)&phoneme_tab_data, "phontab", NULL, context)) != ENS_OK)
		return status;
	if ((status = ReadPhFile((void **)&phoneme_index, "phonindex", NULL, context)) != ENS_OK)
		return status;
	if ((status = ReadPhFile((void **)&phondata_ptr, "phondata", NULL, context)) != ENS_OK)
		return status;
	if ((status = ReadPhFile((void **)&tunes, "intonations", &length, context)) != ENS_OK)
		return status;
	wavefile_data = (unsigned char *)phondata_ptr;
	n_tunes = length / sizeof(TUNE);

	// read the version number and sample rate from the first 8 bytes of phondata
	version = 0; // bytes 0-3, version number
	rate = 0;    // bytes 4-7, sample rate
	for (ix = 0; ix < 4; ix++) {
		version += (wavefile_data[ix] << (ix*8));
		rate += (wavefile_data[ix+4] << (ix*8));
	}

	if (version != version_phdata)
		return create_version_mismatch_error_context(context, path_home, version, version_phdata);

	// set up phoneme tables
	p = phoneme_tab_data;
	n_phoneme_tables = p[0];
	p += 4;

	for (ix = 0; ix < n_phoneme_tables; ix++) {
		int n_phonemes = p[0];
		phoneme_tab_list[ix].n_phonemes = p[0];
		phoneme_tab_list[ix].includes = p[1];
		p += 4;
		memcpy(phoneme_tab_list[ix].name, p, N_PHONEME_TAB_NAME);
		p += N_PHONEME_TAB_NAME;
		phoneme_tab_list[ix].phoneme_tab_ptr = (PHONEME_TAB *)p;
		p += (n_phonemes * sizeof(PHONEME_TAB));
	}

	if (phoneme_tab_number >= n_phoneme_tables)
		phoneme_tab_number = 0;

	if (srate != NULL)
		*srate = rate;
	return ENS_OK;
}

void FreePhData(void)
{
	free(phoneme_tab_data);
	free(phoneme_index);
	free(phondata_ptr);
	free(tunes);
	phoneme_tab_data = NULL;
	phoneme_index = NULL;
	phondata_ptr = NULL;
	tunes = NULL;
	current_phoneme_table = -1;
}

int PhonemeCode(unsigned int mnem)
{
	int ix;

	for (ix = 0; ix < n_phoneme_tab; ix++) {
		if (phoneme_tab[ix] == NULL)
			continue;
		if (phoneme_tab[ix]->mnemonic == mnem)
			return phoneme_tab[ix]->code;
	}
	return 0;
}

int LookupPhonemeString(const char *string)
{
	int ix;
	unsigned int mnem;

	// Pack up to 4 characters into a word
	mnem = 0;
	for (ix = 0; ix < 4; ix++) {
		if (string[ix] == 0) break;
		unsigned char c = string[ix];
		mnem |= (c << (ix*8));
	}

	return PhonemeCode(mnem);
}

frameref_t *LookupSpect(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params,  int *n_frames, PHONEME_LIST *plist)
{
	int ix;
	int nf;
	int nf1;
	int seq_break;
	frameref_t *frames;
	int length1;
	SPECT_SEQ *seq, *seq2;
	SPECT_SEQK *seqk, *seqk2;
	frame_t *frame;
	static frameref_t frames_buf[N_SEQ_FRAMES];

	MAKE_MEM_UNDEFINED(&frames_buf, sizeof(frames_buf));

	seq = (SPECT_SEQ *)(&phondata_ptr[fmt_params->fmt_addr]);
	seqk = (SPECT_SEQK *)seq;
	nf = seq->n_frames;

	if (nf >= N_SEQ_FRAMES)
		nf = N_SEQ_FRAMES - 1;

	seq_len_adjust = fmt_params->fmt2_lenadj + fmt_params->fmt_length;
	seq_break = 0;

	for (ix = 0; ix < nf; ix++) {
		if (seq->frame[0].frflags & FRFLAG_KLATT)
			frame = &seqk->frame[ix];
		else
			frame = (frame_t *)&seq->frame[ix];
		frames_buf[ix].frame = frame;
		frames_buf[ix].frflags = frame->frflags;
		frames_buf[ix].length = frame->length;
		if (frame->frflags & FRFLAG_VOWEL_CENTRE)
			seq_break = ix;
	}

	frames = &frames_buf[0];
	if (seq_break > 0) {
		if (which == 1)
			nf = seq_break + 1;
		else {
			frames = &frames_buf[seq_break]; // body of vowel, skip past initial frames
			nf -= seq_break;
		}
	}

	// do we need to modify a frame for blending with a consonant?
	if ((this_ph->type == phVOWEL) && (fmt_params->fmt2_addr == 0) && (fmt_params->use_vowelin))
		seq_len_adjust += FormantTransition2(frames, &nf, fmt_params->transition0, fmt_params->transition1, NULL, which);

	length1 = 0;
	nf1 = nf - 1;
	for (ix = 0; ix < nf1; ix++)
		length1 += frames[ix].length;

	if (fmt_params->fmt2_addr != 0) {
		// a secondary reference has been returned, which is not a wavefile
		// add these spectra to the main sequence
		seq2 = (SPECT_SEQ *)(&phondata_ptr[fmt_params->fmt2_addr]);
		seqk2 = (SPECT_SEQK *)seq2;

		// first frame of the addition just sets the length of the last frame of the main seq
		nf--;
		for (ix = 0; ix < seq2->n_frames; ix++) {
			if (seq2->frame[0].frflags & FRFLAG_KLATT)
				frame = &seqk2->frame[ix];
			else
				frame = (frame_t *)&seq2->frame[ix];

			frames[nf].length = frame->length;
			if (ix > 0) {
				frames[nf].frame = frame;
				frames[nf].frflags = frame->frflags;
			}
			nf++;
		}
	}

	if (length1 > 0) {
		int length_factor;
		if (which == 2) {
			// adjust the length of the main part to match the standard length specified for the vowel
			// less the front part of the vowel and any added suffix

			int length_std = fmt_params->std_length + seq_len_adjust - 45;
			if (length_std < 10)
				length_std = 10;
			if (plist->synthflags & SFLAG_LENGTHEN)
				length_std += (phoneme_tab[phonLENGTHEN]->std_length * 2); // phoneme was followed by an extra : symbol

			// can adjust vowel length for stressed syllables here

			length_factor = (length_std * 256)/ length1;

			for (ix = 0; ix < nf1; ix++)
				frames[ix].length = (frames[ix].length * length_factor)/256;
		} else {
			if (which == 1) {
				// front of a vowel
				if (fmt_params->fmt_control == 1) {
					// This is the default start of a vowel.
					// Allow very short vowels to have shorter front parts
					if (fmt_params->std_length < 130)
						frames[0].length = (frames[0].length * fmt_params->std_length)/130;
				}
			} else {
				// not a vowel
				if (fmt_params->std_length > 0)
					seq_len_adjust += (fmt_params->std_length - length1);
			}

			if (seq_len_adjust != 0) {
				length_factor = ((length1 + seq_len_adjust) * 256)/length1;
				for (ix = 0; ix < nf1; ix++)
					frames[ix].length = (frames[ix].length * length_factor)/256;
			}
		}
	}

	*n_frames = nf;
	return frames;
}

const unsigned char *GetEnvelope(int index)
{
	if (index == 0) {
		fprintf(stderr, "espeak: No envelope\n");
		return envelope_data[0]; // not found, use a default envelope
	}
	return (unsigned char *)&phondata_ptr[index];
}

static void SetUpPhonemeTable(int number)
{
	int ix;
	int includes;
	PHONEME_TAB *phtab;

	if ((includes = phoneme_tab_list[number].includes) > 0) {
		// recursively include base phoneme tables
		SetUpPhonemeTable(includes - 1);
	}

	// now add the phonemes from this table
	phtab = phoneme_tab_list[number].phoneme_tab_ptr;
	for (ix = 0; ix < phoneme_tab_list[number].n_phonemes; ix++) {
		int ph_code = phtab[ix].code;
		phoneme_tab[ph_code] = &phtab[ix];
		if (ph_code > n_phoneme_tab) {
			memset(&phoneme_tab[n_phoneme_tab+1], 0, (ph_code - (n_phoneme_tab+1)) * sizeof(*phoneme_tab));
			n_phoneme_tab = ph_code;
		}
	}
}

void SelectPhonemeTable(int number)
{
	if (current_phoneme_table == number) return;
	n_phoneme_tab = 0;
	MAKE_MEM_UNDEFINED(&phoneme_tab, sizeof(phoneme_tab));
	SetUpPhonemeTable(number); // recursively for included phoneme tables
	n_phoneme_tab++;
	current_phoneme_table = number;
}

int LookupPhonemeTable(const char *name)
{
	int ix;

	for (ix = 0; ix < n_phoneme_tables; ix++) {
		if (strcmp(name, phoneme_tab_list[ix].name) == 0) {
			phoneme_tab_number = ix;
			break;
		}
	}
	if (ix == n_phoneme_tables)
		return -1;

	return ix;
}

int SelectPhonemeTableName(const char *name)
{
	// Look up a phoneme set by name, and select it if it exists
	// Returns the phoneme table number
	int ix;

	if ((ix = LookupPhonemeTable(name)) == -1)
		return -1;

	SelectPhonemeTable(ix);
	return ix;
}

static void InvalidInstn(PHONEME_TAB *ph, int instn)
{
	char buf[5];
	fprintf(stderr, "Invalid instruction %.4x for phoneme '%s'\n", instn, WordToString(buf, ph->mnemonic));
}

static bool StressCondition(Translator *tr, PHONEME_LIST *plist, int condition, int control)
{
	int stress_level;
	PHONEME_LIST *pl;
	static const int condition_level[4] = { 1, 2, 4, 15 };

	if (phoneme_tab[plist[0].phcode]->type == phVOWEL)
		pl = plist;
	else {
		// consonant, get stress from the following vowel
		if (phoneme_tab[plist[1].phcode]->type == phVOWEL)
			pl = &plist[1];
		else
			return false; // no stress elevel for this consonant
	}

	stress_level = pl->stresslevel & 0xf;

	if (tr != NULL) {
		if ((control & 1) && (plist->synthflags & SFLAG_DICTIONARY) && ((tr->langopts.param[LOPT_REDUCE] & 1) == 0)) {
			// change phoneme.  Don't change phonemes which are given for the word in the dictionary.
			return false;
		}

		if ((tr->langopts.param[LOPT_REDUCE] & 0x2) && (stress_level >= pl->wordstress)) {
			// treat the most stressed syllable in an unstressed word as stressed
			stress_level = STRESS_IS_PRIMARY;
		}
	}

	if (condition == STRESS_IS_PRIMARY)
		return stress_level >= pl->wordstress;

	if (condition == STRESS_IS_SECONDARY) {
		if (stress_level > STRESS_IS_SECONDARY)
			return true;
	} else {
		if (stress_level < condition_level[condition])
			return true;
	}
	return false;

}

static int CountVowelPosition(PHONEME_LIST *plist)
{
	int count = 0;

	for (;;) {
		if (plist->ph->type == phVOWEL)
			count++;
		if (plist->sourceix != 0)
			break;
		plist--;
	}
	return count;
}

static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, unsigned short *p_prog, WORD_PH_DATA *worddata)
{
	unsigned int data;
	int instn;
	int instn2;

	// instruction: 2xxx, 3xxx

	// bits 8-10 = 0 to 5,  which phoneme, =6 the 'which' information is in the next instruction.
	// bit 11 = 0, bits 0-7 are a phoneme code
	// bit 11 = 1, bits 5-7 type of data, bits 0-4 data value

	// bits 8-10 = 7,  other conditions

	instn = (*p_prog) & 0xfff;
	data = instn & 0xff;
	instn2 = instn >> 8;

	if (instn2 < 14) {
		PHONEME_LIST *plist_this;
		plist_this = plist;
		int which = (instn2) % 7;

		if (which == 6) {
			// the 'which' code is in the next instruction
			p_prog++;
			which = (*p_prog);
		}

		if (which == 4) {
			// nextPhW not word boundary
			if (plist[1].sourceix)
				return false;
		}
		if (which == 5) {
			// prevPhW, not word boundary
			if (plist[0].sourceix)
				return false;
		}
		if (which == 6) {
			// next2PhW, not word boundary
			if (plist[1].sourceix || plist[2].sourceix)
				return false;
		}

		bool check_endtype = false;
		switch (which)
		{
		case 0: // prevPh
		case 5: // prevPhW
			plist--;
			check_endtype = true;
			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++) {
				if (plist[which].sourceix)
					return false;
				if (phoneme_tab[plist[which].phcode]->type == phVOWEL) {
					plist = &plist[which];
					break;
				}
			}
			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 = true;
			break;
		case 9: // next3PhW
			for (int ix = 1; ix <= 3; ix++) {
				if (plist[ix].sourceix)
					return false;
			}
			plist = &plist[3];
			break;
		case 10: // prev2PhW
			if ((plist[0].sourceix) || (plist[-1].sourceix))
				return false;
			plist -= 2;
			check_endtype = true;
			break;
		}

		if ((which == 0) || (which == 5)) {
			if (plist->phcode == 1) {
				// This is a NULL phoneme, a phoneme has been deleted so look at the previous phoneme
				plist--;
			}
		}

		if (control & 0x100) {
			// "change phonemes" pass
			plist->ph = phoneme_tab[plist->phcode];
		}
		PHONEME_TAB *ph;
		ph = plist->ph;

		if (instn2 < 7) {
			// 'data' is a phoneme number
			if ((phoneme_tab[data]->mnemonic == ph->mnemonic) == true)
				return true;

			//  not an exact match, check for a vowel type (eg. #i )
			if ((check_endtype) && (ph->type == phVOWEL))
				return data == ph->end_type; // prevPh() match on end_type
			return data == ph->start_type; // thisPh() or nextPh(), match on start_type
		}

		data = instn & 0x1f;

		switch (instn & 0xe0)
		{
		case CONDITION_IS_PHONEME_TYPE:
			return ph->type == data;
		case CONDITION_IS_PLACE_OF_ARTICULATION:
			return ((ph->phflags >> 16) & 0xf) == data;
		case CONDITION_IS_PHFLAG_SET:
			return (ph->phflags & (1 << data)) != 0;
		case CONDITION_IS_OTHER:
			switch (data)
			{
			case STRESS_IS_DIMINISHED:
			case STRESS_IS_UNSTRESSED:
			case STRESS_IS_NOT_STRESSED:
			case STRESS_IS_SECONDARY:
			case STRESS_IS_PRIMARY:
				return StressCondition(tr, plist, data, 0);
			case isBreak:
				return (ph->type == phPAUSE) || (plist_this->synthflags & SFLAG_NEXT_PAUSE);
			case isWordStart:
				return plist->sourceix != 0;
			case isWordEnd:
				return plist[1].sourceix || (plist[1].ph->type == phPAUSE);
			case isAfterStress:
				if (plist->sourceix != 0)
					return false;
				do {
					plist--;
					if ((plist->stresslevel & 0xf) >= 4)
						return true;

				} while (plist->sourceix == 0);
				break;
			case isNotVowel:
				return ph->type != phVOWEL;
			case isFinalVowel:
				for (;;) {
					plist++;
					if (plist->sourceix != 0)
						return true; // start of next word, without finding another vowel
					if (plist->ph->type == phVOWEL)
						return false;
				}
			case isVoiced:
				return (ph->type == phVOWEL) || (ph->type == phLIQUID) || (ph->phflags & phVOICED);
			case isFirstVowel:
				return CountVowelPosition(plist) == 1;
			case isSecondVowel:
				return CountVowelPosition(plist) == 2;
			case isTranslationGiven:
				return (plist->synthflags & SFLAG_DICTIONARY) != 0;
			}
			break;

		}
		return false;
	} else if (instn2 == 0xf) {
		// Other conditions
		switch (data)
		{
		case 1: // PreVoicing
			return control & 1;
		case 2: // KlattSynth
			return voice->klattv[0] != 0;
		case 3: // MbrolaSynth
			return mbrola_name[0] != 0;
		}
	}
	return false;
}

static void SwitchOnVowelType(PHONEME_LIST *plist, PHONEME_DATA *phdata, unsigned short **p_prog, int instn_type)
{
	int voweltype;


	if (instn_type == 2) {
		phdata->pd_control |= pd_FORNEXTPH;
		voweltype = plist[1].ph->start_type; // SwitchNextVowelType
	} else
		voweltype = plist[-1].ph->end_type; // SwitchPrevVowelType

	voweltype -= phonVOWELTYPES;
	if ((voweltype >= 0) && (voweltype < 6)) {
		unsigned short *prog;
		signed char x;

		prog = *p_prog + voweltype*2;
		phdata->sound_addr[instn_type] = (((prog[1] & 0xf) << 16) + prog[2]) * 4;
		x = (prog[1] >> 4) & 0xff;
		phdata->sound_param[instn_type] = x; // sign extend
	}

	*p_prog += 12;
}

static int NumInstnWords(unsigned short *prog)
{
	int instn;
	int instn2;
	int instn_type;
	int n;
	int type2;
	static const char n_words[16] = { 0, 1, 0, 0, 1, 1, 0, 1, 1, 2, 4, 0, 0, 0, 0, 0 };

	instn = *prog;
	instn_type = instn >> 12;
	if ((n = n_words[instn_type]) > 0)
		return n;

	switch (instn_type)
	{
	case 0:
		if (((instn & 0xf00) >> 8) == i_IPA_NAME) {
			n = ((instn & 0xff) + 1) / 2;
			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];
		if ((instn2 >> 12) == 0xf) {
			// This instruction is followed by addWav(), 2 more words
			return 4;
		}
		if (instn2 == INSTN_CONTINUE)
			return 3;
		return 2;
	}
}

void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_DATA *phdata, WORD_PH_DATA *worddata)
{
	// control:
	// bit 0:  PreVoicing
	// bit 8:  change phonemes

	PHONEME_TAB *ph;
	unsigned short *prog;
	int or_flag;
	bool truth;
	bool truth2;
	int data;
	int end_flag;
	int ix;
	signed char param_sc;

	#define N_RETURN 10
	int n_return = 0;
	unsigned short *return_addr[N_RETURN]; // return address stack

	ph = plist->ph;

	if ((worddata != NULL) && (plist->sourceix)) {
		// start of a word, reset word data
		worddata->prev_vowel.ph = NULL;
	}

	memset(phdata, 0, sizeof(PHONEME_DATA));
	phdata->pd_param[i_SET_LENGTH] = ph->std_length;
	phdata->pd_param[i_LENGTH_MOD] = ph->length_mod;

	if (ph->program == 0)
		return;

	end_flag = 0;

	for (prog = &phoneme_index[ph->program]; end_flag != 1; prog++) {
		unsigned short instn;
		int instn2;

		instn = *prog;
		instn2 = (instn >> 8) & 0xf;

		switch (instn >> 12)
		{
		case 0: // 0xxx
			data = instn & 0xff;

			if (instn2 == 0) {
				// instructions with no operand
				switch (data)
				{
				case INSTN_RETURN:
					end_flag = 1;
					break;
				case INSTN_CONTINUE:
					break;
				default:
					InvalidInstn(ph, instn);
					break;
				}
			} else if (instn2 == i_APPEND_IFNEXTVOWEL) {
				if (phoneme_tab[plist[1].phcode]->type == phVOWEL)
					phdata->pd_param[i_APPEND_PHONEME] = data;
			} else if (instn2 == i_ADD_LENGTH) {
				if (data & 0x80) {
					// a negative value, do sign extension
					data = -(0x100 - data);
				}
				phdata->pd_param[i_SET_LENGTH] += data;
			} else if (instn2 == i_IPA_NAME) {
				// followed by utf-8 characters, 2 per instn word
				for (ix = 0; (ix < data) && (ix < 16); ix += 2) {
					prog++;
					phdata->ipa_string[ix] = prog[0] >> 8;
					phdata->ipa_string[ix+1] = prog[0] & 0xff;
				}
				phdata->ipa_string[ix] = 0;
			} else if (instn2 < N_PHONEME_DATA_PARAM) {
				phdata->pd_param[instn2] = data;
				if ((instn2 == i_CHANGE_PHONEME) && (control & 0x100)) {
					// found ChangePhoneme() in PhonemeList mode, exit
					end_flag = 1;
				}
			} else
				InvalidInstn(ph, instn);
			break;
		case 1:
			if (tr == NULL)
				break; // ignore if in synthesis stage

			if (instn2 < 8) {
				// ChangeIf
				if (StressCondition(tr, plist, instn2 & 7, 1) == true) {
					phdata->pd_param[i_CHANGE_PHONEME] = instn & 0xff;
					end_flag = 1; // change phoneme, exit
				}
			}
			break;
		case 2:
		case 3:
			// conditions
			or_flag = 0;
			truth = true;
			while ((instn & 0xe000) == 0x2000) {
				// process a sequence of conditions, using  boolean accumulator
				truth2 = InterpretCondition(tr, control, plist, prog, worddata);
				prog += NumInstnWords(prog);
				if (*prog == i_NOT) {
					truth2 = truth2 ^ 1;
					prog++;
				}

				if (or_flag)
					truth = truth || truth2;
				else
					truth = truth && truth2;
				or_flag = instn & 0x1000;
				instn = *prog;
			}

			if (truth == false) {
				if ((instn & 0xf800) == i_JUMP_FALSE)
					prog += instn & 0xff;
				else {
					// instruction after a condition is not JUMP_FALSE, so skip the instruction.
					prog += NumInstnWords(prog);
					if ((prog[0] & 0xfe00) == 0x6000)
						prog++; // and skip ELSE jump
				}
			}
			prog--;
			break;
		case 6:
			// JUMP
			switch (instn2 >> 1)
			{
			case 0:
				prog += (instn & 0xff) - 1;
				break;
			case 4:
				// conditional jumps should have been processed in the Condition section
				break;
			case 5: // NexttVowelStarts
				SwitchOnVowelType(plist, phdata, &prog, 2);
				break;
			case 6: // PrevVowelTypeEndings
				SwitchOnVowelType(plist, phdata, &prog, 3);
				break;
			}
			break;
		case 9:
			data = ((instn & 0xf) << 16) + prog[1];
			prog++;
			switch (instn2)
			{
			case 1:
				// call a procedure or another phoneme
				if (n_return < N_RETURN) {
					return_addr[n_return++] = prog;
					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;
			else
				ix = 2;

			phdata->vowel_transition[ix] = ((prog[0] & 0xff) << 16) + prog[1];
			phdata->vowel_transition[ix+1] = (prog[2] << 16) + prog[3];
			prog += 3;
			break;
		case 11: // FMT
		case 12: // WAV
		case 13: // VowelStart
		case 14: // VowelEnd
		case 15: // addWav
			instn2 = (instn >> 12) - 11;
			phdata->sound_addr[instn2] = ((instn & 0xf) << 18) + (prog[1] << 2);
			param_sc = phdata->sound_param[instn2] = (instn >> 4) & 0xff;
			prog++;

			if (prog[1] != INSTN_CONTINUE) {
				if (instn2 < 2) {
					// FMT() and WAV() imply Return
					end_flag = 1;
					if ((prog[1] >> 12) == 0xf) {
						// Return after the following addWav()
						end_flag = 2;
					}
				} else if (instn2 == pd_ADDWAV) {
					// addWav(), return if previous instruction was FMT() or WAV()
					end_flag--;
				}

				if ((instn2 == pd_VWLSTART) || (instn2 == pd_VWLEND)) {
					// VowelStart or VowelEnding.
					phdata->sound_param[instn2] = param_sc;   // sign extend
				}
			}
			break;
		default:
			InvalidInstn(ph, instn);
			break;
		}

		if ((end_flag == 1) && (n_return > 0)) {
			// return from called procedure or phoneme
			end_flag = 0;
			prog = return_addr[--n_return];
		}
	}

	if ((worddata != NULL) && (plist->type == phVOWEL))
		memcpy(&worddata->prev_vowel, &plist[0], sizeof(PHONEME_LIST));

	plist->std_length = phdata->pd_param[i_SET_LENGTH];
	if (phdata->sound_addr[0] != 0) {
		plist->phontab_addr = phdata->sound_addr[0]; // FMT address
		plist->sound_param = phdata->sound_param[0];
	} else {
		plist->phontab_addr = phdata->sound_addr[1]; // WAV address
		plist->sound_param = phdata->sound_param[1];
	}
}

void InterpretPhoneme2(int phcode, PHONEME_DATA *phdata)
{
	// Examine the program of a single isolated phoneme
	int ix;
	PHONEME_LIST plist[4];
	memset(plist, 0, sizeof(plist));

	for (ix = 0; ix < 4; ix++) {
		plist[ix].phcode = phonPAUSE;
		plist[ix].ph = phoneme_tab[phonPAUSE];
	}

	plist[1].phcode = phcode;
	plist[1].ph = phoneme_tab[phcode];
	plist[2].sourceix = 1;

	InterpretPhoneme(NULL, 0, &plist[1], phdata, NULL);
}