[1.31.07]

intonation: changed comma intonation for intonation type 2.
intonation: adjusted exclamation (make the nuclear syllable emphasized).
intonation: split intonation table into body and nucleus parts.
lang-zh: only length tones 2,3 at end of sentence.


git-svn-id: https://espeak.svn.sourceforge.net/svnroot/espeak/trunk@137 d46cf337-b52f-0410-862d-fd96e6ae7743
This commit is contained in:
jonsd
2008-02-08 10:38:45 +00:00
parent e5ada07055
commit 39e8e1dcb6
25 changed files with 357 additions and 368 deletions
+3 -100
View File
@@ -83,6 +83,7 @@ extern int Read4Bytes(FILE *f);
extern void MakeVowelLists(void);
extern void FindPhonemesUsed(void);
extern void DrawEnvelopes();
extern int LoadEnvelope2(FILE *f, const char *fname);
extern int CompileDictionary(const char *dsource, const char *dict_name, FILE *log, char *fname, int flags);
static int markers_used[8];
@@ -101,6 +102,7 @@ typedef struct {
int n_envelopes = 0;
char envelope_paths[N_ENVELOPES][80];
unsigned char envelope_dat[N_ENVELOPES][ENV_LEN];
FILE *f_phdata;
@@ -132,7 +134,6 @@ private:
int LoadSpect(const char *path, int control);
int LoadWavefile(FILE *f, const char *fname);
int LoadEnvelope(FILE *f, const char *fname);
int LoadEnvelope2(FILE *f, const char *fname);
int LoadDataFile(const char *path, int control);
int AddSpect(int phcode, int *list, int control);
void AddSpectList(int *list, int control);
@@ -142,7 +143,6 @@ private:
FILE *f_in;
FILE *f_phdata;
FILE *f_phcontents;
FILE *f_errors;
FILE *f_phindex;
@@ -1707,105 +1707,8 @@ void Compile::CPhonemeFiles()
} // end of CPhonemeFiles
//#define MAKE_ENVELOPES
#ifdef MAKE_ENVELOPES
#define ENV_LEN 128
void MakeEnvelope(unsigned char *env, float *points_x, float *points_y)
{//====================================================================
int ix = -1;
int x,y;
for(x=0; x<ENV_LEN; x++)
{
if(x > points_x[ix+4])
ix++;
y = (int)polint(&points_x[ix],&points_y[ix],4,x);
if(y < 0) y = 0;
if(y > 255) y = 255;
env[x] = y;
}
}
static float env1_x[]={0,0x30,0x40,ENV_LEN};
static float env1_y[]={0,200,255,255};
static float env2_x[]={0,0x28,0x48,0x60,ENV_LEN};
static float env2_y[]={255,0xe0,0xc0,0x60,0};
static float env3_x[]={0,0x18,0x30,ENV_LEN};
static float env3_y[]={0,0x28,0x50,255};
static float env4_x[]={0,0x20,0x40,0x60,ENV_LEN};
static float env4_y[]={255,0x70,0,0x70,255};
static float env5_x[]={0,0x20,0x40,0x58,0x70,ENV_LEN};
static float env5_y[]={0,0x28,0x50,0xa0,0xf0,255};
static float env6_x[]={0,0x20,0x38,0x60,ENV_LEN};
static float env6_y[]={255,0xe8,0xd0,0x68,0};
static float env7_x[]={0,0x20,0x40,0x60,ENV_LEN}; // 214
static float env7_y[]={85,42,0,128,255};
static float env8_x[]={0,0x20,0x40,0x60,ENV_LEN}; // 211
static float env8_y[]={255,130,20,10,0};
static float env9_x[]={0,0x20,0x40,0x60,ENV_LEN}; // 51 fall
static float env9_y[]={255,210,140,70,0};
static float enva3_x[]={0,44,64,84,ENV_LEN}; // amp env for broken tone
static float enva3_y[]={255,255,160,255,255};
static float enva6_x[]={0,44,64,80,ENV_LEN}; // amp env for drop tone
static float enva6_y[]={255,255,255,250,50};
unsigned char env_test[ENV_LEN];
void MakeEnvFile(char *fname, float *x, float *y, int source)
{//==========================================================
static char hdr[12] = {'P','I','T','C','H','E','N','V',80,0,120,0};
FILE *f;
int ix;
MakeEnvelope(env_test,x,y);
f = fopen(fname,"wb");
if(source)
{
for(ix=0; ix<128; ix++)
{
fprintf(f,"0x%.2x,",env_test[ix]);
if((ix & 7) == 7)
fprintf(f,"\n");
}
}
else
{
fwrite(hdr,12,1,f);
fwrite(env_test,128,1,f);
}
fclose(f);
}
void make_envs()
{//=============
MakeEnvFile("p_level",env1_x,env1_y,0);
MakeEnvFile("p_rise",env5_x,env5_y,0);
MakeEnvFile("p_fall",env9_x,env9_y,0);
MakeEnvFile("p_214",env7_x,env7_y,0);
MakeEnvFile("p_211",env8_x,env8_y,0);
MakeEnvFile("vi_2",env2_x,env2_y,0);
MakeEnvFile("vi_5",env3_x,env3_y,0);
MakeEnvFile("p_fallrise",env4_x,env4_y,0);
MakeEnvFile("vi_6",env6_x,env6_y,0);
MakeEnvFile("vi_5amp",enva3_x,enva3_y,0);
MakeEnvFile("vi_6amp",enva6_x,enva6_y,0);
}
#endif
int Compile::LoadEnvelope2(FILE *f, const char *fname)
int LoadEnvelope2(FILE *f, const char *fname)
{//===================================================
int ix;
int n;
+174 -186
View File
@@ -64,11 +64,7 @@ static int tone_pitch_env; /* used to return pitch envelope */
#define PITCHrise 1
#define PITCHfrise 2 // and 3 must be for the varient preceded by 'r'
#define PITCHfrise2 4 // and 5 must be the 'r' variant
#define PITCHdrop 6
#define PITCHdrop2 8
//#define PITCHsemi_r 10
//#define PITCH1fall 11
//#define PITCH1fall2 12
#define PITCHrisefall 6
/* 0 fall */
unsigned char env_fall[128] = {
@@ -132,109 +128,81 @@ static unsigned char env_r_frise2[128] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0e, 0x0f, 0x10, 0x12, 0x13, 0x15, 0x17, 0x18, 0x1a, 0x1c, 0x1e, 0x20 };
static unsigned char env_risefall[128] = {
0x98, 0x99, 0x99, 0x9a, 0x9c, 0x9d, 0x9f, 0xa1, 0xa4, 0xa7, 0xa9, 0xac, 0xb0, 0xb3, 0xb6, 0xba,
0xbe, 0xc1, 0xc5, 0xc9, 0xcd, 0xd1, 0xd4, 0xd8, 0xdc, 0xdf, 0xe3, 0xe6, 0xea, 0xed, 0xf0, 0xf2,
0xf5, 0xf7, 0xf9, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfd,
0xfb, 0xfa, 0xf8, 0xf6, 0xf3, 0xf1, 0xee, 0xec, 0xe9, 0xe6, 0xe4, 0xe0, 0xdd, 0xda, 0xd7, 0xd3,
0xd0, 0xcc, 0xc8, 0xc4, 0xc0, 0xbc, 0xb8, 0xb4, 0xb0, 0xac, 0xa7, 0xa3, 0x9f, 0x9a, 0x96, 0x91,
0x8d, 0x88, 0x84, 0x7f, 0x7b, 0x76, 0x72, 0x6d, 0x69, 0x65, 0x60, 0x5c, 0x58, 0x54, 0x50, 0x4c,
0x48, 0x44, 0x40, 0x3c, 0x39, 0x35, 0x32, 0x2f, 0x2b, 0x28, 0x26, 0x23, 0x20, 0x1d, 0x1a, 0x17,
0x15, 0x12, 0x0f, 0x0d, 0x0a, 0x08, 0x07, 0x05, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
/*
unsigned char env_drop[128] = {
0xff, 0xf9, 0xf4, 0xee, 0xe9, 0xe4, 0xdf, 0xda, 0xd5, 0xd0, 0xcb, 0xc6, 0xc1, 0xbc, 0xb8, 0xb3,
0xaf, 0xaa, 0xa6, 0xa2, 0x9d, 0x99, 0x95, 0x91, 0x8d, 0x89, 0x85, 0x81, 0x7d, 0x79, 0x76, 0x72,
0x6f, 0x6b, 0x68, 0x64, 0x61, 0x5e, 0x5b, 0x58, 0x55, 0x52, 0x4f, 0x4c, 0x49, 0x46, 0x44, 0x41,
0x3e, 0x3c, 0x39, 0x37, 0x35, 0x33, 0x30, 0x2e, 0x2c, 0x2a, 0x28, 0x27, 0x25, 0x23, 0x21, 0x20,
0x1e, 0x1d, 0x1b, 0x1a, 0x19, 0x18, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x10, 0x0f, 0x0e,
0x0e, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x19, 0x1a, 0x1b, 0x1d, 0x1e, 0x20, 0x21, 0x23, 0x24, 0x26, 0x28, 0x2a, 0x2c };
static unsigned char env_rise2[128] = {
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x06, 0x06,
0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x16, 0x17, 0x18, 0x19, 0x1b, 0x1c, 0x1d, 0x1f, 0x20, 0x22, 0x23, 0x25, 0x26, 0x28, 0x29, 0x2b,
0x2d, 0x2f, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x47, 0x49, 0x4b,
0x4e, 0x50, 0x52, 0x55, 0x57, 0x5a, 0x5d, 0x5f, 0x62, 0x65, 0x67, 0x6a, 0x6d, 0x70, 0x73, 0x76,
0x79, 0x7c, 0x7f, 0x82, 0x86, 0x89, 0x8c, 0x90, 0x93, 0x96, 0x9a, 0x9d, 0xa0, 0xa3, 0xa6, 0xa9,
0xac, 0xaf, 0xb2, 0xb5, 0xb8, 0xbb, 0xbe, 0xc1, 0xc4, 0xc7, 0xca, 0xcd, 0xd0, 0xd3, 0xd6, 0xd9,
0xdc, 0xdf, 0xe2, 0xe4, 0xe7, 0xe9, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfb, 0xfd };
static unsigned char env_fall2[128] = {
0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6,
0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf0, 0xf0, 0xef, 0xee, 0xee, 0xed, 0xec, 0xeb,
0xea, 0xea, 0xe9, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0, 0xde, 0xdd, 0xdc, 0xdb,
0xd9, 0xd8, 0xd6, 0xd5, 0xd3, 0xd2, 0xd0, 0xce, 0xcc, 0xcb, 0xc9, 0xc7, 0xc5, 0xc3, 0xc0, 0xbe,
0xbc, 0xb9, 0xb7, 0xb5, 0xb2, 0xaf, 0xad, 0xaa, 0xa7, 0xa4, 0xa1, 0x9e, 0x9a, 0x97, 0x94, 0x90,
0x8d, 0x89, 0x85, 0x81, 0x7d, 0x79, 0x75, 0x71, 0x6d, 0x68, 0x64, 0x61, 0x5e, 0x5b, 0x57, 0x54,
0x51, 0x4d, 0x4a, 0x46, 0x43, 0x40, 0x3c, 0x39, 0x35, 0x32, 0x2e, 0x2a, 0x27, 0x23, 0x1f, 0x1c,
0x18, 0x14, 0x11, 0x0d, 0x0b, 0x09, 0x07, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 };
unsigned char env_r_drop[128] = {
0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc8, 0xc6, 0xc5, 0xc3, 0xc1, 0xbe, 0xbc, 0xb9, 0xb7, 0xb4,
0xb1, 0xae, 0xab, 0xa8, 0xa5, 0xa2, 0x9e, 0x9b, 0x97, 0x94, 0x90, 0x8c, 0x89, 0x85, 0x81, 0x7d,
0x79, 0x75, 0x71, 0x6d, 0x69, 0x65, 0x61, 0x5d, 0x59, 0x55, 0x51, 0x4e, 0x4a, 0x46, 0x42, 0x3e,
0x3b, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2e, 0x2c, 0x2b, 0x29, 0x27, 0x25, 0x24, 0x22, 0x21, 0x1f,
0x1e, 0x1c, 0x1b, 0x1a, 0x19, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x11, 0x10, 0x0f, 0x0e,
0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0f, 0x0f, 0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x23, 0x24, 0x26, 0x28 };
static unsigned char env_fallrise3[128] = {
0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfa, 0xf8, 0xf6, 0xf4, 0xf1, 0xee, 0xeb,
0xe8, 0xe5, 0xe1, 0xde, 0xda, 0xd6, 0xd2, 0xcd, 0xc9, 0xc4, 0xbf, 0xba, 0xb6, 0xb0, 0xab, 0xa6,
0xa1, 0x9c, 0x96, 0x91, 0x8b, 0x86, 0x80, 0x7b, 0x75, 0x6f, 0x6a, 0x64, 0x5f, 0x59, 0x54, 0x4f,
0x49, 0x44, 0x3f, 0x3a, 0x35, 0x30, 0x2b, 0x26, 0x22, 0x1d, 0x19, 0x15, 0x11, 0x0d, 0x0a, 0x07,
0x04, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x05,
0x07, 0x09, 0x0b, 0x0d, 0x10, 0x12, 0x15, 0x18, 0x1b, 0x1e, 0x22, 0x25, 0x29, 0x2d, 0x31, 0x35,
0x3a, 0x3e, 0x43, 0x48, 0x4c, 0x51, 0x57, 0x5b, 0x5e, 0x62, 0x65, 0x68, 0x6b, 0x6e, 0x71, 0x74,
0x76, 0x78, 0x7b, 0x7c, 0x7e, 0x80, 0x81, 0x82, 0x83, 0x83, 0x84, 0x84, 0x83, 0x83, 0x82, 0x81 };
static unsigned char env_fallrise4[128] = {
0x72, 0x72, 0x71, 0x71, 0x70, 0x6f, 0x6d, 0x6c, 0x6a, 0x68, 0x66, 0x64, 0x61, 0x5f, 0x5c, 0x5a,
0x57, 0x54, 0x51, 0x4e, 0x4b, 0x48, 0x45, 0x42, 0x3f, 0x3b, 0x38, 0x35, 0x32, 0x2f, 0x2c, 0x29,
0x26, 0x23, 0x20, 0x1d, 0x1b, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0e, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06,
0x07, 0x07, 0x08, 0x09, 0x0a, 0x0c, 0x0d, 0x0f, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1b, 0x1d, 0x20,
0x23, 0x26, 0x29, 0x2c, 0x2f, 0x33, 0x37, 0x3b, 0x3f, 0x43, 0x47, 0x4c, 0x51, 0x56, 0x5b, 0x60,
0x65, 0x6a, 0x6f, 0x74, 0x79, 0x7f, 0x84, 0x89, 0x8f, 0x95, 0x9b, 0xa1, 0xa7, 0xad, 0xb3, 0xba,
0xc0, 0xc7, 0xce, 0xd5, 0xdc, 0xe3, 0xea, 0xf1, 0xf5, 0xf7, 0xfa, 0xfc, 0xfd, 0xfe, 0xff, 0xff };
unsigned char env_drop2[128] = {
0xff, 0xfc, 0xf9, 0xf6, 0xf3, 0xf0, 0xed, 0xea, 0xe7, 0xe5, 0xe2, 0xdf, 0xdc, 0xda, 0xd7, 0xd5,
0xd2, 0xcf, 0xcd, 0xca, 0xc8, 0xc5, 0xc3, 0xc0, 0xbe, 0xbc, 0xb9, 0xb7, 0xb4, 0xb2, 0xb0, 0xae,
0xab, 0xa9, 0xa7, 0xa5, 0xa3, 0xa1, 0x9f, 0x9d, 0x9b, 0x99, 0x97, 0x95, 0x93, 0x91, 0x8f, 0x8d,
0x8b, 0x89, 0x88, 0x86, 0x84, 0x83, 0x81, 0x7f, 0x7e, 0x7c, 0x7a, 0x79, 0x77, 0x76, 0x74, 0x73,
0x71, 0x70, 0x6f, 0x6d, 0x6c, 0x6a, 0x69, 0x68, 0x67, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60, 0x5f,
0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58, 0x57, 0x56, 0x55, 0x54, 0x54, 0x53, 0x52, 0x51, 0x51,
0x50, 0x4f, 0x4f, 0x4e, 0x4e, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b, 0x4a, 0x4a, 0x4a, 0x49, 0x49,
0x49, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x48 };
unsigned char env_r_drop2[128] = {
0xcf, 0xce, 0xcd, 0xcd, 0xcc, 0xcb, 0xcb, 0xca, 0xc9, 0xc8, 0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2,
0xc1, 0xc0, 0xbf, 0xbd, 0xbc, 0xbb, 0xba, 0xb8, 0xb7, 0xb6, 0xb4, 0xb3, 0xb2, 0xb0, 0xaf, 0xad,
0xac, 0xaa, 0xa9, 0xa7, 0xa6, 0xa4, 0xa3, 0xa1, 0x9f, 0x9e, 0x9c, 0x9a, 0x99, 0x97, 0x96, 0x94,
0x92, 0x91, 0x8f, 0x8d, 0x8c, 0x8a, 0x88, 0x87, 0x85, 0x83, 0x82, 0x80, 0x7e, 0x7d, 0x7b, 0x7a,
0x78, 0x76, 0x75, 0x73, 0x72, 0x70, 0x6f, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68, 0x68, 0x67, 0x66,
0x65, 0x64, 0x63, 0x62, 0x61, 0x60, 0x5f, 0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5b, 0x5a, 0x59, 0x58,
0x58, 0x57, 0x56, 0x56, 0x55, 0x54, 0x54, 0x53, 0x52, 0x52, 0x51, 0x51, 0x50, 0x4f, 0x4f, 0x4e,
0x4e, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b, 0x4b, 0x4a, 0x4a, 0x49, 0x49, 0x49, 0x48, 0x48, 0x48 };
// 10 semi_r
unsigned char env_semi_r[128] = {
0x00, 0x01, 0x02, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0b, 0x0c, 0x0e, 0x0f, 0x11, 0x12, 0x14, 0x15,
0x17, 0x18, 0x1a, 0x1b, 0x1d, 0x1f, 0x20, 0x22, 0x23, 0x25, 0x27, 0x28, 0x2a, 0x2c, 0x2d, 0x2f,
0x31, 0x33, 0x35, 0x37, 0x39, 0x3b, 0x3d, 0x3f, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50,
0x52, 0x54, 0x57, 0x59, 0x5b, 0x5d, 0x5f, 0x61, 0x63, 0x65, 0x67, 0x69, 0x6c, 0x6e, 0x70, 0x72,
0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x87, 0x89, 0x8b, 0x8d, 0x8f, 0x90,
0x92, 0x94, 0x96, 0x97, 0x99, 0x9b, 0x9c, 0x9e, 0x9f, 0xa1, 0xa2, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xad, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3,
0xb4, 0xb4, 0xb4, 0xb5, 0xb5, 0xb6, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb8 };
// 11 drop3
unsigned char env_drop3[128] = {
0xff, 0xf8, 0xf2, 0xec, 0xe7, 0xe1, 0xdb, 0xd5, 0xd0, 0xca, 0xc5, 0xc0, 0xbb, 0xb5, 0xb1, 0xac,
0xa7, 0xa3, 0x9e, 0x9b, 0x97, 0x93, 0x90, 0x8c, 0x89, 0x86, 0x83, 0x80, 0x7d, 0x7b, 0x78, 0x76,
0x73, 0x71, 0x6f, 0x6d, 0x6b, 0x68, 0x66, 0x64, 0x62, 0x5f, 0x5d, 0x5b, 0x59, 0x57, 0x56, 0x54,
0x52, 0x50, 0x4e, 0x4d, 0x4b, 0x49, 0x48, 0x46, 0x44, 0x43, 0x41, 0x40, 0x3e, 0x3d, 0x3b, 0x3a,
0x39, 0x37, 0x35, 0x34, 0x32, 0x31, 0x2f, 0x2d, 0x2c, 0x2a, 0x29, 0x28, 0x26, 0x25, 0x23, 0x22,
0x21, 0x1f, 0x1e, 0x1d, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f,
0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x0a, 0x09, 0x08, 0x08, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04,
0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
// 12 r_drop3
unsigned char env_r_drop3[128] = {
0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc8, 0xc7, 0xc5, 0xc4, 0xc2, 0xc0, 0xbe, 0xbc, 0xba, 0xb8,
0xb5, 0xb3, 0xb1, 0xae, 0xac, 0xa9, 0xa6, 0xa4, 0xa1, 0x9e, 0x9b, 0x98, 0x95, 0x92, 0x8f, 0x8c,
0x89, 0x86, 0x83, 0x80, 0x7d, 0x7a, 0x76, 0x73, 0x70, 0x6d, 0x6a, 0x67, 0x63, 0x60, 0x5d, 0x5a,
0x57, 0x54, 0x51, 0x4e, 0x4b, 0x48, 0x45, 0x43, 0x40, 0x3d, 0x3b, 0x39, 0x37, 0x36, 0x34, 0x33,
0x32, 0x30, 0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11,
0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0c, 0x0b, 0x0b, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07, 0x06,
0x06, 0x05, 0x05, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 };
*/
// long vowel fall
static unsigned char env_long_fall[128] = {
254,249,250,251,252,253,254,254, 255,255,255,255,254,254,253,252,
251,250,249,247,244,242,238,234, 230,225,221,217,213,209,206,203,
199,195,191,187,183,179,175,172, 168,165,162,159,156,153,150,148,
145,143,140,138,136,134,132,130, 128,126,123,120,117,114,111,107,
104,100,96,91, 86,82,77,73, 70,66,63,60, 58,55,53,51,
49,47,46,45, 43,42,40,38, 36,34,31,28, 26,24,22,20,
18,16,14,12, 11,10,9,8, 8,8,8,8, 9,8,8,8,
8,8,7,7, 6,6,6,5, 4,4,3,3, 2,1,1,0 };
static unsigned char env_risefallrise[128] = {
0x7f, 0x7f, 0x7f, 0x80, 0x81, 0x83, 0x84, 0x87, 0x89, 0x8c, 0x8f, 0x92, 0x96, 0x99, 0x9d, 0xa1,
0xa5, 0xaa, 0xae, 0xb2, 0xb7, 0xbb, 0xc0, 0xc5, 0xc9, 0xcd, 0xd2, 0xd6, 0xda, 0xde, 0xe2, 0xe6,
0xea, 0xed, 0xf0, 0xf3, 0xf5, 0xf8, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xfd, 0xfc, 0xfb, 0xf9,
0xf7, 0xf4, 0xf0, 0xec, 0xe7, 0xe2, 0xdc, 0xd5, 0xce, 0xc6, 0xbd, 0xb4, 0xa9, 0x9e, 0x92, 0x88,
0x82, 0x7d, 0x77, 0x72, 0x6c, 0x66, 0x60, 0x5a, 0x54, 0x4e, 0x49, 0x42, 0x3c, 0x37, 0x32, 0x2d,
0x28, 0x24, 0x1f, 0x1b, 0x18, 0x14, 0x11, 0x0e, 0x0c, 0x09, 0x07, 0x06, 0x05, 0x04, 0x04, 0x04,
0x04, 0x05, 0x06, 0x08, 0x0a, 0x0d, 0x10, 0x14, 0x18, 0x1d, 0x23, 0x29, 0x2f, 0x37, 0x3e, 0x47,
0x50, 0x5a, 0x64, 0x70, 0x7c, 0x83, 0x85, 0x88, 0x8a, 0x8c, 0x8e, 0x8f, 0x91, 0x92, 0x93, 0x93 };
unsigned char *envelope_data[16] = {
env_fall, env_rise, env_frise, env_r_frise,
unsigned char *envelope_data[18] = {
env_fall,
env_rise,
env_frise, env_r_frise,
env_frise2, env_r_frise2,
env_risefall, env_risefall,
env_long_fall, env_long_fall, env_fall, env_fall,
env_fall, env_fall, env_fall, env_fall,
env_fall, env_fall
env_fallrise3, env_fallrise3,
env_fallrise4, env_fallrise4,
env_fall2, env_fall2,
env_rise2, env_rise2,
env_risefallrise, env_risefallrise
};
@@ -251,15 +219,12 @@ static short oflow_less[] = {3, 19, 12, 7, 2};
static short oflow_test2[] = {20, 0, 20, 0, 20};
static short back_emf[] = {35, 32, 0};
#define N_TONE_HEAD_TABLE 13
#define N_TONE_NUCLEUS_TABLE 13
typedef struct {
unsigned char pitch_env0; /* pitch envelope, tonic syllable at end */
unsigned char tonic_max0;
unsigned char tonic_min0;
unsigned char pitch_env1; /* followed by unstressed */
unsigned char tonic_max1;
unsigned char tonic_min1;
unsigned char pre_start;
unsigned char pre_end;
@@ -272,56 +237,59 @@ typedef struct {
char n_overflow;
short *overflow;
} TONE_HEAD;
typedef struct {
unsigned char pitch_env0; /* pitch envelope, tonic syllable at end */
unsigned char tonic_max0;
unsigned char tonic_min0;
unsigned char pitch_env1; /* followed by unstressed */
unsigned char tonic_max1;
unsigned char tonic_min1;
short *backwards;
unsigned char tail_start;
unsigned char tail_end;
unsigned char tail_shape;
} TONE_TABLE;
unsigned char flags;
} TONE_NUCLEUS;
#define N_TONE_TABLE 13
#define T_EMPH 1
static TONE_TABLE tone_table[N_TONE_TABLE] = {
{PITCHfall, 30, 5, PITCHfall, 30, 8, // 0 statement
20, 25, 34, 22, drops_0, 3, 3, 5, oflow, NULL, 12, 7, 0},
{PITCHfrise, 35,8, PITCHfrise2, 35,10, // 1 comma
20, 25, 34, 20, drops_0, 3, 3, 5, oflow, NULL, 15, 23, 0},
{PITCHfrise, 39,10, PITCHfrise2, 36,10, // 2 question
20, 25, 34, 20, drops_0, 3, 3, 5, oflow, NULL, 15, 28, 0},
{PITCHfall, 41, 4, PITCHfall, 41, 27, // 3 exclamation
20, 25, 36, 22, drops_0, 3, 4, 5, oflow_emf, back_emf, 16, 4, 0},
{PITCHfall, 38, 2, PITCHfall, 42, 30, // 4 statement, emphatic
20, 25, 34, 22, drops_0, 3, 3, 5, oflow, NULL, 15, 5, 0},
{PITCHfall, 28, 5, PITCHfall, 28, 9, // 5 statement, less intonation
20, 25, 32, 24, drops_0, 4, 3, 5, oflow_less, NULL, 12, 7, 0},
{PITCHfrise2, 32,8, PITCHfrise2, 28,9, // 6 comma, less intonation
20, 25, 32, 24, drops_0, 4, 3, 5, oflow_less, NULL, 10,16, 0},
{PITCHfrise2, 28, 7, PITCHfall, 29, 14, // 7 comma, less intonation, less rise
20, 25, 32, 24, drops_0, 4, 3, 5, oflow_less, NULL, 14, 8, 0},
{PITCHrise, 30, 20, PITCHfall, 19, 14, // 8 pitch raises at end of sentence
20, 25, 34, 22, drops_0, 3, 3, 5, oflow, NULL, 20, 26, 0},
{PITCHfrise, 35,11, PITCHfrise2, 32,10, // 9 comma
20, 25, 34, 20, drops_0, 3, 3, 5, oflow, NULL, 19, 24, 0},
{PITCHfrise, 39, 15, PITCHfall, 28, 14, // 10 question
20, 25, 34, 22, drops_0, 3, 3, 5, oflow, NULL, 20, 36, 0},
{PITCHfall, 28, 6, PITCHfall, 28, 10, // 11 test
20, 25, 24, 22, drops_0, 3, 3, 5, oflow_less, NULL, 12, 6, 0},
{PITCHfall, 35, 9, PITCHfall, 35, 12, // 12 test
19, 26, 36, 20, drops_0, 2, 4, 5, oflow_test2, NULL, 16, 10, 0},
static TONE_HEAD tone_head_table[N_TONE_HEAD_TABLE] = {
{20, 25, 34, 22, drops_0, 3, 3, 5, oflow}, // 0 statement
{20, 25, 34, 20, drops_0, 3, 3, 5, oflow}, // 1 comma
{20, 25, 34, 20, drops_0, 3, 3, 5, oflow}, // 2 question
{20, 25, 36, 22, drops_0, 3, 4, 5, oflow_emf}, // 3 exclamation
{20, 25, 34, 22, drops_0, 3, 3, 5, oflow}, // 4 statement, emphatic
{20, 25, 32, 24, drops_0, 4, 3, 5, oflow_less}, // 5 statement, less intonation
{20, 25, 32, 24, drops_0, 4, 3, 5, oflow_less}, // 6 comma, less intonation
{20, 25, 32, 24, drops_0, 4, 3, 5, oflow_less}, // 7 comma, less intonation, less rise
{20, 25, 34, 22, drops_0, 3, 3, 5, oflow}, // 8 pitch raises at end of sentence
{20, 25, 34, 20, drops_0, 3, 3, 5, oflow}, // 9 comma
{20, 25, 34, 22, drops_0, 3, 3, 5, oflow}, // 10 question
{20, 25, 24, 22, drops_0, 3, 3, 5, oflow_less}, // 11 test
{19, 26, 36, 20, drops_0, 2, 4, 5, oflow_test2}, // 12 test
};
static TONE_NUCLEUS tone_nucleus_table[N_TONE_NUCLEUS_TABLE] = {
{PITCHfall, 30, 5, PITCHfall, 30, 8, NULL, 12, 7, 0}, // 0 statement
{PITCHfrise, 35, 8, PITCHfrise2, 35,10, NULL, 15, 23, 0}, // 1 comma
{PITCHfrise, 39,10, PITCHfrise2, 36,10, NULL, 15, 28, 0}, // 2 question
// {PITCHfall, 41, 4, PITCHfall, 41,27, NULL, 16, 4, T_EMPH}, // 3 exclamation
{PITCHfall, 43, 3, PITCHfall, 45,35, NULL, 35, 4, T_EMPH}, // 3 exclamation
// {PITCHrisefall,47, 8, PITCHrise, 48,30, NULL, 48, 5, T_EMPH}, // 3 exclamation
{PITCHfall, 38, 2, PITCHfall, 42,30, NULL, 15, 5, 0}, // 4 statement, emphatic
{PITCHfall, 28, 5, PITCHfall, 28, 9, NULL, 12, 7, 0}, // 5 statement, less intonation
{PITCHfrise, 30, 8, PITCHfrise2, 30,10, NULL, 13, 20, 0}, // 6 comma, less intonation
{PITCHfrise2, 28, 7, PITCHfall, 29,14, NULL, 14, 8, 0}, // 7 comma, less intonation, less rise
{PITCHrise, 30,20, PITCHfall, 19,14, NULL, 20, 26, 0}, // 8 pitch raises at end of sentence
{PITCHfrise, 35,11, PITCHfrise2, 32,10, NULL, 19, 24, 0}, // 9 comma
{PITCHfrise, 39,15, PITCHfall, 28,14, NULL, 20, 36, 0}, // 10 question
{PITCHfall, 28, 6, PITCHfall, 28,10, NULL, 12, 6, 0}, // 11 test
{PITCHfall, 35, 9, PITCHfall, 35,12, NULL, 16, 10, 0}, // 12 test
};
@@ -330,8 +298,8 @@ static TONE_TABLE tone_table[N_TONE_TABLE] = {
unsigned char punctuation_to_tone[INTONATION_TYPES][PUNCT_INTONATIONS] = {
{0,1,2,3,0,4},
{0,1,2,3,0,4},
{5,6,2,0,0,4},
{5,7,1,0,0,4},
{5,6,2,3,0,4},
{5,7,1,3,0,4},
{8,9,10,3,0,0},
{8,8,10,3,0,0},
{11,11,11,11,0,0}, // 6 test
@@ -485,7 +453,7 @@ static void set_pitch(SYLLABLE *syl, int base, int drop)
static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress, int continuing)
static int calc_pitch_segment(int ix, int end_ix, TONE_HEAD *th, TONE_NUCLEUS *tn, int min_stress, int continuing)
/**********************************************************************************************/
/* Calculate pitches until next RESET or tonic syllable, or end.
Increment pitch if stress is >= min_stress.
@@ -505,7 +473,7 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress,
static short continue_tab[5] = {-13, 16, 10, 4, 0};
drops = t->body_drops;
drops = th->body_drops;
if(continuing)
{
@@ -513,13 +481,13 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress,
overflow = 0;
n_overflow = 5;
overflow_tab = continue_tab;
increment = (t->body_end - t->body_start) << 8;
increment = increment / (t->body_max_steps -1);
increment = (th->body_end - th->body_start) << 8;
increment = increment / (th->body_max_steps -1);
}
else
{
n_overflow = t->n_overflow;
overflow_tab = t->overflow;
n_overflow = th->n_overflow;
overflow_tab = th->overflow;
initial = 1;
}
@@ -541,18 +509,18 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress,
overflow = 0;
n_steps = n_primary = count_increments(ix,end_ix,min_stress);
if(n_steps > t->body_max_steps)
n_steps = t->body_max_steps;
if(n_steps > th->body_max_steps)
n_steps = th->body_max_steps;
if(n_steps > 1)
{
increment = (t->body_end - t->body_start) << 8;
increment = (th->body_end - th->body_start) << 8;
increment = increment / (n_steps -1);
}
else
increment = 0;
pitch = t->body_start << 8;
pitch = th->body_start << 8;
}
else
{
@@ -560,11 +528,11 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress,
pitch += increment;
else
{
pitch = (t->body_end << 8) - (increment * overflow_tab[overflow++])/16;
pitch = (th->body_end << 8) - (increment * overflow_tab[overflow++])/16;
if(overflow >= n_overflow)
{
overflow = 0;
overflow_tab = t->overflow;
overflow_tab = th->overflow;
}
}
}
@@ -572,9 +540,9 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress,
n_steps--;
n_primary--;
if((t->backwards) && (n_primary < 2))
if((tn->backwards) && (n_primary < 2))
{
pitch = t->backwards[n_primary] << 8;
pitch = tn->backwards[n_primary] << 8;
}
}
@@ -592,7 +560,7 @@ static int calc_pitch_segment(int ix, int end_ix, TONE_TABLE *t, int min_stress,
{
/* unstressed, drop pitch if preceded by PRIMARY */
if((syllable_tab[ix-1].stress & 0x3f) >= SECONDARY)
set_pitch(syl,pitch - (t->body_lower_u << 8), drops[stress]);
set_pitch(syl,pitch - (th->body_lower_u << 8), drops[stress]);
else
set_pitch(syl,pitch,drops[stress]);
}
@@ -646,9 +614,12 @@ static int calc_pitch_segment2(int ix, int end_ix, int start_p, int end_p, int m
drop = -increment;
if(drop < min_drop[stress])
drop = min_drop[stress];
pitch += increment;
set_pitch(syl,pitch,drop);
if(drop > 0x900)
drop = 0x900;
set_pitch(syl, pitch, drop);
}
ix++;
@@ -661,19 +632,21 @@ static int calc_pitch_segment2(int ix, int end_ix, int start_p, int end_p, int m
static int calc_pitches(int start, int end, int group_tone)
/**********************************************************/
/* Calculate pitch values for the vowels in this tone group */
static int calc_pitches(int start, int end, int head_tone, int nucleus_tone)
//===========================================================================
// Calculate pitch values for the vowels in this tone group
{
int ix;
TONE_TABLE *t;
TONE_HEAD *th;
TONE_NUCLEUS *tn;
int drop;
int continuing = 0;
if(start > 0)
continuing = 1;
t = &tone_table[group_tone];
th = &tone_head_table[head_tone];
tn = &tone_nucleus_table[nucleus_tone];
ix = start;
/* vowels before the first primary stress */
@@ -681,7 +654,7 @@ static int calc_pitches(int start, int end, int group_tone)
if(number_pre > 0)
{
ix = calc_pitch_segment2(ix, ix+number_pre, t->pre_start, t->pre_end, 0);
ix = calc_pitch_segment2(ix, ix+number_pre, th->pre_start, th->pre_end, 0);
}
/* body of tonic segment */
@@ -691,7 +664,7 @@ static int calc_pitches(int start, int end, int group_tone)
{
tone_posn = tone_posn2; // put tone on the penultimate stressed word
}
ix = calc_pitch_segment(ix,tone_posn, t, PRIMARY, continuing);
ix = calc_pitch_segment(ix,tone_posn, th, tn, PRIMARY, continuing);
if(no_tonic)
return(0);
@@ -699,17 +672,22 @@ static int calc_pitches(int start, int end, int group_tone)
/* tonic syllable */
/******************/
if(tn->flags & T_EMPH)
{
syllable_tab[ix].flags |= SYL_EMPHASIS;
}
if(number_tail == 0)
{
tone_pitch_env = t->pitch_env0;
drop = t->tonic_max0 - t->tonic_min0;
set_pitch(&syllable_tab[ix++],t->tonic_min0 << 8,drop << 8);
tone_pitch_env = tn->pitch_env0;
drop = tn->tonic_max0 - tn->tonic_min0;
set_pitch(&syllable_tab[ix++],tn->tonic_min0 << 8,drop << 8);
}
else
{
tone_pitch_env = t->pitch_env1;
drop = t->tonic_max1 - t->tonic_min1;
set_pitch(&syllable_tab[ix++],t->tonic_min1 << 8,drop << 8);
tone_pitch_env = tn->pitch_env1;
drop = tn->tonic_max1 - tn->tonic_min1;
set_pitch(&syllable_tab[ix++],tn->tonic_min1 << 8,drop << 8);
}
syllable_tab[tone_posn].env = tone_pitch_env;
@@ -719,7 +697,7 @@ static int calc_pitches(int start, int end, int group_tone)
/* tail, after the tonic syllable */
/**********************************/
calc_pitch_segment2(ix, end, t->tail_start, t->tail_end, 0);
calc_pitch_segment2(ix, end, tn->tail_start, tn->tail_end, 0);
return(tone_pitch_env);
} /* end of calc_pitches */
@@ -770,6 +748,8 @@ void Translator::CalcPitches_Tone(int clause_tone)
}
}
phoneme_list[final_stressed].tone = 7;
// language specific, changes to tones
if(translator_name == L('v','i'))
{
@@ -828,6 +808,15 @@ void Translator::CalcPitches_Tone(int clause_tone)
tone_promoted = 0;
}
if(ix == final_stressed)
{
if((tph->mnemonic == 0x3535 ) || (tph->mnemonic == 0x3135))
{
// change sentence final tone 1 or 4 to stress 6, not 7
phoneme_list[final_stressed].tone = 6;
}
}
if(prev_tph->mnemonic == 0x343132) // [214]
{
if(tph->mnemonic == 0x343132) // [214]
@@ -895,7 +884,6 @@ void Translator::CalcPitches_Tone(int clause_tone)
}
}
phoneme_list[final_stressed].tone = 7;
} // end of Translator::CalcPitches_Tone
@@ -1034,9 +1022,9 @@ void Translator::CalcPitches(int clause_type)
count_pitch_vowels(st_start, ix, n_st);
if((ix < n_st) || (clause_type == 0))
calc_pitches(st_start, ix, group_tone_emph); // split into > 1 tone groups, use emphatic tone
calc_pitches(st_start, ix, group_tone_emph, group_tone_emph); // split into > 1 tone groups, use emphatic tone
else
calc_pitches(st_start, ix, group_tone);
calc_pitches(st_start, ix, group_tone, group_tone);
st_start = ix;
}
@@ -1045,7 +1033,7 @@ void Translator::CalcPitches(int clause_type)
// end of clause after this syllable, indicated by a phonPAUSE_CLAUSE phoneme
st_clause_end = st_ix+1;
count_pitch_vowels(st_start, st_clause_end, st_clause_end);
calc_pitches(st_start, st_clause_end, group_tone_comma);
calc_pitches(st_start, st_clause_end, group_tone_comma, group_tone_comma);
st_start = st_clause_end;
}
}
@@ -1053,7 +1041,7 @@ void Translator::CalcPitches(int clause_type)
if(st_start < st_ix)
{
count_pitch_vowels(st_start, st_ix, n_st);
calc_pitches(st_start, st_ix, group_tone);
calc_pitches(st_start, st_ix, group_tone, group_tone);
}
+1 -1
View File
@@ -52,7 +52,7 @@ wxMenuBar *MakeMenu(int type)
file_menu->Append(SPECTSEQ_SAVE, _("&Save"));
file_menu->Append(SPECTSEQ_SAVEAS, _("Save &As"));
file_menu->Append(SPECTSEQ_SAVESELECT, _("Save Selection"));
// file_menu->Append(SPECTSEQ_SAVEPITCH, _T("Save Pitch &Envelope"));
file_menu->Append(SPECTSEQ_SAVEPITCH, _T("Save Pitch &Envelope"));
file_menu->Append(SPECTSEQ_CLOSE, _("&Close"));
// file_menu->Append(MENU_CLOSE_ALL, _T("Close &All"));
}
+10 -3
View File
@@ -79,8 +79,15 @@ void InitProsodyDisplay()
menu_envelopes->Append(0x101,_T("Rise"));
menu_envelopes->Append(0x102,_T("Fall-rise"));
menu_envelopes->Append(0x103,_T("Fall-rise (R)"));
menu_envelopes->Append(0x104,_T("Fall-2"));
menu_envelopes->Append(0x106,_T("Fall-3"));
menu_envelopes->Append(0x104,_T("Fall-rise 2"));
menu_envelopes->Append(0x105,_T("Fall-rise 2(R)"));
menu_envelopes->Append(0x106,_T("Rise-fall"));
menu_envelopes->Append(0x108,_T("Fall-rise 3"));
menu_envelopes->Append(0x10a,_T("Fall-rise 4"));
menu_envelopes->Append(0x10c,_T("Fall 2"));
menu_envelopes->Append(0x10e,_T("Rise 2"));
menu_envelopes->Append(0x110,_T("Rise-fall-rise"));
menu_prosody = new wxMenu;
menu_prosody->Append(1,_T("Pitch envelope"),menu_envelopes);
@@ -353,7 +360,7 @@ void ProsodyDisplay::DrawEnv(wxDC& dc, int x1, int y1, int width, PHONEME_LIST *
for(ix=0; ix<=width; ix+=4)
{
x = int((ix * 127.9)/width);
pitch = ph->pitch1 + (pitchr * env[x])/256;
pitch = p1 + (pitchr * env[x])/256;
y = y1-int(pitch * scaley);
if(ix > 0)
dc.DrawLine(x1+ix-4,y2,x1+ix,y);
+2 -2
View File
@@ -1272,8 +1272,8 @@ static void SetProsodyParameter(int param_type, wchar_t *attr1, PARAM_STACK *sp)
{"x-low",20},
{"low",50},
{"medium",100},
{"high",125},
{"x-high",150},
{"high",140},
{"x-high",180},
{NULL, -1}};
static const MNEM_TAB *mnem_tabs[5] = {
+3
View File
@@ -518,6 +518,8 @@ void Translator::CalcLengths()
{
// tonic syllable, include a constant component so it doesn't decrease directly with speed
length_mod += 20;
if(emphasized)
length_mod += 10;
}
else
if(emphasized)
@@ -564,6 +566,7 @@ if(p->type != phVOWEL)
// set pitch for pre-vocalic part
if(pitch_start - last_pitch > 8) // was 9
last_pitch = pitch_start - 8;
prev->pitch1 = last_pitch;
prev->pitch2 = pitch_start;
if(last_pitch < pitch_start)
+1 -1
View File
@@ -156,7 +156,7 @@ public:
int Save(wxOutputStream& stream, int selection);
int Load(wxInputStream& stream);
void Draw(wxDC &dc, int start_y, int end_y);
void MakePitchenv(PitchEnvelope &pitch);
void MakePitchenv(PitchEnvelope &pitch, int start_frame, int end_frame);
void MakeWave(int start, int end, PitchEnvelope &pitch);
void InterpolatePeaks(int on);
+14 -12
View File
@@ -405,31 +405,33 @@ void SpectDisplay::Save(const wxString &path, int selection)
void SpectDisplay::SavePitchenv(PitchEnvelope &pitch)
{//==============================================
{//==================================================
// save the pitch envelope
int ix;
FILE *f_env;
wxString filename;
char fname[200];
filename = wxFileSelector(_T("(Save pitch envelope"),path_pitches,_T(""),_T(""),_T("*"),wxSAVE);
if(filename.IsEmpty())
return;
wxFileOutputStream stream(filename);
if(stream.Ok() == FALSE)
strcpy(fname, filename.mb_str(wxConvLocal));
f_env = fopen(fname,"w");
if(f_env == NULL)
{
wxLogError(_T("Failed to write '%s'"),filename.c_str());
wxLogError(_T("Failed to write ")+filename);
return;
}
wxDataOutputStream s(stream);
s.Write32(FILEID1_PITCHENV);
s.Write32(FILEID2_PITCHENV);
s.Write16(pitch.pitch1); // Hz
s.Write16(pitch.pitch2); // Hz
for(ix=0; ix<128; ix++)
s.Write8(pitch.env[ix]);
{
fprintf(f_env," 0x%.2x,",pitch.env[ix]);
if((ix & 0xf) == 0xf)
fprintf(f_env,"\n");
}
fclose(f_env);
} // end of SpectDisplay::SavePitchenv
@@ -958,7 +960,7 @@ void MyFrame::OnNewWindow(wxCommandEvent& event)
setlocale(LC_NUMERIC,"C"); // read numbers in the form 1.23456
spectseq->Load(stream);
spectseq->name = leaf;
spectseq->MakePitchenv(spectseq->pitchenv);
spectseq->MakePitchenv(spectseq->pitchenv,0,spectseq->numframes-1);
if(event.GetId() == MENU_SPECTRUM)
path_spectload = path.GetPath();
+4 -4
View File
@@ -791,8 +791,8 @@ void SpectSeq::CopyDown(int frame, int direction)
} // end of CopyDown
void SpectSeq::MakePitchenv(PitchEnvelope &pitchenv)
{//=================================================
void SpectSeq::MakePitchenv(PitchEnvelope &pitchenv, int start_frame, int end_frame)
{//=================================================================================
double f;
double min=8000;
double max=0;
@@ -808,7 +808,7 @@ void SpectSeq::MakePitchenv(PitchEnvelope &pitchenv)
memset(pitchenv.env,127,128);
for(ix=0; ix<numframes; ix++)
for(ix=start_frame; ix<=end_frame; ix++)
{
if((f = frames[ix]->pitch) == 0) continue;
nx++;
@@ -837,7 +837,7 @@ void SpectSeq::MakePitchenv(PitchEnvelope &pitchenv)
ay = new float[nx+1];
nx = 0;
for(ix=0; ix<numframes; ix++)
for(ix=start_frame; ix<=end_frame; ix++)
{
if((f = frames[ix]->pitch) == 0) continue;
+1 -1
View File
@@ -35,7 +35,7 @@
#include "translate.h"
#include "wave.h"
const char *version_string = "1.31.06 05.Feb.08";
const char *version_string = "1.31.07 08.Feb.08";
const int version_phdata = 0x013105;
int option_device_number = -1;
+1 -1
View File
@@ -241,7 +241,7 @@ void SelectPhonemeTable(int number);
int SelectPhonemeTableName(const char *name);
extern unsigned char *envelope_data[16];
extern unsigned char *envelope_data[18];
extern int formant_rate[]; // max rate of change of each formant
extern int speed_factor1;
extern int speed_factor2;
+1 -1
View File
@@ -718,7 +718,7 @@ SetLengthMods(tr,3); // all equal
case L('z','h'):
case L_zhy:
{
static const short stress_lengths_zh[8] = {230,150, 230,230, 230,0, 230,300};
static const short stress_lengths_zh[8] = {230,150, 230,230, 230,0, 240,290};
static const unsigned char stress_amps_zh[] = {22,16, 22,22, 22,22, 22,22 };
tr = new Translator;
+18 -2
View File
@@ -521,8 +521,9 @@ void DrawEnvelopes()
int ix_env;
int y_base;
int x;
FILE *f_txt=NULL;
unsigned char *env;
char name[80];
char name[200];
wxBitmap bitmap(WD_ENV,HT_ENV*n_envelopes);
@@ -533,6 +534,8 @@ void DrawEnvelopes()
dc.SetFont(*wxSWISS_FONT);
dc.Clear();
sprintf(name,"%s%s",path_source,"envelopes.txt");
// f_txt = fopen(name,"w");
for(ix_env=0; ix_env<n_envelopes; ix_env++)
{
@@ -553,9 +556,22 @@ void DrawEnvelopes()
{
dc.DrawLine(x*2, y_base-env[x]/2, (x+1)*2, y_base-env[x+1]/2);
}
if(f_txt != NULL)
{
fprintf(f_txt,"%s\n",name);
for(x=0; x<128; x++)
{
fprintf(f_txt," 0x%.2x,",env[x]);
if((x & 0xf) == 0xf)
fputc('\n',f_txt);
}
fputc('\n',f_txt);
}
}
bitmap.SaveFile(path_phsource+_T("/envelopes.png"),wxBITMAP_TYPE_PNG);
if(f_txt != NULL)
fclose(f_txt);
}
+1 -1
View File
@@ -1630,7 +1630,7 @@ if(option_log_frames)
range = (wvoice->pitch_range * embedded_value[EMBED_R])/50;
// compensate for change in pitch when the range is narrowed or widened
base -= (range - wvoice->pitch_range)*20;
base -= (range - wvoice->pitch_range)*18;
pitch_base = base + (pitch1 * range);
pitch_range = base + (pitch2 * range) - pitch_base;