mahta.fetrat
/
HomoFast-eSpeak-Persian
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

espeakedit: remove all but the --compile support 

This removes the GUI part of espeakedit, keeping the part that is
responsible for compiling the voice and intonation data. The
motivation for this is:

  1.  the voice and intonation data compilation will move into
      libespeak-ng after removing the wxWidgets logic and converting
      the code to C;

  2.  the espeakedit code is tightly coupled to the internals of
      libespeak-ng at a source code level, not a binary/API level,
      making the code harder to maintain;

  3.  a new GUI will be written in Qt that better supports creating
      and editing voices and languages.
master
Reece H. Dunn 9 years ago
parent
bd608a8451
commit
50377416cf
18 changed files with 19 additions and 8385 deletions
Unified View Show Diff Stats
  1. 1
    8
      Makefile.am
  2. 2
    175
      src/compiledata.cpp
  3. 14
    795
      src/espeakedit.cpp
  4. 0
    2283
      src/extras.cpp
  5. 0
    574
      src/formantdlg.cpp
  6. 0
    190
      src/main.h
  7. 0
    174
      src/menus.cpp
  8. 1
    108
      src/options.cpp
  9. 0
    71
      src/options.h
  10. 0
    601
      src/prosodydisplay.cpp
  11. 0
    50
      src/prosodydisplay.h
  12. 1
    182
      src/spect.cpp
  13. 0
    181
      src/spect.h
  14. 0
    1030
      src/spectdisplay.cpp
  15. 0
    438
      src/spectseq.cpp
  16. 0
    478
      src/transldlg.cpp
  17. 0
    299
      src/voicedlg.cpp
  18. 0
    748
      src/vowelchart.cpp

+ 1
- 8
Makefile.am View File

espeakedit_SOURCE = \ espeakedit_SOURCE = \
src/compiledata.cpp \ src/compiledata.cpp \
src/espeakedit.cpp \ src/espeakedit.cpp \
src/extras.cpp \
src/formantdlg.cpp \
src/menus.cpp \
src/options.cpp \ src/options.cpp \
src/prosodydisplay.cpp \ src/prosodydisplay.cpp \
src/spect.cpp \ src/spect.cpp \
src/spectdisplay.cpp \
src/spectseq.cpp \
src/transldlg.cpp \
src/voicedlg.cpp \
src/vowelchart.cpp
src/spectseq.cpp


if OPT_KLATT if OPT_KLATT
common_FLAGS += -DINCLUDE_KLATT common_FLAGS += -DINCLUDE_KLATT

+ 2
- 175
src/compiledata.cpp View File

extern wxString path_phsource; extern wxString path_phsource;
extern wxString path_phfile; extern wxString path_phfile;
extern char path_dsource[sizeof(path_home)+20]; extern char path_dsource[sizeof(path_home)+20];
extern char path_source[sizeof(path_home)+20];


extern wxProgressDialog *progress;
extern int progress_max; extern int progress_max;
extern int gui_flag; extern int gui_flag;
extern char voice_name2[40]; extern char voice_name2[40];


extern void FindPhonemesUsed(void);
extern "C" int utf8_in(int *c, const char *buf); extern "C" int utf8_in(int *c, const char *buf);
extern "C" int utf8_out(unsigned int c, char *buf); extern "C" int utf8_out(unsigned int c, char *buf);
extern void DrawEnvelopes(); extern void DrawEnvelopes();
extern void ReadPhondataManifest(); extern void ReadPhondataManifest();
char path_source[sizeof(path_home)+20];


typedef struct { typedef struct {
const char *mnem; const char *mnem;






static wxString CompileAllDictionaries()
{//=====================================
wxString filename;
wxFileName fname;
wxString dictstr;
wxString filetype;
wxString report = _T("");
int err;
int errors = 0;
int dict_count = 0;
FILE *f_in;
FILE *log;
FILE *f_phused;
char dictname[80];
char fname_log[sizeof(path_dsource)+20];
char save_voice_name[80];
char path[sizeof(path_home)+40]; // path_dsource+20
char buf[200];
char voicename[80];

if(!wxDirExists(path_dictsource))
{
if(gui_flag)
{
wxString dirname = wxDirSelector(_T("Directory of dictionary files"),path_phsource);
if(!dirname.IsEmpty())
{
path_dictsource = dirname;
strncpy0(path_dsource,path_dictsource.mb_str(wxConvLocal),sizeof(path_dsource)-1);
strcat(path_dsource,"/");
}
}
else
{
fprintf(stderr,"Can't find dictionary files: %s\n",path_dsource);
}
}

wxDir dir(path_dictsource);
if(!dir.IsOpened())
{
return(_T(" No dictionaries"));
}

strcpy(save_voice_name,voice_name2);

sprintf(fname_log,"%s%s",path_dsource,"dict_log");
log = fopen(fname_log,"w");
if(log != 0)
{
fprintf(log, "%s", utf8_bom);
}
sprintf(fname_log,"%s%s",path_dsource,"dict_phonemes");
f_phused = fopen(fname_log,"w");

if(f_phused)
{
fprintf(f_phused,"Phonemes which are used in the *_rules and *_list files\n");
}

bool cont = dir.GetFirst(&filename, _T("*_rules*"), wxDIR_FILES);
while ( cont )
{
fname = wxFileName(filename);
filetype = fname.GetName().AfterLast('_');
if((filetype != _T("rules")) && (filetype != _T("rules.txt")))
{
cont = dir.GetNext(&filename);
continue;
}

dictstr = fname.GetName().BeforeLast('_');
strcpy(dictname,dictstr.mb_str(wxConvLocal));

dict_count++;
strcpy(voicename,dictname);

// read the *_rules file to see if a phoneme table is specified though a voice name
sprintf(path,"%s%s_rules.txt",path_dsource,dictname);
if((f_in = fopen(path,"r")) == NULL)
{
sprintf(path,"%s%s_rules",path_dsource,dictname);
f_in = fopen(path,"r");
}

if(f_in != NULL)
{
unsigned int ix;
unsigned int c;

for(ix=0; ix<20; ix++)
{
if(fgets(buf,sizeof(buf),f_in) == NULL)
break;

if(memcmp(buf,"//voice=",8)==0)
{
for(ix=0; ix<sizeof(voicename); ix++)
{
if(isspace(c = buf[ix+8]))
{
break;
}
voicename[ix] = c;
}
voicename[ix] = 0;
break;
}
}
fclose(f_in);
}

if(LoadVoice(voicename,1) == NULL)
{
wxLogError(wxString::Format(_T("Can't find voice '%s' for dictionary '%s'"), wxString(voicename, wxConvLocal).c_str(), dictstr.c_str()));
report = report + dictstr + _T(" No Voice, ");
errors ++;
}
else
if((err = CompileDictionary(path_dsource, dictname,log,NULL,0)) > 0)
{
report = report + dictstr + wxString::Format(_T(" %d, "),err);
errors += err;
}

if(f_phused != NULL)
{
memset(phoneme_tab_flags,0,sizeof(phoneme_tab_flags));
FindPhonemesUsed();
PrintPhonemesUsed(f_phused, path_dsource, dictname);
}

cont = dir.GetNext(&filename);
}
if(log != NULL)
fclose(log);
if(f_phused != NULL)
fclose(f_phused);

LoadVoiceVariant(save_voice_name,0);

if(errors == 0)
return(wxString::Format(_T(" Compiled %d dictionaries"),dict_count));
else
{
return(_T(" Dictionary errors: ") + report);
}

} // end of CompileAllDictionaries




static void error(const char *format, const char *string) static void error(const char *format, const char *string)
{//====================================================== {//======================================================
if(string==NULL) if(string==NULL)
return; return;
} }


if(gui_flag)
progress->Update(n_phoneme_tabs);

memset(&phoneme_tab_list2[n_phoneme_tabs], 0, sizeof(PHONEME_TAB_LIST)); memset(&phoneme_tab_list2[n_phoneme_tabs], 0, sizeof(PHONEME_TAB_LIST));
phoneme_tab_list2[n_phoneme_tabs].phoneme_tab_ptr = phoneme_tab2 = p; phoneme_tab_list2[n_phoneme_tabs].phoneme_tab_ptr = phoneme_tab2 = p;
strncpy0(phoneme_tab_list2[n_phoneme_tabs].name, name, N_PHONEME_TAB_NAME); strncpy0(phoneme_tab_list2[n_phoneme_tabs].name, name, N_PHONEME_TAB_NAME);
sprintf(fname,"%scompile_prog_log",path_source); sprintf(fname,"%scompile_prog_log",path_source);
f_prog_log = fopen_log(f_errors,fname,"wb"); f_prog_log = fopen_log(f_errors,fname,"wb");


if(gui_flag)
{
progress = new wxProgressDialog(_T("Compiling"),_T(""),progress_max);
}
else
{
fprintf(stderr,"Compiling phoneme data: %s\n",path_source);
}
fprintf(stderr,"Compiling phoneme data: %s\n",path_source);


// write a word so that further data doesn't start at displ=0 // write a word so that further data doesn't start at displ=0
Write4Bytes(f_phdata,version_phdata); Write4Bytes(f_phdata,version_phdata);
LoadVoice(voice_name2,0); LoadVoice(voice_name2,0);


CompileReport(); CompileReport();
if(gui_flag != 0)
report_dict = CompileAllDictionaries();
#ifdef MAKE_ENVELOPES #ifdef MAKE_ENVELOPES
DrawEnvelopes(); DrawEnvelopes();
#endif #endif



if(gui_flag)
{
delete progress;
}

if(resample_count > 0) if(resample_count > 0)
{ {
fprintf(f_errors, "\n%d WAV files resampled to %d Hz\n", resample_count, samplerate_native); fprintf(f_errors, "\n%d WAV files resampled to %d Hz\n", resample_count, samplerate_native);

+ 14
- 795
src/espeakedit.cpp View File

#include "speak_lib.h" #include "speak_lib.h"
#include "espeak_ng.h" #include "espeak_ng.h"


#include "main.h"
#include "speech.h" #include "speech.h"
#include "options.h"
#include "phoneme.h" #include "phoneme.h"
#include "synthesize.h" #include "synthesize.h"
#include "voice.h" #include "voice.h"
#include "spect.h" #include "spect.h"
#include "translate.h" #include "translate.h"
#include "prosodydisplay.h"


static const char *about_string2 = "espeakedit: %s\nAuthor: Jonathan Duddington (c) 2009\n\n" static const char *about_string2 = "espeakedit: %s\nAuthor: Jonathan Duddington (c) 2009\n\n"
"Licensed under GNU General Public License version 3\n" "Licensed under GNU General Public License version 3\n"
"<a href=\"http://espeak.sourceforge.net/\">http://espeak.sourceforge.net</a><br>" "<a href=\"http://espeak.sourceforge.net/\">http://espeak.sourceforge.net</a><br>"
"Licensed under <a href=\"http://espeak.sourceforge.net/license.html\">GNU General Public License version 3</a></font>"; "Licensed under <a href=\"http://espeak.sourceforge.net/license.html\">GNU General Public License version 3</a></font>";


const char *path_data;

extern void TestTest(int control);
extern void CompareLexicon(int);
extern void ConvertToUtf8();
extern void DictionaryFormat(const char *dictname);
extern void DictionarySort(const char *dictname);

extern void init_z();
extern void ConfigInit(bool use_defaults);
extern void CompilePhonemeData(void); extern void CompilePhonemeData(void);
extern void CompileSampleRate(void); extern void CompileSampleRate(void);
extern espeak_ng_STATUS CompileIntonation(FILE *log); extern espeak_ng_STATUS CompileIntonation(FILE *log);
extern void InitSpectrumDisplay();
extern void InitProsodyDisplay();
extern void InitWaveDisplay();

extern void VowelChart(int control, char *fname);
extern void MakeVowelLists(void);
extern void MakeWordFreqList();

extern wxMenu *speak_menu;
extern wxMenu *data_menu;



MyFrame *myframe = NULL;
SpectDisplay *currentcanvas = NULL;

ProsodyDisplay *prosodycanvas = NULL;
wxNotebook *notebook = NULL;
wxNotebook *screenpages = NULL;

wxProgressDialog *progress;
int progress_max; int progress_max;
int gui_flag = 0; int gui_flag = 0;
int frame_x, frame_y, frame_w, frame_h;


int adding_page = 0; // fix for wxWidgets (2,8,7) bug, adding first page to a wxNotebook gives emptystring for GetPageTex() in Notebook_Page_Changed event.
class MyApp: public wxApp
{
public:
bool OnInit(void);
int OnExit(void);
};


IMPLEMENT_APP(MyApp) IMPLEMENT_APP(MyApp)




int MyApp::OnExit() int MyApp::OnExit()
{//================ {//================
ConfigSave(1);
return(0); return(0);
} }


const char *p = argv[1]; const char *p = argv[1];
while((param[j] = p[j]) != 0) j++; while((param[j] = p[j]) != 0) j++;
#endif #endif
}
else
{
param[0] = '-';
param[1] = 'h';
param[2] = 0;
}


if((strcmp(param,"--help")==0) || (strcmp(param,"-h")==0)) if((strcmp(param,"--help")==0) || (strcmp(param,"-h")==0))
{ {
} }
exit(0); exit(0);
} }

ConfigInit(false);
gui_flag = 1;
// It seems that the wctype functions don't work until the locale has been set
// to something other than the default "C". Then, not only Latin1 but also the
// other characters give the correct results with iswalpha() etc.
if(setlocale(LC_CTYPE,"en_US.UTF-8") == NULL)
{
if(setlocale(LC_CTYPE,"UTF-8") == NULL)
setlocale(LC_CTYPE,"");
}

if((frame_w == 0) || (frame_h == 0))
{
frame_w = 800;
frame_h = 768;
}

// Create the main frame window
myframe = new MyFrame(NULL, -1, AppName, wxPoint(frame_x, frame_y), wxSize(frame_w, frame_h),
wxDEFAULT_FRAME_STYLE |
wxNO_FULL_REPAINT_ON_RESIZE |
wxHSCROLL | wxVSCROLL);


// Make a menubar
myframe->SetMenuBar(MakeMenu(0, voice_name2));
myframe->CreateStatusBar();
myframe->SetVoiceTitle(voice_name2);

// myframe->Maximize();
myframe->Show(TRUE);

SetTopWindow(myframe);
wxInitAllImageHandlers();
// wxImage::AddHandler(wxPNGHandler);
wxLogStatus(_T("Using espeak_data at: ")+wxString(path_home, wxConvLocal));
return TRUE;
}

BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_CHAR(MyFrame::OnKey)
EVT_MENU(MENU_ABOUT, MyFrame::OnAbout)
EVT_MENU(MENU_DOCS, MyFrame::OnAbout)
EVT_MENU(MENU_SPECTRUM, MyFrame::OnNewWindow)
EVT_MENU(MENU_SPECTRUM2, MyFrame::OnNewWindow)
EVT_MENU(MENU_PROSODY, MyFrame::OnProsody)
EVT_MENU(MENU_OPT_SPEED, MyFrame::OnOptions)
EVT_MENU(MENU_OPT_PUNCT, MyFrame::OnOptions)
EVT_MENU(MENU_OPT_SPELL, MyFrame::OnOptions)
EVT_MENU(MENU_OPT_SPELL2, MyFrame::OnOptions)
EVT_MENU(MENU_PATH_DATA, MyFrame::OnOptions)
EVT_MENU(MENU_PATH0, MyFrame::OnOptions)
EVT_MENU(MENU_PATH1, MyFrame::OnOptions)
EVT_MENU(MENU_PATH2, MyFrame::OnOptions)
EVT_MENU(MENU_PATH3, MyFrame::OnOptions)
EVT_MENU(MENU_PATH4, MyFrame::OnOptions)
EVT_MENU(MENU_COMPILE_PH, MyFrame::OnTools)
EVT_MENU(MENU_COMPILE_PH2, MyFrame::OnTools)
EVT_MENU(MENU_COMPILE_DICT, MyFrame::OnTools)
EVT_MENU(MENU_COMPILE_DICT_DEBUG, MyFrame::OnTools)
EVT_MENU(MENU_FORMAT_DICTIONARY, MyFrame::OnTools)
EVT_MENU(MENU_SORT_DICTIONARY, MyFrame::OnTools)
EVT_MENU(MENU_COMPILE_MBROLA, MyFrame::OnTools)
EVT_MENU(MENU_COMPILE_INTONATION, MyFrame::OnTools)
EVT_MENU(MENU_QUIT, MyFrame::OnQuit)
EVT_MENU(MENU_SPEAK_TRANSLATE, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_RULES, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_IPA, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_TEXT, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_FILE, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_STOP, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_PAUSE, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_VOICE, MyFrame::OnSpeak)
EVT_MENU(MENU_SPEAK_VOICE_VARIANT, MyFrame::OnSpeak)
EVT_MENU(MENU_LOAD_WAV, MyFrame::OnTools)
EVT_MENU(MENU_VOWELCHART1, MyFrame::OnTools)
EVT_MENU(MENU_VOWELCHART2, MyFrame::OnTools)
EVT_MENU(MENU_VOWELCHART3, MyFrame::OnTools)
EVT_MENU(MENU_LEXICON_RU, MyFrame::OnTools)
EVT_MENU(MENU_LEXICON_BG, MyFrame::OnTools)
EVT_MENU(MENU_LEXICON_DE, MyFrame::OnTools)
EVT_MENU(MENU_LEXICON_IT, MyFrame::OnTools)
EVT_MENU(MENU_LEXICON_TEST, MyFrame::OnTools)
EVT_MENU(MENU_TO_UTF8, MyFrame::OnTools)
EVT_MENU(MENU_COUNT_WORDS, MyFrame::OnTools)
EVT_MENU(MENU_TEST, MyFrame::OnTools)
EVT_MENU(MENU_TEST2, MyFrame::OnTools)

EVT_MENU(SPECTSEQ_SAVE, MyFrame::PageCmd)
EVT_MENU(SPECTSEQ_SAVEAS, MyFrame::PageCmd)
EVT_MENU(SPECTSEQ_SAVESELECT, MyFrame::PageCmd)
EVT_MENU(SPECTSEQ_CLOSE, MyFrame::PageCmd)
EVT_MENU(SPECTSEQ_SAVEPITCH, MyFrame::PageCmd)
EVT_MENU(MENU_CLOSE_ALL, MyFrame::PageCmd)


EVT_NOTEBOOK_PAGE_CHANGED(ID_SCREENPAGES, MyFrame::OnPageChanged)
EVT_TIMER(1, MyFrame::OnTimer)
END_EVENT_TABLE()


MyFrame::~MyFrame(void)
{//====================
myframe->Maximize(false);
myframe->Show(false);
myframe->Iconize(false); // os=Windows, get the non-iconsized size
myframe->GetPosition(&frame_x, &frame_y);
myframe->GetSize(&frame_w, &frame_h);
}

MyFrame::MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size,
const long style):
wxFrame(parent, id, title, pos, size, style)
{//===================================================================================================================
// Main Frame constructor

int error_flag = 0;
int result;
int param;
int srate;

notebook = new wxNotebook(this, ID_NOTEBOOK, wxDefaultPosition, wxSize(312,760));
// notebook->AddPage(voicedlg,_T("Voice"),FALSE);
formantdlg = new FormantDlg(notebook);
notebook->AddPage(formantdlg,_T(" Spect"),FALSE);
voicedlg = new VoiceDlg(notebook);

transldlg = new TranslDlg(notebook);
notebook->AddPage(transldlg,_T("Text"),TRUE);


screenpages = new wxNotebook(this, ID_SCREENPAGES, wxDefaultPosition, wxSize(554,702));

wxBoxSizer *framesizer = new wxBoxSizer( wxHORIZONTAL );


framesizer->Add(
notebook,
0, // make horizontally stretchable
wxEXPAND | // make vertically stretchable
wxALL, // and make border all around
4 ); // set border width

framesizer->Add(
screenpages,
1, // make horizontally stretchable
wxEXPAND | // make vertically stretchable
wxALL, // and make border all around
4 ); // set border width

SetSizer( framesizer ); // use the sizer for layout
framesizer->SetSizeHints( this ); // set size hints to honour minimum size
SetSize(pos.x, pos.y, size.GetWidth(), size.GetHeight());

LoadConfig();

if((result = LoadPhData(&srate)) != 1)
{
if(result == -1)
wxLogError(_T("Failed to read espeak-data/phontab,phondata,phonindex\nPath = ")+wxString(path_home,wxConvLocal)+_T("\n\nThe 'eSpeak' package needs to be installed"));
else
wxLogError(_T("Wrong version of espeak-data at:\n")+ wxString(path_home,wxConvLocal)+_T("\nVersion 0x%x (expects 0x%x)"),result,version_phdata);

error_flag = 1;
srate = 22050;
}
WavegenInit(srate,0);
WavegenInitSound();

f_trans = stdout;
option_ssml = 1;
option_phoneme_input = 1;


// if(LoadVoice(voice_name,0) == NULL)
if(SetVoiceByName(voice_name2) != EE_OK)
{
if(error_flag==0)
wxLogError(_T("Failed to load voice data"));
strcpy(dictionary_name,"en");
}
WavegenSetVoice(voice);

for(param=0; param<N_SPEECH_PARAM; param++)
param_stack[0].parameter[param] = param_defaults[param];

SetParameter(espeakRATE,option_speed,0);

SetSpeed(3);
SynthesizeInit();

InitSpectrumDisplay();
InitProsodyDisplay();
// InitWaveDisplay();
espeak_ListVoices(NULL);

m_timer.SetOwner(this,1);

m_timer.Start(500); /* 0.5 timer */

} // end of MyFrame::MyFrame


void MyFrame::SetVoiceTitle(char *voice_name)
{//==========================================
char buf[100];

if(samplerate_native == 22050)
sprintf(buf, " - %s voice", voice_name);
else
sprintf(buf, " - %s voice %dHz", voice_name, samplerate_native);
SetTitle(AppName + wxString(buf,wxConvLocal));

if((data_menu != NULL) && (translator != NULL))
{
sprintf(buf,"Compile &dictionary '%s'",translator->dictionary_name);
data_menu->SetLabel(MENU_COMPILE_DICT, wxString(buf,wxConvLocal));
sprintf(buf,"&Layout '%s_rules' file",translator->dictionary_name);
data_menu->SetLabel(MENU_FORMAT_DICTIONARY, wxString(buf,wxConvLocal));
sprintf(buf,"&Sort '%s_rules' file",translator->dictionary_name);
data_menu->SetLabel(MENU_SORT_DICTIONARY, wxString(buf,wxConvLocal));
}
}



void MyFrame::PageCmd(wxCommandEvent& event)
{//=========================================
int pagenum;
int ix;
int n_pages;
SpectDisplay *page;

// if(currentcanvas != NULL)
{
pagenum = screenpages->GetSelection();

switch(event.GetId())
{
case SPECTSEQ_SAVE:
currentcanvas->Save(currentcanvas->savepath);
break;
case SPECTSEQ_SAVEAS:
currentcanvas->Save();
screenpages->SetPageText(screenpages->GetSelection(), currentcanvas->spectseq->name+_T(" ²"));
break;
case SPECTSEQ_SAVESELECT:
currentcanvas->Save(_T(""), 1);
break;
case SPECTSEQ_CLOSE:
if(screenpages->GetPageText(pagenum) != _T("Prosody"))
{
currentcanvas->OnActivate(0);
}
screenpages->DeletePage(pagenum);

if((n_pages = screenpages->GetPageCount()) > 0)
{
if(pagenum >= n_pages)
pagenum--;
page = (SpectDisplay *)screenpages->GetPage(pagenum);

if(screenpages->GetPageText(pagenum) == _T("Prosody"))
{
MakeMenu(3, NULL);
}
else
{
page->OnActivate(1);
MakeMenu(2, NULL);
}
}
else
{
MakeMenu(1, NULL);
}
break;

case MENU_CLOSE_ALL:
n_pages = screenpages->GetPageCount();
for(ix=n_pages-1; ix>=0; ix--)
{
screenpages->DeletePage(ix);
}
currentcanvas = NULL;
MakeMenu(1, NULL);
break;
case SPECTSEQ_SAVEPITCH:
currentcanvas->SavePitchenv(currentcanvas->spectseq->pitchenv);
break;
}
}
}



void MyFrame::OnPageChanged(wxNotebookEvent& event)
{//=================================================
int pagenum;
wxString title;
SpectDisplay *page;

pagenum = event.GetSelection();

if(event.GetId() == ID_SCREENPAGES)
{
title = screenpages->GetPageText(pagenum);

if((title != _T("Prosody")) && (adding_page != 2))
{
page = (SpectDisplay *)screenpages->GetPage(pagenum);

if(page != currentcanvas)
{
if(currentcanvas != NULL)
{
currentcanvas->OnActivate(0);
}
page->OnActivate(1);
}
MakeMenu(2, NULL);
}
else
{
MakeMenu(3, NULL);
}
}
adding_page = 0; // work around for wxNotebook bug (version 2.8.7)
}


void MyFrame::OnKey(wxKeyEvent& event)
{
int key;

key = event.GetKeyCode();

if((currentcanvas != NULL) && (currentcanvas != FindFocus()))
{
if((key == WXK_F1) || (key == WXK_F2))
{
currentcanvas->OnKey(event);
currentcanvas->SetFocus();
return;
}
}

event.Skip();
}

void MyFrame::OnTimer(wxTimerEvent &event)
//****************************************
{
SynthOnTimer();
}


void MyFrame::OnQuit(wxCommandEvent& event)
{
switch(event.GetId())
{
case MENU_QUIT:
Close(TRUE);
break;
case MENU_CLOSE_ALL:
break;
}
}



class HtmlWindow: public wxHtmlWindow
{
public:

HtmlWindow(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style);
void OnLinkClicked(const wxHtmlLinkInfo& link);
};

HtmlWindow::HtmlWindow(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style):
wxHtmlWindow(parent, id, pos, size, style)
{
}

void HtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
{
if(wxLaunchDefaultBrowser(link.GetHref()) == FALSE)
wxLogStatus(_T("Failed to launch default browser: "+link.GetHref()));
}


void MyFrame::OnAbout(wxCommandEvent& event)
{//=========================================
int result;
char buf[300];
wxString url_docs;

switch(event.GetId())
{
case MENU_ABOUT:
{
wxDialog dlg(this, wxID_ANY, wxString(_("About")));

sprintf(buf,about_string,espeak_Info(NULL));
HtmlWindow *html = new HtmlWindow(&dlg, wxID_ANY, wxDefaultPosition, wxSize(380, 160), wxHW_SCROLLBAR_NEVER);
html -> SetBorders(0);
html -> SetPage(wxString(buf,wxConvLocal));
html -> SetSize(html -> GetInternalRepresentation() -> GetWidth(),
html -> GetInternalRepresentation() -> GetHeight());

wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
topsizer -> Add(html, 1, wxALL, 10);

//#if wxUSE_STATLINE
// topsizer -> Add(new wxStaticLine(&dlg, wxID_ANY), 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
//#endif // wxUSE_STATLINE

wxButton *bu1 = new wxButton(&dlg, wxID_OK, _("OK"));
bu1 -> SetDefault();

topsizer -> Add(bu1, 0, wxALL | wxALIGN_RIGHT, 15);

dlg.SetSizer(topsizer);
topsizer -> Fit(&dlg);

dlg.ShowModal();
}
break;

case MENU_DOCS:
strcpy(buf,"/docs/docindex.html");
url_docs = wxGetCwd() + wxString(buf,wxConvLocal); // look for "docs" in the current directory
if(!wxFileExists(url_docs))
{
strcpy(buf,"http://espeak.sourceforge.net/docindex.html");
url_docs = wxString(buf,wxConvLocal);
}
else
{
url_docs = _T("file://") + url_docs;
}

result = wxLaunchDefaultBrowser(url_docs);
if(result == 0)
wxLogStatus(_T("Failed to launch default browser: "+url_docs));
break;
}
}



void OnOptions2(int event_id)
{//==========================
wxString string;
int value;

switch(event_id)
{
case MENU_OPT_SPEED:
value = wxGetNumberFromUser(_T(""),_T(""),_T("Speed"),option_speed,80,500);
if(value > 0)
{
option_speed = value;
SetParameter(espeakRATE,option_speed,0);
SetSpeed(3);
}
break;

case MENU_OPT_PUNCT:
transldlg->t_source->SetValue(_T("<tts:style field=\"punctuation\" mode=\"all\">\n"));
transldlg->t_source->SetInsertionPointEnd();
notebook->SetSelection(1);
break;

case MENU_OPT_SPELL:
transldlg->t_source->SetValue(_T("<say-as interpret-as=\"characters\">\n"));
transldlg->t_source->SetInsertionPointEnd();
notebook->SetSelection(1);
break;

case MENU_OPT_SPELL2:
transldlg->t_source->SetValue(_T("<say-as interpret-as=\"tts:char\">\n"));
transldlg->t_source->SetInsertionPointEnd();
notebook->SetSelection(1);
break;

case MENU_PATH_DATA:
string = wxDirSelector(_T("espeak_data directory"), path_espeakdata);
if(!string.IsEmpty())
{
if(!wxDirExists(string+_T("/voices")))
{
wxLogError(_T("No 'voices' directory in ") + string);
break;
}
path_espeakdata = string;
wxLogMessage(_T("Quit and restart espeakedit to use the new espeak_data location"));
}
break;

case MENU_PATH0:
string = wxFileSelector(_T("Master phonemes file"),wxFileName(path_phfile).GetPath(),
_T("phonemes"),_T(""),_T("*"),wxOPEN);
if(!string.IsEmpty())
{
path_phfile = string;
}
break;

case MENU_PATH1:
string = wxDirSelector(_T("Phoneme source directory"),path_phsource);
if(!string.IsEmpty())
{
path_phsource = string;
}
break;

case MENU_PATH2:
string = wxDirSelector(_T("Dictionary source directory"),path_dictsource);
if(!string.IsEmpty())
{
path_dictsource = string;
}
break;

case MENU_PATH3:
string = wxFileSelector(_T("Sound output file"),wxFileName(path_speech).GetPath(),
_T(""),_T("WAV"),_T("*"),wxSAVE);
if(!string.IsEmpty())
{
path_speech = string;
}
break;

case MENU_PATH4:
string = wxFileSelector(_T("Voice file to modify formant peaks"),wxFileName(path_speech).GetPath(),
_T(""),_T(""),_T("*"),wxOPEN);
if(!string.IsEmpty())
{
path_modifiervoice = string;
}
break;
}

ConfigSetPaths();
}


void MyFrame::OnOptions(wxCommandEvent& event)
{//===========================================
OnOptions2(event.GetId());
}


void DisplayErrorFile(const char *fname)
{//=====================================
int len;
FILE *f;
char *msg;
wxString msg_string;

len = GetFileLength(fname);
if(len > 0)
{
if(len > 1500)
len = 1500; // restrict length to prevent crash in wxLogMessage()
msg = (char *)malloc(len+1);
if(msg != NULL)
{
f = fopen(fname,"r");
len = fread(msg,1, len, f);
fclose(f);
msg[len] = 0;
msg_string = wxString(msg,wxConvUTF8);
wxLogMessage(msg_string);
free(msg);
}
}
} // end of DisplayErrorFile



void MyFrame::OnTools(wxCommandEvent& event)
{//=========================================
int err;
FILE *log;
int debug_flag=0;
char fname_log[sizeof(path_dsource)+12];
char err_fname[sizeof(path_home)+15];
static unsigned const char utf8_bom[] = {0xef,0xbb,0xbf,0};

switch(event.GetId())
{
case MENU_TEST:
TestTest(0);
break;

case MENU_TEST2:
TestTest(2);
break;

case MENU_TO_UTF8:
ConvertToUtf8();
break;

case MENU_COUNT_WORDS:
MakeWordFreqList();
break;

case MENU_LEXICON_RU:
case MENU_LEXICON_BG:
case MENU_LEXICON_DE:
case MENU_LEXICON_IT:
case MENU_LEXICON_TEST:
CompareLexicon(event.GetId()); // Compare a lexicon with _rules translation
break;

case MENU_COMPILE_PH:
CompilePhonemeData();
SetVoiceTitle(voice_name2);
break;

case MENU_COMPILE_PH2:
CompileSampleRate();
SetVoiceTitle(voice_name2);
break;

case MENU_COMPILE_MBROLA:
{
wxString filepath = wxFileSelector(_T("Read Mbrola phonemes file"),path_phsource+_T("/mbrola"),_T(""),_T(""),_T("*"),wxOPEN);
espeak_ng_CompileMbrolaVoice(filepath.mb_str(wxConvLocal), stdout);
}
break;

case MENU_COMPILE_INTONATION:
{
FILE *f_errors;
char fname_errors[sizeof(path_source)+120];
sprintf(fname_errors,"%s%s",path_source,"error_intonation");
if((f_errors = fopen(fname_errors,"w")) == NULL)
f_errors = stderr;

espeak_ng_STATUS status = CompileIntonation(f_errors);
if (f_errors != stderr)
fclose(f_errors);

if (status == ENE_COMPILE_ERRORS)
DisplayErrorFile(fname_errors);
}
break;

case MENU_COMPILE_DICT_DEBUG:
debug_flag =1; // and drop through to next case
case MENU_COMPILE_DICT:
sprintf(fname_log,"%s%s",path_dsource,"dict_log");
log = fopen(fname_log,"w");
if(log != NULL)
{
fprintf(log, "%s", utf8_bom);
}

LoadDictionary(translator, translator->dictionary_name, 0);
if((err = CompileDictionary(path_dsource,translator->dictionary_name,log,err_fname,debug_flag)) < 0)
{
wxLogError(_T("Can't access file:\n")+wxString(err_fname,wxConvLocal));

wxString dir = wxDirSelector(_T("Directory containing dictionary files"),path_dictsource);
if(!dir.IsEmpty())
{
path_dictsource = dir;
strncpy0(path_dsource,path_dictsource.mb_str(wxConvLocal),sizeof(path_dsource)-1);
strcat(path_dsource,"/");
}
break;
}
wxLogStatus(_T("Compiled '")+wxString(dictionary_name,wxConvLocal)+_T("', %d errors"),err);

if(log != NULL)
{
fclose(log);

if(err > 0)
{
// display the error messages
DisplayErrorFile(fname_log);
}
}
break;

case MENU_FORMAT_DICTIONARY:
DictionaryFormat(dictionary_name);
break;

case MENU_SORT_DICTIONARY:
DictionarySort(dictionary_name);
break;

case MENU_VOWELCHART1:
MakeVowelLists();
break;

case MENU_VOWELCHART2:
VowelChart(2,NULL);
break;

case MENU_VOWELCHART3:
VowelChart(3,NULL);
break;

case MENU_LOAD_WAV:
// LoadWavFile();
break;
}
}

void MyFrame::OnSpeak(wxCommandEvent& event)
{//=========================================
switch(event.GetId())
{
case MENU_SPEAK_TRANSLATE:
case MENU_SPEAK_RULES:
case MENU_SPEAK_IPA:
case MENU_SPEAK_TEXT:
transldlg->OnCommand(event);
break;

case MENU_SPEAK_FILE:
out_ptr = NULL;
transldlg->SpeakFile();
break;

case MENU_SPEAK_STOP:
SpeakNextClause(NULL,NULL,2);
break;

case MENU_SPEAK_PAUSE:
out_ptr = NULL;
SpeakNextClause(NULL,NULL,3);
if(SynthStatus() & 2)
speak_menu->SetLabel(MENU_SPEAK_PAUSE,_T("&Resume"));
else
{
speak_menu->SetLabel(MENU_SPEAK_PAUSE,_T("&Pause"));
}
break;

case MENU_SPEAK_VOICE:
transldlg->ReadVoice(0);
SetVoiceTitle(voice_name2);
break;

case MENU_SPEAK_VOICE_VARIANT:
transldlg->ReadVoice(1);
SetVoiceTitle(voice_name2);
break;
}
}




+ 0
- 2283
src/extras.cpp
File diff suppressed because it is too large
View File


+ 0
- 574
src/formantdlg.cpp View File

/***************************************************************************
* Copyright (C) 2006 to 2007 by Jonathan Duddington *
* email: [email protected] *
* *
* 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, write see: *
* <http://www.gnu.org/licenses/>. *
***************************************************************************/



// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wx.h"
#include "wx/mdi.h"


#include "speak_lib.h"
#include "main.h"
#include "speech.h"
#include "phoneme.h"
#include "synthesize.h"
#include "voice.h"
#include "spect.h"

#include "wx/textctrl.h"
#include "wx/checkbox.h"

FormantDlg *formantdlg=NULL;
ByteGraph *pitchgraph=NULL;



BEGIN_EVENT_TABLE(FormantDlg, wxPanel)
EVT_BUTTON(T_ZOOMOUT,FormantDlg::OnCommand)
EVT_BUTTON(T_ZOOMIN,FormantDlg::OnCommand)
EVT_SPINCTRL(-1,FormantDlg::OnSpin)
// EVT_SPINCTRL(T_TIMESEQ,FormantDlg::OnSpin)
// EVT_SPINCTRL(T_AMPFRAME,FormantDlg::OnSpin)
// EVT_SPINCTRL(T_TIMEFRAME,FormantDlg::OnSpin)
END_EVENT_TABLE()

int use_spin_controls=0;

void FormantDlg::OnCommand(wxCommandEvent& event)
{//=============================================
int id;

if(currentcanvas == NULL)
return;

switch(id = event.GetId())
{
case T_ZOOMIN:
case T_ZOOMOUT:
currentcanvas->OnZoom(id);
break;

case T_AMPLITUDE:
currentcanvas->RefreshDialogValues(0);
break;

case T_TIMEFRAME:
case T_AMPFRAME:
currentcanvas->RefreshDialogValues(1);
break;
}
currentcanvas->SetFocus();
}

void FormantDlg::OnSpin(wxSpinEvent& event)
{//=============================================
int id;

if(currentcanvas == NULL)
return;

switch(id = event.GetId())
{
case T_AMPFRAME:
currentcanvas->RefreshDialogValues(1);
break;

default:
currentcanvas->RefreshDialogValues(0);
break;
}
currentcanvas->SetFocus();
}

FormantDlg::FormantDlg(wxWindow *parent) : wxPanel(parent,-1,wxDefaultPosition,wxSize(400,800))
{//=============================================================================================
int ix;
int y;
int xplace;
int id;
wxString string;
wxString control_name;

int height;
int width;
int x;
int y2 = 420;
int y3 = 520;

wxClientDisplayRect(&x,&y,&width, &height);
#ifdef PLATFORM_WINDOWS
if(height <= 768)
{
y2 = 410;
y3 = 508;
}
#else
if(height <= 800)
{
y2 = 378;
y3 = 456;
}
#endif
y = 24;
xplace = 28;
id = 201;
new wxStaticText(this,-1,_T("Formants"),wxPoint(4,5));
new wxStaticText(this,-1,_T(" Ht Width (Klatt)"),wxPoint(78,5),wxSize(300,20));
new wxStaticText(this,-1,_T("Bw Ap Bp"),wxPoint(188,29),wxSize(300,20));

for(ix=0; ix < 8; ix++)
{
string.Printf(_T("%d"),ix);
t_labpk[ix] = new wxStaticText(this,id++,string,
wxPoint(xplace-22,y+1+24*ix));

if(ix < 7)
{
control_name.Printf(_T("Formant %d"),ix);
t_pkfreq[ix] = new wxTextCtrl(this,id++,_T(""),
wxPoint(xplace,y+24*ix),wxSize(44,20),
wxTE_CENTRE,wxDefaultValidator,control_name);
}

control_name.Printf(_T("Height %d"),ix);
t_pkheight[ix] = new wxTextCtrl(this,id++,_T(""),
wxPoint(xplace+46,y+24*ix),wxSize(36,20),
wxTE_CENTRE,wxDefaultValidator,control_name);

if(ix < 6)
{
control_name.Printf(_T("Width %d"),ix);
t_pkwidth[ix] = new wxTextCtrl(this,id++,_T(""),
wxPoint(xplace+84,y+24*ix),wxSize(60,20),
wxTE_CENTRE,wxDefaultValidator,control_name);
}

if((ix == 0) || (ix > 6)) continue;

if(ix < 4)
{
control_name.Printf(_T("Klatt bandwidth %d"),ix);
t_klt_bw[ix] = new wxTextCtrl(this,id++,_T(""),
wxPoint(xplace+150,y+24*ix),wxSize(40,20),
wxTE_CENTRE,wxDefaultValidator,control_name);
}

control_name.Printf(_T("Klatt parallal %d"),ix);
t_klt_ap[ix] = new wxTextCtrl(this,id++,_T(""),
wxPoint(xplace+192,y+24*ix),wxSize(36,20),
wxTE_CENTRE,wxDefaultValidator,control_name);

control_name.Printf(_T("Klatt parallel bandwidth %d"),ix);
t_klt_bp[ix] = new wxTextCtrl(this,id++,_T(""),
wxPoint(xplace+230,y+24*ix),wxSize(40,20),
wxTE_CENTRE,wxDefaultValidator,control_name);
}

y=224;
if(use_spin_controls)
{
t_timeframe = new wxSpinCtrl(this,T_TIMEFRAME,_T(""), wxPoint(6,y+0), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Frame length"));
}
else
{
tt_timeframe = new wxTextCtrl(this,T_TIMEFRAME,_T(""), wxPoint(6,y+0), wxSize(52,24), wxTE_CENTRE,wxDefaultValidator,_T("Frame length"));
}
t_orig_frame = new wxStaticText(this,-1,_T("mS"),wxPoint(61,y+8));
t_ampframe = new wxSpinCtrl(this,T_AMPFRAME,_T(""), wxPoint(104,y+0), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Frame amplitude"));
t_lab[3] = new wxStaticText(this,-1,_T("% amp - Frame"),wxPoint(159,y+8));

y += 40;
s_klatt[KLATT_AV] = new wxSpinCtrl(this,T_AV,_T(""), wxPoint(6,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt AV"));
t_klatt[KLATT_AV] = new wxStaticText(this,-1,_T("AV"),wxPoint(61,y+4));

s_klatt[KLATT_FNZ] = new wxSpinCtrl(this,T_FNZ,_T(""), wxPoint(104,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt FNZ"));
t_klatt[KLATT_FNZ] = new wxStaticText(this,-1,_T("FNZ"),wxPoint(159,y+4));


y += 28;
s_klatt[KLATT_Tilt] = new wxSpinCtrl(this,T_TILT,_T(""), wxPoint(6,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt tilt"));
t_klatt[KLATT_Tilt] = new wxStaticText(this,-1,_T("Tilt"),wxPoint(61,y+4));

s_klatt[KLATT_Aspr] = new wxSpinCtrl(this,T_ASPR,_T(""), wxPoint(104,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt aspiration"));
t_klatt[KLATT_Aspr] = new wxStaticText(this,-1,_T("Aspr"),wxPoint(159,y+4));

s_klatt[KLATT_Skew] = new wxSpinCtrl(this,T_SKEW,_T(""), wxPoint(202,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt skew"));
t_klatt[KLATT_Skew] = new wxStaticText(this,-1,_T("Skew"),wxPoint(257,y+4));

y += 28;
s_klatt[KLATT_AVp] = new wxSpinCtrl(this,T_AVP,_T(""), wxPoint(6,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt AVp"));
t_klatt[KLATT_AVp] = new wxStaticText(this,-1,_T("AVp"),wxPoint(61,y+4));

s_klatt[KLATT_Fric] = new wxSpinCtrl(this,T_FRIC,_T(""), wxPoint(104,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt fric amp"));
t_klatt[KLATT_Fric] = new wxStaticText(this,-1,_T("Fric"),wxPoint(159,y+4));

s_klatt[KLATT_FricBP] = new wxSpinCtrl(this,T_FRICBP,_T(""), wxPoint(202,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt fric bandwidth"));
t_klatt[KLATT_FricBP] = new wxStaticText(this,-1,_T("FricBP"),wxPoint(257,y+4));

y += 28;
s_klatt[KLATT_Kopen] = new wxSpinCtrl(this,T_KOPEN,_T(""), wxPoint(6,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt KOpen"));
t_klatt[KLATT_Kopen] = new wxStaticText(this,-1,_T("kopen"),wxPoint(61,y+4));

s_klatt[KLATT_Turb] = new wxSpinCtrl(this,T_TURB,_T(""), wxPoint(104,y), wxSize(52,24), wxTE_CENTRE,0,500,0,_T("Klatt turbulence"));
t_klatt[KLATT_Turb] = new wxStaticText(this,-1,_T("Turb"),wxPoint(159,y+4));



t_zoomout = new wxButton(this,T_ZOOMOUT,_T("Zoom-"),wxPoint(16,y2));
t_zoomin = new wxButton(this,T_ZOOMIN,_T("Zoom+"),wxPoint(106,y2));

y = y2 + 46;
t_amplitude = new wxSpinCtrl(this,T_AMPLITUDE,_T(""),
wxPoint(6,y),wxSize(52,24),wxTE_CENTRE,0,y+130,0,_T("Sequence amp"));
t_lab[2] = new wxStaticText(this,-1,_T("% amp - Sequence"),wxPoint(61,y+4));
// t_timeseq = new wxSpinCtrl(this,T_TIMESEQ,_T(""),
// wxPoint(6,400),wxSize(52,24),wxTE_CENTRE,0,500);
t_orig_seq = new wxStaticText(this,-1,_T("mS"),wxPoint(61,y+30));

t_pitch = new wxStaticText(this,-1,_T(""),wxPoint(4,y3),wxSize(192,24));

pitchgraph = new ByteGraph(this,wxPoint(0,y3+18),wxSize(200,140));
pitchgraph->SetData(128,env_fall);
pitchgraph->ShowSpectrum(1);
pitchgraph->Show();
}



void FormantDlg::GetValues(SpectSeq *spectseq, int frame)
{//======================================================
int ix;
wxString value;
long num;
SpectFrame *sf;

if(spectseq->frames == NULL)
return;
sf = spectseq->frames[frame];

if(use_spin_controls == 0)
{
formantdlg->tt_timeframe->GetValue().ToLong(&num);
sf->length_adjust = num - spectseq->GetFrameLength(frame,0,NULL);
}

for(ix=0; ix < 8; ix++)
{
if(ix < 7)
{
num = 0;
value = t_pkfreq[ix]->GetValue();
value.ToLong(&num);
sf->peaks[ix].pkfreq = num;
}

num = 0;
value = t_pkheight[ix]->GetValue();
value.ToLong(&num);
sf->peaks[ix].pkheight = num << 6;

if(ix < 6)
{
num = 0;
value = t_pkwidth[ix]->GetValue();
value.ToLong(&num);
sf->peaks[ix].pkwidth = sf->peaks[ix].pkright = num*2;

if((ix < 3) && ((value = value.AfterFirst('/')) != wxEmptyString))
{
num = 0;
value.ToLong(&num);
sf->peaks[ix].pkright = num*2;
}
}
}

for(ix=1; ix < 7; ix++)
{
if(ix < 4)
{
num = 0;
value = t_klt_bw[ix]->GetValue();
value.ToLong(&num);
sf->peaks[ix].klt_bw = num;
}

num = 0;
value = t_klt_ap[ix]->GetValue();
value.ToLong(&num);
sf->peaks[ix].klt_ap = num;

num = 0;
value = t_klt_bp[ix]->GetValue();
value.ToLong(&num);
sf->peaks[ix].klt_bp = num;
}
} // end of FormantDlg::GetValues



void FormantDlg::ShowFrame(SpectSeq *spectseq, int frame, int pk, int field)
{//==============================================================
int ix;
SpectFrame *sf;
wxString value;
int original_mS;
peak_t *peak;

if(spectseq->frames == NULL)
return;
sf = spectseq->frames[frame];

if(field == 0xff)
{
// indicate the selected peak
// t_select_peak[pk]->SetValue(TRUE);
}

for(ix=0; ix < 8; ix++)
{
if(field != 0xff && pk!=ix)
continue;

if(field == 0xff)
{
if(pk==ix)
value.Printf(_T("%d="),ix);
else
value.Printf(_T("%d"),ix);
t_labpk[ix]->SetLabel(value);
}

peak = &(sf->peaks[ix]);

if((field & 1) && (ix < 7))
{
value.Printf(_T("%4d"),sf->peaks[ix].pkfreq);
t_pkfreq[ix]->SetValue(value);
}
if(field & 2)
{
value.Printf(_T("%3d"),sf->peaks[ix].pkheight >> 6);
t_pkheight[ix]->SetValue(value);
}
if((field & 4) && (ix < 6))
{
if(sf->peaks[ix].pkwidth == sf->peaks[ix].pkright)
value.Printf(_T("%3d"),sf->peaks[ix].pkwidth/2);
else
value.Printf(_T("%3d/%3d"),sf->peaks[ix].pkwidth/2, sf->peaks[ix].pkright/2);
t_pkwidth[ix]->SetValue(value);
}

if((ix > 0) && (ix < 7))
{
if((field & 8) && (ix < 4))
{
value.Printf(_T("%3d"),peak->klt_bw);
t_klt_bw[ix]->SetValue(value);
}

if(field & 16)
{
value.Printf(_T("%3d"),peak->klt_ap);
t_klt_ap[ix]->SetValue(value);
}

if(field & 32)
{
value.Printf(_T("%3d"),peak->klt_bp);
t_klt_bp[ix]->SetValue(value);
}
}
}

// find the time until the next keyframe
value.Printf(_T("%d"),int(spectseq->GetFrameLength(frame,1,&original_mS)+0.5)); // round to nearest integer

if(use_spin_controls)
t_timeframe->SetValue(value);
else
tt_timeframe->SetValue(value);

value.Printf(_T("%d mS"),original_mS);
t_orig_frame->SetLabel(value);
value.Printf(_T("%3d"),sf->amp_adjust);
t_ampframe->SetValue(value);

for(ix=0; ix<N_KLATTP; ix++)
{
SetSpinCtrl(s_klatt[ix], sf->klatt_param[ix]);
}

} // end of FormantDlg::ShowFrame


BEGIN_EVENT_TABLE(ByteGraph,wxScrolledWindow)
EVT_LEFT_DOWN(ByteGraph::OnMouse)
END_EVENT_TABLE()

static wxBrush BRUSH_FORMANT(wxColour(255,100,50),wxSOLID);
static wxPen PEN_KEYFRAME(wxColour(255,220,100),2,wxSOLID);
static wxPen PEN_KEYFORMANT(wxColour(0,0,0),2,wxSOLID);


ByteGraph::ByteGraph(wxWindow *parent, const wxPoint& pos, const wxSize &size):
wxScrolledWindow(parent,-1,pos,size,wxSUNKEN_BORDER)
{//============================================================
npoints = 0;
show_spectrum = 0;
} // end of ByteGraph::ByteGraph


void ByteGraph::SetData(int nx, unsigned char *data)
{//=================================================
npoints = nx;
graph = data;
Refresh();
} // end of ByteGraph::SetData


void ByteGraph::ShowSpectrum(int yes)
{//==================================
show_spectrum = yes;
}


void ByteGraph::DrawSpectrum(wxDC& dc)
{//===================================
SpectSeq *seq;
SpectFrame *sf;
int ix;
int x, y;
int pk;
double length;
int numframes;
int width, height;
double xscale, yscale;

spectrum_scale = 0;
if(currentcanvas==NULL) return;
if((seq = currentcanvas->spectseq) == NULL) return;
numframes = seq->numframes;

if(numframes == 0) return;

GetClientSize(&width,&height);

if(((length = seq->frames[numframes-1]->time)==0) && (numframes>1))
length = seq->frames[numframes-2]->time;

length = length - seq->frames[0]->time;

yscale = height/3000.0;
spectrum_scale = xscale = width/length;

dc.SetBrush(BRUSH_FORMANT);
dc.SetPen(*wxTRANSPARENT_PEN);
for(ix=0; ix<numframes; ix++)
{
sf = seq->frames[ix];
x = int(sf->time*xscale);

if(sf->keyframe)
{
dc.SetPen(PEN_KEYFRAME);
dc.DrawLine(x,0,x,height);
}

dc.SetPen(*wxTRANSPARENT_PEN);
dc.DrawCircle(x,int(height-(sf->formants[1].freq-200)*yscale),3);
dc.DrawCircle(x,int(height-(sf->formants[2].freq-200)*yscale),3);
dc.DrawCircle(x,int(height-(sf->formants[3].freq-200)*yscale),3);

if(sf->keyframe)
{
dc.SetPen(PEN_KEYFORMANT);
for(pk=1; pk<6; pk++)
{
y = height-int((sf->peaks[pk].pkfreq-200)*yscale);
dc.DrawLine(x-3,y,x+3,y);
}
}
}
}


void ByteGraph::OnDraw(wxDC &dc)
{//============================
int x, y, x2, y2, ix;
int width, height;
double xscale, yscale;

if(show_spectrum) DrawSpectrum(dc);

if(npoints==0) return;

GetClientSize(&width,&height);

xscale = double(width) / npoints;
yscale = double(height) / 256.0;

if(npoints > 8)
{
// draw pitch profile
dc.SetPen(*wxMEDIUM_GREY_PEN);
x = 0;
y = height - int(graph[0]*yscale);
for(ix=1; ix<npoints; ix++)
{
dc.DrawLine(x,y,x2=int(ix*xscale),y2=height - int(graph[ix]*yscale));
x = x2;
y = y2;
}
}
} // end of ByteGraph::OnDraw


void ByteGraph::OnMouse(wxMouseEvent& event)
{//========================================
int ix;
SpectSeq *seq;
double time;
double t0, t1;
double t2=0;

if(currentcanvas==NULL) return;
if((seq = currentcanvas->spectseq) == NULL) return;

wxClientDC dc(this);
PrepareDC(dc);

wxPoint pt(event.GetLogicalPosition(dc));
t0 = t2 = seq->frames[0]->time;
time = (double(pt.x) / spectrum_scale) + t0;

for(ix=1; ix<seq->numframes; ix++)
{
t1=t2;
t2 = seq->frames[ix]->time;
if(time <= t1 + (t2-t1)/2)
{
currentcanvas->SelectFrame(ix-1);
break;
}
}
} // end of ByteGraph::OnMouse


+ 0
- 190
src/main.h View File


#include "wx/toolbar.h"
#include "wx/laywin.h"
#include "wx/progdlg.h"
#include "wx/notebook.h"

typedef unsigned short USHORT;
typedef unsigned char UCHAR;



extern wxMenuBar *MakeMenu(int type, const char *dict_name);

extern wxString path_phsource;
extern wxString path_speaktext;
extern wxString path_speech;
extern wxProgressDialog *progress;
extern int progress_max;
extern int gui_flag;

extern char *WavFileName();
extern char voice_name2[40];

class SpectDisplay;


// Define a new application
class MyApp: public wxApp
{
public:
bool OnInit(void);
int OnExit(void);
};

// Define a new frame
class MyFrame: public wxFrame
{
public:

MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, const long style);
~MyFrame(void);


void OnAbout(wxCommandEvent& event);
void OnQuit(wxCommandEvent& event);
void OnOptions(wxCommandEvent& event);
void OnSpeak(wxCommandEvent& event);
void OnTools(wxCommandEvent& event);
void OnKey(wxKeyEvent& event);
void OnTimer(wxTimerEvent& event);
void LoadWavFile(void);

void OnNewWindow(wxCommandEvent& event);
void OnProsody(wxCommandEvent& event);
void PageCmd(wxCommandEvent& event);
void SetVoiceTitle(char *voice_name);
void OnPageChanged(wxNotebookEvent& event);

protected:
wxTimer m_timer;

DECLARE_EVENT_TABLE()
};


#ifdef deleted
class MyChild: public wxPanel
{
public:
SpectDisplay *canvas;
MyChild(wxNotebook *parent, const wxString& title, const wxPoint& pos, const wxSize& size, const long style);
~MyChild(void);
void OnActivate(wxActivateEvent& event);

void OnQuit(wxCommandEvent& event);
void OnSave(wxCommandEvent& event);
void OnSaveAs(wxCommandEvent& event);
void OnSaveSelect(wxCommandEvent& event);
void OnSavePitchenv(wxCommandEvent& event);
// void OnVoiceDlg(wxCommandEvent& event);

DECLARE_EVENT_TABLE()
};
#endif


class TranslDlg : public wxPanel
{//=============================
public:
TranslDlg(wxWindow *parent);

void OnKey(wxKeyEvent& event);
void SpeakFile(void);
void ReadVoice(int variant);
void OnCommand(wxCommandEvent& event);
wxTextCtrl* t_source;

private:
wxButton *t_translate;
wxButton *t_process;
wxTextCtrl* t_phonetic;


DECLARE_EVENT_TABLE()
};

extern MyFrame *myframe;
extern wxNotebook* screenpages;
extern TranslDlg *transldlg;
extern wchar_t ipa1[256];


enum {
MENU_QUIT = 1,
MENU_OPEN,
MENU_SPECTRUM,
MENU_SPECTRUM2,
MENU_CLOSE_ALL,
MENU_ABOUT,
MENU_DOCS,

MENU_OPTIONS,
MENU_OPT_SPEED,
MENU_OPT_PUNCT,
MENU_OPT_SPELL,
MENU_OPT_SPELL2,
MENU_PATHS,
MENU_PATH_DATA,
MENU_PATH0,
MENU_PATH1,
MENU_PATH2,
MENU_PATH3,
MENU_PATH4,

MENU_PROSODY,
MENU_COMPILE_PH,
MENU_COMPILE_PH2,
MENU_COMPILE_DICT,
MENU_COMPILE_DICT_DEBUG,
MENU_FORMAT_DICTIONARY,
MENU_SORT_DICTIONARY,
MENU_COMPILE_MBROLA,
MENU_COMPILE_INTONATION,

MENU_SPEAK_TRANSLATE,
MENU_SPEAK_RULES,
MENU_SPEAK_IPA,
MENU_SPEAK_TEXT,
MENU_SPEAK_FILE,
MENU_SPEAK_PAUSE,
MENU_SPEAK_STOP,
MENU_SPEAK_VOICE,
MENU_SPEAK_VOICE_VARIANT,
MENU_LOAD_WAV,

MENU_VOWELCHART,
MENU_VOWELCHART1,
MENU_VOWELCHART2,
MENU_VOWELCHART3,
MENU_LEXICON,
MENU_LEXICON_RU,
MENU_LEXICON_BG,
MENU_LEXICON_DE,
MENU_LEXICON_IT,
MENU_LEXICON_TEST,
MENU_TO_UTF8,
MENU_COUNT_WORDS,
MENU_TEST,
MENU_TEST2,

SPECTSEQ_CLOSE,
SPECTSEQ_SAVE,
SPECTSEQ_SAVEAS,
SPECTSEQ_SAVESELECT,
SPECTSEQ_SAVEPITCH,
SPECTSEQ_VOICEDLG,

ID_SCREENPAGES,
ID_NOTEBOOK
};


// wxWidgets 3 name changes
#if wxCHECK_VERSION(3, 0, 0)
#define wxOPEN wxFD_OPEN
#define wxSAVE wxFD_SAVE
#define WXK_PRIOR WXK_PAGEUP
#define WXK_NEXT WXK_PAGEDOWN
#endif


+ 0
- 174
src/menus.cpp View File

/***************************************************************************
* Copyright (C) 2005 to 2013 by Jonathan Duddington *
* email: [email protected] *
* *
* 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 "wx/wx.h"

#include "main.h"

wxMenu *speak_menu;
wxMenu *data_menu = NULL;
wxMenuBar *menu_bar = NULL;


wxMenuBar *MakeMenu(int type, const char *dict_name)
{//===================================================
char buf[100];
wxMenu *old_menu;
wxMenu *file_menu;
wxMenu *help_menu;
wxMenu *option_menu = NULL;
wxMenu *paths_menu;
wxMenu *tools_menu;
wxMenu *voice_menu;
wxMenu *vowelchart_menu;
wxMenu *lexicon_menu;

// FILE MENU
file_menu = new wxMenu;
file_menu->Append(MENU_SPECTRUM, _("&Open..."));
file_menu->Append(MENU_SPECTRUM2, _("O&pen2..."));
// file_menu->Append(MENU_PROSODY, _T("&Prosody window"));
if(type<=1)
{
}
else
if(type==2)
{
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_CLOSE, _("&Close"));
file_menu->Append(MENU_CLOSE_ALL, _T("Close &All"));
}
else
if(type==3)
{
// file_menu->Append(SPECTSEQ_SAVE, _("&Save"));
// file_menu->Append(SPECTSEQ_SAVEAS, _("Save &As..."));
file_menu->Append(SPECTSEQ_CLOSE, _("&Close"));
file_menu->Append(MENU_CLOSE_ALL, _T("Close &All"));
}
file_menu->Append(MENU_QUIT, _("&Quit"));

if(type==0)
{
// Initialization, make all the menus
// SPEAK_MENU
speak_menu = new wxMenu;
speak_menu->Append(MENU_SPEAK_TRANSLATE, _("&Translate"));
speak_menu->Append(MENU_SPEAK_RULES, _("Show &Rules"));
speak_menu->Append(MENU_SPEAK_IPA, _("Show &IPA"));
speak_menu->Append(MENU_SPEAK_TEXT, _("&Speak"));
speak_menu->AppendSeparator();
speak_menu->Append(MENU_SPEAK_FILE, _("Speak &file..."));
speak_menu->Append(MENU_SPEAK_PAUSE, _("&Pause"));
speak_menu->Append(MENU_SPEAK_STOP, _("St&op"));

// VOICE MENU
voice_menu = new wxMenu;
voice_menu->Append(MENU_SPEAK_VOICE, _("Select &Voice.."));
voice_menu->Append(MENU_SPEAK_VOICE_VARIANT, _("Select Voice Va&riant..."));

// DATA MENU
data_menu = new wxMenu;
data_menu->Append(MENU_COMPILE_DICT, _("Compile &dictionary"));
data_menu->Append(MENU_COMPILE_DICT_DEBUG, _("Compile dictionary (debu&g)"));
data_menu->Append(MENU_COMPILE_PH, _("Compile &phoneme data 22050Hz"));
data_menu->Append(MENU_COMPILE_PH2, _("Compile at sample &rate"));
data_menu->AppendSeparator();
data_menu->Append(MENU_COMPILE_MBROLA, _("Compile &mbrola phonemes list..."));
data_menu->Append(MENU_COMPILE_INTONATION, _("Compile &intonation data"));
data_menu->AppendSeparator();
data_menu->Append(MENU_FORMAT_DICTIONARY, _("&Layout *_rules file"));
data_menu->Append(MENU_SORT_DICTIONARY, _("&Sort *_rules file"));

sprintf(buf,"Compile &dictionary '%s'",dict_name);
data_menu->SetLabel(MENU_COMPILE_DICT, wxString(buf,wxConvLocal));
sprintf(buf,"&Layout '%s_rules' file",dict_name);
data_menu->SetLabel(MENU_FORMAT_DICTIONARY, wxString(buf,wxConvLocal));
sprintf(buf,"&Sort '%s_rules' file",dict_name);
data_menu->SetLabel(MENU_SORT_DICTIONARY, wxString(buf,wxConvLocal));

// OPTIONS MENU
paths_menu = new wxMenu;
paths_menu->Append(MENU_PATH0, _("Master phonemes file..."));
paths_menu->Append(MENU_PATH1, _("Phoneme data source..."));
paths_menu->Append(MENU_PATH2, _("Dictionary data source..."));
paths_menu->Append(MENU_PATH3, _("Synthesized sound WAV file..."));
paths_menu->AppendSeparator();
paths_menu->Append(MENU_PATH4, _("Voice file to modify formant peaks..."));

option_menu = new wxMenu;
option_menu->Append(MENU_PATHS, _("Set &paths"), paths_menu);
option_menu->Append(MENU_OPT_SPEED, _("Speed..."));
option_menu->AppendSeparator();
option_menu->Append(MENU_OPT_PUNCT, _("Speak punctuation"));
option_menu->Append(MENU_OPT_SPELL, _("Speak characters"));
option_menu->Append(MENU_OPT_SPELL2, _("Speak character name"));

// TOOLS
vowelchart_menu = new wxMenu;
vowelchart_menu->Append(MENU_VOWELCHART1, _("From compiled phoneme data"));
// vowelchart_menu->Append(MENU_VOWELCHART2, _("From list of formants..."));
vowelchart_menu->Append(MENU_VOWELCHART3, _("From directory of vowel files..."));

lexicon_menu = new wxMenu;
lexicon_menu->Append(MENU_LEXICON_RU, _("Russian"));
lexicon_menu->Append(MENU_LEXICON_BG, _("Bulgarian"));
lexicon_menu->Append(MENU_LEXICON_DE, _("German"));
lexicon_menu->Append(MENU_LEXICON_IT, _("Italian"));
// lexicon_menu->Append(MENU_LEXICON_TEST, _("Test"));

tools_menu = new wxMenu;
tools_menu->Append(MENU_VOWELCHART, _("Make &Vowels Chart"), vowelchart_menu);
// tools_menu->Append(MENU_LOAD_WAV, _T("Analyse WAV file"));
tools_menu->Append(MENU_LEXICON, _("Process &Lexicon"), lexicon_menu);
tools_menu->Append(MENU_TO_UTF8, _("Convert file to &UTF8..."));
tools_menu->Append(MENU_COUNT_WORDS, _("Count word &frequencies..."));
tools_menu->Append(MENU_TEST , _("Test (temporary)"));
// tools_menu->Append(MENU_TEST2 , _T("Test2"));

// HELP MENU
help_menu = new wxMenu;
help_menu->Append(MENU_DOCS, _("eSpeak &Documentation"));
help_menu->Append(MENU_ABOUT, _("&About"));


menu_bar = new wxMenuBar;

menu_bar->Append(file_menu, _("&File"));
menu_bar->Append(speak_menu, _("&Speak"));
menu_bar->Append(voice_menu, _("&Voice"));
menu_bar->Append(option_menu, _("&Options"));
menu_bar->Append(tools_menu, _("&Tools"));
menu_bar->Append(data_menu, _("&Compile"));
menu_bar->Append(help_menu, _("&Help"));
}
else
{
// Just replace the File menu
old_menu = menu_bar->Replace(0, file_menu, _("&File"));
delete old_menu;
}
return(menu_bar);
} // end of MakeMenu



+ 1
- 108
src/options.cpp View File

#include "wx/msw/registry.h" #include "wx/msw/registry.h"
#endif #endif


#include "main.h"

#include "options.h"

extern "C" void WavegenInit(int samplerate, int wavemult_fact);
extern void strncpy0(char *to,const char *from, int size);
extern int GetNumeric(wxTextCtrl *t);
extern void SetNumeric(wxTextCtrl *t, int value);
extern int samplerate;

wxString path_espeakdata; wxString path_espeakdata;
wxString path_spectload; wxString path_spectload;
wxString path_spectload2; wxString path_spectload2;
wxString path_pitches; wxString path_pitches;
wxString path_wave;
wxString path_speech;
wxString path_phfile; wxString path_phfile;
wxString path_phsource; wxString path_phsource;
wxString path_dictsource; wxString path_dictsource;
wxString path_speaktext;
wxString path_modifiervoice; wxString path_modifiervoice;
wxString path_dir1; wxString path_dir1;
int option_speed=160;


char path_source[sizeof(path_home)+20];
char path_dsource[sizeof(path_home)+20]; char path_dsource[sizeof(path_home)+20];
char voice_name2[40]; char voice_name2[40];


BEGIN_EVENT_TABLE(Options, wxDialog)
EVT_BUTTON(wxID_SAVE,Options::OnCommand)
EVT_BUTTON(wxID_CLOSE,Options::OnCommand)
END_EVENT_TABLE()


Options::Options(wxWindow *parent) : wxDialog(parent,-1,_T("Options"),wxDefaultPosition,wxDefaultSize)
{//===================================================================================================

m_lab[0] = new wxStaticText(this,-1,_T("Sample rate"),wxPoint(72,84));
m_samplerate = new wxTextCtrl(this,-1,_T(""),wxPoint(8,80),wxSize(60,24));
SetNumeric(m_samplerate,samplerate);

m_save = new wxButton(this,wxID_SAVE,_T("Save"),wxPoint(8,120));
m_close = new wxButton(this,wxID_CLOSE,_T("Cancel"),wxPoint(98,120));
Show();
}


Options::~Options()
{//================
int ix;

for(ix=0; ix < 1; ix++)
delete m_lab[ix];

delete m_samplerate;
delete m_save;
delete m_close;
}

void Options::OnCommand(wxCommandEvent& event)
{//===========================================
int id;
int value;

switch(id = event.GetId())
{
case wxID_SAVE:
value = GetNumeric(m_samplerate);
if(value > 0) WavegenInit(value,0);

Destroy();
break;

case wxID_CLOSE:
Destroy();
break;
}
}



void ConfigSetPaths() void ConfigSetPaths()
{//================== {//==================
// set c_string paths from wxStrings // set c_string paths from wxStrings
pConfig->Read(_T("/spectload"),&path_spectload,basedir+_T("/phsource")); pConfig->Read(_T("/spectload"),&path_spectload,basedir+_T("/phsource"));
pConfig->Read(_T("/spectload2"),&path_spectload2,basedir+_T("/phsource")); pConfig->Read(_T("/spectload2"),&path_spectload2,basedir+_T("/phsource"));
pConfig->Read(_T("/pitchpath"),&path_pitches,basedir+_T("/pitch")); pConfig->Read(_T("/pitchpath"),&path_pitches,basedir+_T("/pitch"));
pConfig->Read(_T("/wavepath"),&path_wave,wxEmptyString);
pConfig->Read(_T("/speechpath"),&path_speech,wxEmptyString);
pConfig->Read(_T("/voicename"),&string,wxEmptyString); pConfig->Read(_T("/voicename"),&string,wxEmptyString);
strcpy(voice_name2,string.mb_str(wxConvLocal));
pConfig->Read(_T("/phsource"),&path_phsource,basedir+_T("/phsource")); pConfig->Read(_T("/phsource"),&path_phsource,basedir+_T("/phsource"));
pConfig->Read(_T("/phfile"),&path_phfile,path_phsource+_T("/phonemes")); pConfig->Read(_T("/phfile"),&path_phfile,path_phsource+_T("/phonemes"));
pConfig->Read(_T("/dictsource"),&path_dictsource,basedir+_T("/dictsource")); pConfig->Read(_T("/dictsource"),&path_dictsource,basedir+_T("/dictsource"));
pConfig->Read(_T("/speaktext"),&path_speaktext,wxEmptyString);
pConfig->Read(_T("/modifiervoice"),&path_modifiervoice,basedir); pConfig->Read(_T("/modifiervoice"),&path_modifiervoice,basedir);
pConfig->Read(_T("/dir1"),&path_dir1,basedir); pConfig->Read(_T("/dir1"),&path_dir1,basedir);
option_speed = pConfig->Read(_T("/speed"),160);
frame_x = pConfig->Read(_T("/windowx"), 0l);
frame_y = pConfig->Read(_T("/windowy"), 0l);
frame_h = pConfig->Read(_T("/windowh"), 0l);
frame_w = pConfig->Read(_T("/windoww"), 0l);
} }
ConfigSetPaths(); ConfigSetPaths();
} // end of ConfigInit } // end of ConfigInit



void ConfigSave(int exit)
{//======================
wxFileConfig *pConfig = (wxFileConfig *)(wxConfigBase::Get());


#ifndef PLATFORM_WINDOWS
// pConfig->Write(_T("/samplerate"),samplerate);
#endif
pConfig->Write(_T("/espeakdata"),path_espeakdata);
pConfig->Write(_T("/spectload"),path_spectload);
pConfig->Write(_T("/spectload2"),path_spectload2);
pConfig->Write(_T("/pitchpath"),path_pitches);
pConfig->Write(_T("/wavepath"),path_wave);
pConfig->Write(_T("/speechpath"),path_speech);
pConfig->Write(_T("/voicename"),wxString(voice_name2,wxConvLocal));
pConfig->Write(_T("/phsource"),path_phsource);
pConfig->Write(_T("/phfile"),path_phfile);
pConfig->Write(_T("/dictsource"),path_dictsource);
pConfig->Write(_T("/speaktext"),path_speaktext);
pConfig->Write(_T("/speed"),option_speed);
pConfig->Write(_T("/modifiervoice"),path_modifiervoice);
pConfig->Write(_T("/dir1"),path_dir1);
pConfig->Write(_T("/windowx"),frame_x);
pConfig->Write(_T("/windowy"),frame_y);
pConfig->Write(_T("/windoww"),frame_w);
pConfig->Write(_T("/windowh"),frame_h);
if(exit)
delete wxFileConfig::Set((wxFileConfig *)NULL);
}

+ 0
- 71
src/options.h View File

/***************************************************************************
* Copyright (C) 2005 to 2007 by Jonathan Duddington *
* email: [email protected] *
* Copyright (C) 2013 by 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/>. *
***************************************************************************/

#ifndef OPTIONS_H
#define OPTIONS_H

#include "wx/dialog.h"
#include "wx/spinctrl.h"

/**
*@author Jonathan Duddington
*/

extern void ConfigInit(bool use_defaults);
extern void ConfigSave(int end);
extern void ConfigSetPaths();

extern wxString path_espeakdata;
extern wxString path_spectload;
extern wxString path_spectload2;
extern wxString path_pitches;
extern wxString path_phfile;
extern wxString path_phsource;
extern wxString path_dictsource;
extern wxString path_modifiervoice;
extern wxString path_dir1;
extern int frame_x, frame_y, frame_w, frame_h;

extern char path_source[sizeof(path_home)+20];
extern char path_dsource[sizeof(path_home)+20];

extern int option_speed;

extern void OnOptions2(int event_id);

// not currently used
class Options : public wxDialog {
public:
Options(wxWindow *parent);
~Options();

private:
void OnCommand(wxCommandEvent& event);

wxButton *m_save;
wxButton *m_close;
wxStaticText *m_lab[10];

wxTextCtrl *m_samplerate;

DECLARE_EVENT_TABLE()
};

#endif

+ 0
- 601
src/prosodydisplay.cpp View File

#include "wx/numdlg.h" #include "wx/numdlg.h"


#include "speak_lib.h" #include "speak_lib.h"
#include "main.h"
#include "speech.h" #include "speech.h"
#include "phoneme.h" #include "phoneme.h"
#include "synthesize.h" #include "synthesize.h"
#include "prosodydisplay.h"
#include "translate.h" #include "translate.h"


extern MyFrame *myframe;
extern ProsodyDisplay *prosodycanvas;

wxMenu *menu_prosody;


BEGIN_EVENT_TABLE(ProsodyDisplay, wxScrolledWindow)
EVT_LEFT_DOWN(ProsodyDisplay::OnMouse)
EVT_RIGHT_DOWN(ProsodyDisplay::OnMouse)
EVT_CHAR(ProsodyDisplay::OnKey)
EVT_MENU(-1, ProsodyDisplay::OnMenu)
END_EVENT_TABLE()


static wxPen PEN_PITCHENV(wxColour(0,0,255),1,wxSOLID);
static wxPen PEN_SAMPLED(wxColour(0,200,200),2,wxSOLID);
static wxPen PEN_PHSELECTED(wxColour(255,0,0),2,wxSOLID);
static wxPen PEN_PHSTRESSED(wxColour(80,80,196),3,wxSOLID);
static wxPen PEN_PHSTRESSED2(wxColour(160,160,255),2,wxSOLID);




typedef struct { typedef struct {
unsigned int value; unsigned int value;
char *name; char *name;
} }
fclose(f); fclose(f);
} }



ProsodyDisplay::ProsodyDisplay(wxWindow *parent, const wxPoint& pos, const wxSize& size)
: wxScrolledWindow(parent, -1, pos, size,
wxSUNKEN_BORDER | wxNO_FULL_REPAINT_ON_RESIZE)
{//=====================================================================

linewidth = size.GetWidth();
scalex = 0.5;
scaley = double(LINESEP*6)/150.0;
selected_ph = -1;
SetBackgroundColour(wxColour(245,245,245));
} // end of ProsodyDisplay::ProsodyDisplay


ProsodyDisplay::~ProsodyDisplay()
{//==========================
prosodycanvas = NULL;
}

extern MNEM_TAB envelope_names[];

void InitProsodyDisplay()
{//======================
wxMenu *menu_envelopes;
int ix;
wxString string;

ReadPhondataManifest();
menu_envelopes = new wxMenu;
// entries match those in envelope_data[] in intonation.cpp

for(ix=0; envelope_names[ix].mnem != NULL; ix++)
{
string = wxString(envelope_names[ix].mnem, wxConvLocal);
menu_envelopes->Append(0x100+envelope_names[ix].value, string);
}
menu_prosody = new wxMenu;
menu_prosody->Append(1,_T("Pitch envelope"),menu_envelopes);
menu_prosody->Append(2,_T("Amplitude"));
menu_prosody->Append(3,_T("Length"));
menu_prosody->Append(4,_T("Play F2"));
}


void ProsodyDisplay::RefreshLine(int line)
{//=====================================
int x,y;

CalcScrolledPosition(0,line*FRAMEHEIGHT,&x,&y);
RefreshRect(wxRect(0,y,linewidth,FRAMEHEIGHT));
}


int ProsodyDisplay::GetWidth(PHONEME_LIST *p)
{//========================================
int w;

if(p->ph == NULL)
return(0);

w = (p->ph->std_length * 2);
if(w == 0) w = 60;

if(p->length != 0)
w = (w * p->length) / 256;

return(int((w + p->prepause)* scalex) + 1);
}


void ProsodyDisplay::SelectPh(int index)
{//=====================================
// A phoneme has been selected
PHONEME_LIST *p;
const char *emphasized;
int y1, y2;
int ix;
const char *name = "?";
char buf[120];
char len_string[20];
char param_string[20];

if(index < 0) return;

p = &phlist[index];
if((p == NULL) || (p->ph == NULL)) return;

emphasized = "";
if(p->stresslevel & 8)
emphasized = "*";

for(ix=0; envelope_names[ix].mnem != NULL; ix++)
{
if(envelope_names[ix].value == (p->env & 0xfe))
{
name = envelope_names[ix].mnem;
break;
}
}
y1 = p->pitch1;
y2 = p->pitch2;
len_string[0] = 0;
param_string[0] = 0;
if(p->std_length > 0)
sprintf(len_string," Length %d", p->std_length*2);
if(p->sound_param != 0)
sprintf(param_string,", %d", p->sound_param);

sprintf(buf,"Stress %s%d Amp %2d LengthMod %2d Pitch %3d %3d %s PhFlags %.2x (%s%s)%s",
emphasized,p->stresslevel&0x7,p->amp, p->length,y1,y2,name,p->ph->phflags, LookupManifest(p->phontab_addr), param_string, len_string);
wxLogStatus(wxString(buf,wxConvLocal));
}


void ProsodyDisplay::ChangePh(int pitch1, int pitch2)
{//================================================
PHONEME_LIST *p;
int sign1;
int sign2;

if(selected_ph < 0)
return;

p = &phlist[selected_ph];
sign1 = p->pitch1 - p->pitch2;
p->pitch1 += pitch1;
p->pitch2 += (pitch1 + pitch2);
sign2 = p->pitch1 - p->pitch2;

if((sign1 != 0) && ((sign1 * sign2) <= 0))
{
// change of sign, change rise to fall
if(p->env == 1)
p->env = 0;
else
if(p->env == 0)
p->env = 1;
}
}


void ProsodyDisplay::OnMenu(wxCommandEvent& event)
{//===============================================
int id;
int value;
PHONEME_LIST *p;

id = event.GetId();
p = &phlist[selected_ph];

if((id & 0xf00) == 0x100)
{
// selected a pitch envelope
p->env = id - 0x100;
}

switch(id)
{
case 2:
value = wxGetNumberFromUser(_T(""),_T("Amplitude"),_T(""),p->amp,0,40);
if(value >= 0)
p->amp = value;
break;
case 3:
value = wxGetNumberFromUser(_T(""),_T("Length"),_T(""),p->length,1,500);
if(value >= 0)
p->length = value;
break;
case 4:
MakeWave2(phlist,numph);
break;
}
SelectPh(selected_ph);
Refresh();
}


void ProsodyDisplay::OnMouse(wxMouseEvent& event)
{//============================================
int line;
int ix;
int xpos=0;


wxClientDC dc(this);
PrepareDC(dc);
wxPoint pt(event.GetLogicalPosition(dc));

if(selected_ph >= 0)
{
// find line for previously selected phoneme
for(line=0; line<num_lines; line++)
if(linetab[line+1] > selected_ph) break;
RefreshLine(line);
selected_ph = -1;
}

line = pt.y / FRAMEHEIGHT;

if(line < num_lines)
{
// find which phoneme is selected on this line
for(ix=linetab[line]; (ix<linetab[line+1]) && (ix<numph); ix++)
{
xpos += GetWidth(&phlist[ix]);
if(xpos > pt.x)
{
selected_ph = ix;
SelectPh(selected_ph);
break;
}
}

RefreshLine(line);
}

if(event.RightDown())
{
PopupMenu(menu_prosody);
}

} // end of ProsodyDisplay::OnMouse


void ProsodyDisplay::OnKey(wxKeyEvent& event)
{//========================================
PHONEME_LIST *p;
int display=1;

if(selected_ph < 0)
selected_ph = 0;

p = &phlist[selected_ph];

switch(event.GetKeyCode())
{
case WXK_F2:
// make and play from this clause
MakeWave2(phlist,numph);
break;

case WXK_LEFT:
if(selected_ph > 1)
selected_ph--;
break;

case WXK_RIGHT:
if(selected_ph < (numph-2))
selected_ph++;
break;

case WXK_UP:
if(event.ControlDown())
ChangePh(-1,2);
else
ChangePh(1,0);
display = 1;
break;

case WXK_DOWN:
if(event.ControlDown())
ChangePh(1,-2);
else
ChangePh(-1,0);
break;

case ',':
case '<':
if(p->length > 0)
p->length--;
break;

case '.':
case '>':
p->length++;
break;

case WXK_TAB:
display = 0;
event.Skip();
transldlg->SetFocus();
break;

default:
display = 0;
event.Skip();
break;
}

if(display)
{
Refresh();
SelectPh(selected_ph);
}
} // end of ProsodyDisplay::OnKey


void ProsodyDisplay::DrawEnv(wxDC& dc, int x1, int y1, int width, PHONEME_LIST *ph)
{//==============================================================================
int pitchr;
int pitch;
int p1;
int ix;
int x,y;
int y2=0;
unsigned char *env;
PHONEME_DATA phdata_tone;

if(width <= 0) return;

if((pitchr = ph->pitch2 - ph->pitch1) < 0)
{
pitchr = -pitchr;
p1 = ph->pitch2;
}
else
{
p1 = ph->pitch1;
}

if(p1 == 255) return;

dc.SetPen(PEN_PITCHENV);

env = envelope_data[ph->env];
if((ph->type == phVOWEL) && (ph->tone_ph != 0))
{
// the envelope is given by a Tone phoneme acting on this vowel
InterpretPhoneme2(ph->tone_ph, &phdata_tone);
env = GetEnvelope(phdata_tone.pitch_env);
}

if(env == NULL)
return;

for(ix=0; ix<=width; ix+=4)
{
x = int((ix * 127.9)/width);
pitch = p1 + (pitchr * env[x])/256;
y = y1-int(pitch * scaley);
if(ix > 0)
dc.DrawLine(x1+ix-4,y2,x1+ix,y);
y2 = y;
}
} // end of DrawEnv



static void GetPhonemeName(PHONEME_TAB *ph, wxString& string)
{//==========================================================
string = wxString(WordToString(ph->mnemonic),wxConvLocal);
}


void ProsodyDisplay::DrawPitchline(wxDC& dc, int line, int x1, int x2)
{//=================================================================
int ix;
int endix;
int y;
int offy;
int xpos;
int width; // total width, including pre-pause
int width2; // width without pre-pause
int width_env;
int textwidth, textheight;
wxString string;
PHONEME_LIST *p;

if(linetab[line] >= numph) return;

offy = (line+1) * FRAMEHEIGHT - 1;

y = LINEBASE+LINESEP;
dc.SetPen(*wxLIGHT_GREY_PEN);
// dc.SetPen(*wxCYAN_PEN);
for(ix=0; ix<5; ix++)
{
dc.DrawLine(0,offy-y,linewidth,offy-y);
y += LINESEP;
}

endix = linetab[line+1];

xpos = 0;
for(ix=linetab[line]; ix<endix; ix++)
{
if(ix < 0 || ix > numph-2) break;
if(xpos > x2) break; // past the redraw region

p = &phlist[ix];

width = GetWidth(p);
width2 = width - int(p->prepause * scalex) - 1;

if(xpos+width < x1)
{
xpos += width;
continue; // before the redraw region
}

// is this a stressed vowel ?
if((p->type == phVOWEL) && (p->stresslevel >= 2))
{
if(p->stresslevel >= 4)
dc.SetPen(PEN_PHSTRESSED);
else
dc.SetPen(PEN_PHSTRESSED2);
dc.DrawLine(xpos,offy-LINEBASE-1,xpos+width,offy-LINEBASE-1);
}

// is this phoneme selected ?
if(ix == selected_ph)
{
dc.SetPen(PEN_PHSELECTED);
dc.DrawLine(xpos,offy-LINEBASE,xpos+width,offy-LINEBASE);
}

// draw separator bar
if(p->newword)
dc.SetPen(*wxBLACK_PEN); // word boundary
else
dc.SetPen(*wxLIGHT_GREY_PEN);

dc.DrawLine(xpos,offy-LINEBASE,xpos,offy-LINEBASE-LINESEP*6);

// draw pitch envelope
if(((p->ph->phflags & phWAVE) == 0) && (p->ph->type != phPAUSE))
{
if(!(p->synthflags & SFLAG_SEQCONTINUE))
{
width_env = width2;
if(phlist[ix+1].synthflags & SFLAG_SEQCONTINUE)
width_env += GetWidth(&phlist[ix+1]);
DrawEnv(dc,xpos+1+(width-width2),offy-LINEBASE,width_env,p);
}
}
else
if(p->type != phPAUSE)
{
// sampled sound, draw a flat line
dc.SetPen(PEN_SAMPLED);
dc.DrawLine(xpos+1+(width-width2),offy-LINEBASE-LINESEP,
xpos+1+width,offy-LINEBASE-LINESEP);
}

// show phoneme name from the PHONEME_TAB
GetPhonemeName(p->ph,string);
dc.GetTextExtent(string,&textwidth,&textheight);
dc.DrawText(string,xpos+(width-textwidth/2)/2, offy-LINEBASE);

xpos += width;
}

// draw the separator bar at the end of the line
if(ix==endix && ix<numph && phlist[ix].newword)
dc.SetPen(*wxLIGHT_GREY_PEN);
else
dc.SetPen(*wxBLACK_PEN); // word boundary or end of list
dc.DrawLine(xpos,offy-LINEBASE,xpos,offy-LINEBASE-LINESEP*6);

} // end of ProsodyDisplay::DrawPitchline


void ProsodyDisplay::OnDraw(wxDC& dc)
{//================================
int x1,y1;
int vX,vY,vW,vH; // Dimensions of client area in pixels

int line, start, end;

GetClientSize(&x1, &y1);
if(x1 != linewidth)
{
LayoutData(NULL, 0);
}

wxRegionIterator upd(GetUpdateRegion()); // get the update rect list

while (upd)
{
vX = upd.GetX();
vY = upd.GetY();
vW = upd.GetW();
vH = upd.GetH();

CalcUnscrolledPosition(vX,vY,&x1,&y1);

// Repaint this rectangle, find which lines to redraw
start = y1/FRAMEHEIGHT;
end = (y1+vH)/FRAMEHEIGHT;

for(line=start; line<=end && line<num_lines; line++)
DrawPitchline(dc,line,x1,x1+vW);

upd ++ ;
}
} // end of ProsodyDisplay::OnDraw


void ProsodyDisplay::LayoutData(PHONEME_LIST *ph_list, int n_ph)
{//===========================================================
// divide the phoneme list into lines for display
int xpos;
int w;
int ix;
int height;
PHONEME_LIST *p;

if(ph_list != NULL)
{
numph = n_ph;
phlist = ph_list;
}

num_lines = 0;
linetab[0] = 1;
GetClientSize(&linewidth, &height);
xpos = linewidth;

// could improve this to do 'wordwrap' - only split on word boundary
// or unvoiced phonemes

for(ix=1; ix<numph-2; ix++)
{
p = &phlist[ix];
w = GetWidth(p);

if(w + xpos >= linewidth)
{
linetab[num_lines++] = ix;
xpos = 0;
}
xpos += w;
}
linetab[num_lines]=numph-2;

SetScrollbars(SCROLLUNITS,SCROLLUNITS,linewidth/SCROLLUNITS,
(num_lines*FRAMEHEIGHT)/SCROLLUNITS+1);

Refresh();
} // end of ProsodyDisplay::LayoutData


extern int adding_page;

void MyFrame::OnProsody(wxCommandEvent& WXUNUSED(event))
{//=====================================================
// Open the Prosody display window
int width, height;
int ix, npages;

if(prosodycanvas != NULL)
{
// The Prosody window is already open

// ?? select the prosody page ??
npages = screenpages->GetPageCount();
for(ix=0; ix<npages; ix++)
{
if(screenpages->GetPage(ix) == (wxWindow*)prosodycanvas)
{
screenpages->ChangeSelection(ix);
break;
}
}
return;
}


screenpages->GetClientSize(&width, &height);
prosodycanvas = new ProsodyDisplay(screenpages, wxPoint(0, 50), wxSize(width-10, height));
adding_page = 2; // work around for wxNotebook bug (version 2.8.7)
screenpages->AddPage(prosodycanvas, _T("Prosody"), true);
}

+ 0
- 50
src/prosodydisplay.h View File




#define FRAMEHEIGHT 120
#define LINEBASE 20
#define LINESEP 16

#define SCROLLUNITS 20




class ProsodyDisplay: public wxScrolledWindow
{//========================================
public:
ProsodyDisplay(wxWindow *parent, const wxPoint& pos, const wxSize& size);
~ProsodyDisplay();

virtual void OnDraw(wxDC& dc);
void OnMouse(wxMouseEvent& event);
void OnKey(wxKeyEvent& event);
void OnMenu(wxCommandEvent& event);

void Save(const wxString &path=_T(""));
void LayoutData(PHONEME_LIST *phlist, int n_ph);

private:
void Redraw(wxDC& dc, int x1, int y1, int x2, int y2);
void DrawEnv(wxDC& dc, int x1, int y1, int width, PHONEME_LIST *ph);
void DrawPitchline(wxDC& dc, int line, int x1, int x2);
void RefreshLine(int line);
int GetWidth(PHONEME_LIST *p);
void ChangePh(int pitch1, int pitch2);
void SelectPh(int index);

int linewidth; // height for drawing pitch
double scalex; // scale length values
double scaley; // scale pitch values
int selected_ph;

int numph;
PHONEME_LIST *phlist;
int num_lines;
short linetab[N_PHONEME_LIST/2];

DECLARE_EVENT_TABLE()
}; // end class ProsodyDisplay




+ 1
- 182
src/spect.cpp View File

/*************************************************************************** /***************************************************************************
* Copyright (C) 2005 to 2007 by Jonathan Duddington * * Copyright (C) 2005 to 2007 by Jonathan Duddington *
* email: [email protected] * * email: [email protected] *
* Copyright (C) 2013 by Reece H. Dunn *
* Copyright (C) 2013-2015 by Reece H. Dunn *
* * * *
* This program is free software; you can redistribute it and/or modify * * 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 * * it under the terms of the GNU General Public License as published by *


#include "speak_lib.h" #include "speak_lib.h"
#include "speech.h" #include "speech.h"
#include "main.h"
#include "phoneme.h" #include "phoneme.h"
#include "synthesize.h" #include "synthesize.h"
#include "voice.h" #include "voice.h"
#include "spect.h" #include "spect.h"
#include "options.h"
#include "wx/txtstrm.h" #include "wx/txtstrm.h"
#include "wx/brush.h" #include "wx/brush.h"
#include "wx/datstrm.h" #include "wx/datstrm.h"
static int default_klt_bw[N_PEAKS] = static int default_klt_bw[N_PEAKS] =
{89,90,140,260,260,260,500,500,500}; {89,90,140,260,260,260,500,500,500};


float SpectTilt(int value, int freq)
{//=================================
float x;
float y;

if((currentcanvas == NULL) || (currentcanvas->spectseq->bass_reduction == 0))
return(float(value));

y = value*value*2;

if(freq < 600)
{
return(sqrt(y/2.5));
}
else
if(freq < 1050)
{
x = 1.0 + ((1050.0-freq)* 1.5)/450.0;
return(sqrt(y/x));
}
else
{
return(sqrt(y));
}
}


SpectFrame::SpectFrame(SpectFrame *copy) SpectFrame::SpectFrame(SpectFrame *copy)
{//===================================== {//=====================================


} }




void SpectFrame::ApplyVoiceMods()
{//==============================
// apply the modifications to the formants which are defined in the current voice
int pk;
char voice_name1[40];

strcpy(voice_name1, voice_name2); // remember current voice name

if(LoadVoice(path_modifiervoice.mb_str(wxConvLocal),0x13) == NULL)
{
wxLogError(_T("Can't read voice: ")+path_modifiervoice);
OnOptions2(MENU_PATH4);
return;
}

wxLogStatus(_T("Convert using voice: ")+path_modifiervoice);

for(pk=0; pk<N_PEAKS; pk++)
{
peaks[pk].pkfreq = (peaks[pk].pkfreq * voice->freq2[pk])/256;
peaks[pk].pkheight = (peaks[pk].pkheight * voice->height2[pk])/256;
peaks[pk].pkwidth = (peaks[pk].pkwidth * voice->width2[pk])/256;
peaks[pk].pkright = (peaks[pk].pkright * voice->width2[pk])/256;
}
LoadVoice(voice_name1,1);
}




double SpectFrame::GetRms(int seq_amplitude) double SpectFrame::GetRms(int seq_amplitude)
{//========================================= {//=========================================






void SpectFrame::Draw(wxDC& dc, int offy, int frame_width, double scalex, double scaley)
{//=====================================================================================
int pt;
int peak;
peak_t *pk;
int ix;
double x0, x1;
int y0, y1;
int x, x2, x3;
double xinc;
double yf;
int font_height;
wxString text;

if(currentcanvas == NULL)
return;

dc.SetFont(*wxSWISS_FONT);

xinc = dx * scalex;

x0 = xinc;
x1 = nx * xinc;

if(selected) // this frame is selected
{
// highlight selected peak by drawing a red triangle
pk = &peaks[pk_select];

x2 = int(pk->pkright * scalex * 0.44);
x3 = int(pk->pkwidth * scalex * 0.44);
x = int((pk->pkfreq) * scalex);
y1 = (pk->pkheight * FRAME_HEIGHT) >> 14;
if(y1 < 5) y1 = 5;

wxPoint triangle[3];
dc.SetBrush(BRUSH_SELECTED_PEAK);
dc.SetPen(*wxTRANSPARENT_PEN);
triangle[0] = wxPoint(0,-y1);
triangle[1] = wxPoint(x2,0);
triangle[2] = wxPoint(-x3,0);
dc.DrawPolygon(3,triangle,x,offy);
}

// draw the measured formants
dc.SetPen(BLUE_PEN);
for(peak=1; peak<=5; peak++)
{
if(formants[peak].freq != 0)
{
// set height from linear interpolation of the adjacent
// points in the spectrum
pt = (int)(formants[peak].freq / dx);
y0 = spect[pt-1];
y1 = spect[pt];
yf = (y1-y0) * (formants[peak].freq - pt*dx)/dx;

y1 = offy - (int)((y0+yf) * scaley);
x1 = formants[peak].freq * scalex;
dc.DrawLine((int)x1,offy,(int)x1,y1);

}
}

// draw the spectrum outline
if(keyframe)
dc.SetPen(*wxBLACK_PEN);
else
dc.SetPen(*wxMEDIUM_GREY_PEN);

if(spect != NULL)
{
y0 = offy - (int)(spect[0] * scaley);
for(pt=1; pt<nx; pt++)
{
x1 = x0 + xinc;
y1 = offy - (int)(SpectTilt(spect[pt],int(pt*dx)) * scaley);
dc.DrawLine((int)x0,y0,(int)x1,y1);
x0 = x1;
y0 = y1;
}
}

if(currentcanvas->zoom < 2)
dc.SetFont(FONT_SMALL);
else
dc.SetFont(FONT_MEDIUM);


// Markers
x = frame_width - 120 - 32;
for(ix=0; ix<N_MARKERS; ix++)
{
if(markers & 1<<ix)
{
dc.SetBrush(BRUSH_MARKER[ix]);
y0 = offy-FRAME_HEIGHT+22;
dc.DrawRectangle(x,y0,22,22);
if(currentcanvas->zoom > 2)
{
text.Printf(_T("%d"),ix);
dc.DrawText(text,x+2,y0);
}
x -= 26;
}
}

DrawPeaks(&dc,offy,frame_width,currentcanvas->spectseq->amplitude,scalex);

font_height = int(15 / currentcanvas->zoomy);

text.Printf(_T("%3dmS %.1fHz"),int(time*1000),pitch);
dc.DrawText(text,frame_width-130,offy-FRAME_HEIGHT+20+font_height);
if(keyframe || rms > 0)
{
text.Printf(_T("%3d"),(int)rms);
dc.DrawText(text,frame_width-130,offy-FRAME_HEIGHT+20+font_height*2);
}
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine(0,offy,frame_width,offy); // base line

} // end of SpectFrame::Draw


void SpectFrame::KlattDefaults() void SpectFrame::KlattDefaults()
{//============================ {//============================
// set default values for Klatt parameters // set default values for Klatt parameters

+ 0
- 181
src/spect.h View File

#define FILEID2_PRAATSEQ 0x51455354 #define FILEID2_PRAATSEQ 0x51455354




class MyFrame;

typedef struct { typedef struct {
unsigned short pitch1; unsigned short pitch1;
unsigned short pitch2; unsigned short pitch2;
int ImportSPC2(wxInputStream &stream, float &time_acc); int ImportSPC2(wxInputStream &stream, float &time_acc);
int Load(wxInputStream &stream, int file_format_type); int Load(wxInputStream &stream, int file_format_type);
int Save(wxOutputStream &stream, int file_format_type); int Save(wxOutputStream &stream, int file_format_type);
void Draw(wxDC &dc, int offy, int frame_width, double scalex, double scaley);


void ZeroPeaks(); void ZeroPeaks();
void CopyPeaks(SpectFrame *sf); void CopyPeaks(SpectFrame *sf);
void ToggleMarker(int n); void ToggleMarker(int n);
void ApplyVoiceMods();


void MakeWaveF(int peaks, PitchEnvelope &pitch, int amplitude, int duration);
void MakeHtab(int numh, int *htab, int pitch); void MakeHtab(int numh, int *htab, int pitch);
double GetRms(int amp); double GetRms(int amp);
void KlattDefaults(); void KlattDefaults();
int ImportSPC2(wxInputStream& stream); int ImportSPC2(wxInputStream& stream);
int Save(wxOutputStream& stream, int selection); int Save(wxOutputStream& stream, int selection);
int Load(wxInputStream& stream); int Load(wxInputStream& stream);
void Draw(wxDC &dc, int start_y, int end_y);
void MakePitchenv(PitchEnvelope &pitch, int start_frame, int end_frame); void MakePitchenv(PitchEnvelope &pitch, int start_frame, int end_frame);
void MakeWave(int start, int end, PitchEnvelope &pitch);


void InterpolatePeaks(int on); void InterpolatePeaks(int on);
void InterpolateAdjacent(void);
void CopyDown(int frame, int direction); void CopyDown(int frame, int direction);
void SelectAll(int yes); void SelectAll(int yes);
int CountSelected(); int CountSelected();
void DeleteSelected(); void DeleteSelected();
void ClipboardCopy();
int ClipboardInsert(int insert_at);
float GetFrameLength(int frame, int plus, int *original_mS); float GetFrameLength(int frame, int plus, int *original_mS);
float GetKeyedLength(); float GetKeyedLength();
void SetFrameLengths(); void SetFrameLengths();
double scaley; double scaley;


}; };


class SpectDisplay: public wxScrolledWindow
{//========================================
public:
SpectDisplay(wxWindow *parent, const wxPoint& pos, const wxSize& size, SpectSeq *spect);
~SpectDisplay();
virtual void OnDraw(wxDC& dc);
void OnMouse(wxMouseEvent& event);
void OnKey(wxKeyEvent& event);
void OnActivate(int active);
void OnMenu(wxCommandEvent& event);

void Save(const wxString &path=_T(""),int selection=0);
void SavePitchenv(PitchEnvelope &pitch);

void OnZoom(int command);

SpectSeq *spectseq;
float zoomx;
float zoomy;
int zoom;
wxString savepath;
void ReadDialogValues();
void WriteDialogValues();
void WriteDialogLength();
void RefreshDialogValues(int type);
int ScrollToFrame(int frame, int centre);
void SelectFrame(int frame);

private:
void RefreshFrame(int frame);
void SetKeyframe(SpectFrame *sf, int yes);
void SetExtent();
int sframe;
int pk_num;


DECLARE_EVENT_TABLE()
};


class ByteGraph: public wxScrolledWindow
{//=====================================
public:
ByteGraph(wxWindow *parent, const wxPoint& pos, const wxSize &size);
virtual void OnDraw(wxDC &dc);
void SetData(int nx, unsigned char *data);
void ShowSpectrum(int yes);
private:
int npoints;
unsigned char *graph;
int show_spectrum;
double spectrum_scale;
void DrawSpectrum(wxDC &dc);
void OnMouse(wxMouseEvent& event);

DECLARE_EVENT_TABLE()
};


class FormantDlg : public wxPanel
{//==============================
public:
FormantDlg(wxWindow *parent);
void ShowFrame(SpectSeq *spectseq, int frame, int pk, int field);
void GetValues(SpectSeq *spectseq, int frame);
void OnCommand(wxCommandEvent& event);
void OnSpin(wxSpinEvent& event);
void HideFields(int synth_type);

wxCheckBox *usepitchenv;

wxSpinCtrl *t_amplitude;
wxSpinCtrl *t_ampframe;
wxSpinCtrl *t_timeframe;
wxTextCtrl *tt_timeframe;
wxSpinCtrl *t_timeseq;
wxStaticText *t_pitch;
wxStaticText *t_orig_frame;
wxStaticText *t_orig_seq;

wxSpinCtrl *s_klatt[N_KLATTP];
wxStaticText *t_klatt[N_KLATTP];

private:
wxStaticText *t_lab[10];
wxStaticText *t_labpk[N_PEAKS];
wxTextCtrl *t_pkfreq[N_PEAKS];
wxTextCtrl *t_pkheight[N_PEAKS];
wxTextCtrl *t_pkwidth[N_PEAKS];
wxTextCtrl *t_klt_bw[N_PEAKS];
wxTextCtrl *t_klt_ap[N_PEAKS];
wxTextCtrl *t_klt_bp[N_PEAKS];
wxRadioButton *t_select_peak[N_PEAKS];

wxButton *t_zoomout;
wxButton *t_zoomin;

DECLARE_EVENT_TABLE()
};



class VoiceDlg : public wxPanel
{//=============================
public:
VoiceDlg(wxWindow *parent);
void ReadParams();
void WriteParams();
void Save();
void Load();
void SetFromSpect(SpectSeq *spect);

voice_t *voice_p;
PitchEnvelope pitchenv;
wxSpinCtrl* vd_pitch1;
wxSpinCtrl* vd_pitch2;
wxTextCtrl* vd_duration;

private:
wxButton *vd_defaults;
wxButton *vd_load;
wxButton *vd_save;

wxStaticText* vd_labpk[N_PEAKS+1];
wxSpinCtrl* vd[N_PEAKS+1][3];
wxCheckBox* vd_usepitch;

wxStaticText* vd_lab[3];
ByteGraph *vd_pitchgraph;
wxComboBox *vd_pitchchoice;

int pitch1;
int pitch2;

void OnCommand(wxCommandEvent& event);
void OnSpin(wxSpinEvent& event);

DECLARE_EVENT_TABLE()
};



extern SpectSeq *clipboard_spect;
extern int pk_select;
extern int samplerate;
extern unsigned char env_fall[];
extern FormantDlg* formantdlg;
extern VoiceDlg* voicedlg;
extern wxNotebook* notebook;
extern ByteGraph* pitchgraph;
extern SpectDisplay *currentcanvas;
extern float polint(float xa[],float ya[],int n,float x);
extern void WavegenInit(int samplerate, int wavemult_fact);
extern void WavegenInitPkData(int); // initialise envelope data
extern "C" void SetPitch(int length, unsigned char *env, int pitch1, int pitch2);
extern void SetSynthHtab(int length_mS, USHORT *ht1, int nh1, float pitch1, USHORT *ht2, int nh2, float pitch2);
extern void MakeWaveFile(int synthesis_method);
extern void MakeWaveBuf(int length, UCHAR *buf);

extern int OpenWaveFile(const char *path, int samplerate);
extern int OpenWaveFile2(const char *path);
extern void CloseWaveFile(int rate);
extern void PlayWavFile(const char *fname);

extern void SetSpinCtrl(wxSpinCtrl *t, int value);
extern int GetNumeric(wxTextCtrl *t);
extern void SetNumeric(wxTextCtrl *t, int value);

extern int use_spin_controls;

+ 0
- 1030
src/spectdisplay.cpp
File diff suppressed because it is too large
View File


+ 0
- 438
src/spectseq.cpp View File

#include "synthesize.h" #include "synthesize.h"
#include "voice.h" #include "voice.h"
#include "spect.h" #include "spect.h"
#include "main.h"
#include "wx/numdlg.h" #include "wx/numdlg.h"
#include "wx/txtstrm.h" #include "wx/txtstrm.h"
#include "wx/datstrm.h" #include "wx/datstrm.h"






void MakeWaveFile(int synthesis_method)
{//====================================
int result=1;
int resume=0;
unsigned char wav_outbuf[1024];

while(result != 0)
{
out_ptr = out_start = wav_outbuf;
out_end = &wav_outbuf[sizeof(wav_outbuf)];

#ifdef INCLUDE_KLATT
if(synthesis_method == 1)
result = Wavegen_Klatt(resume);
else
#endif
result = Wavegen();

if(f_wave != NULL)
fwrite(wav_outbuf, 1, out_ptr - wav_outbuf, f_wave);
resume=1;
}
} // end of MakeWaveFile




SpectSeq::SpectSeq(int n) SpectSeq::SpectSeq(int n)
{//====================== {//======================
numframes = n; numframes = n;
} // end of SpectSeq::DeleteSelected } // end of SpectSeq::DeleteSelected




void SpectSeq::ClipboardCopy()
{//===========================
int ix;
int nframes;
int count=0;

nframes = CountSelected();
if(nframes == 0) return;

if(clipboard_spect != NULL)
delete clipboard_spect;

if((clipboard_spect = new SpectSeq(nframes))==NULL) return;

for(ix=0; ix<numframes; ix++)
{
if(frames[ix]->selected)
{
if((clipboard_spect->frames[count] = new SpectFrame(frames[ix])) == NULL)
break;

count++;
}
}
} // end of SpectSeq::ClipboardCopy



int SpectSeq::ClipboardInsert(int insert_at)
{//=========================================
int ix;
int j;
int total;
int result=insert_at;
float thistime=0;
float timeinc=0;
float timeoffset=0;
SpectFrame **frames2;

if(clipboard_spect == NULL) return(result);
if(clipboard_spect->numframes == 0) return(result);
timeoffset = clipboard_spect->frames[0]->time;

if(CountSelected() == 0)
insert_at = -1;

total = numframes + clipboard_spect->numframes;
frames2 = new SpectFrame* [total];
if(frames2 == NULL) return(result);

total = 0;
for(ix=0; ix<numframes; ix++)
{
thistime = frames[ix]->time;
if(ix == insert_at)
{
result = total;
for(j=0; j<clipboard_spect->numframes; j++)
{
frames2[total] = new SpectFrame(clipboard_spect->frames[j]);
frames2[total]->time += (thistime - timeoffset);
timeinc = frames2[total]->time - thistime + (frames2[total]->length/1000);
total++;
}
}
frames2[total] = new SpectFrame(frames[ix]);
frames2[total++]->time += timeinc;
}
if(insert_at == -1)
{
// insert at the end
result = total;
for(j=0; j<clipboard_spect->numframes; j++)
{
frames2[total] = new SpectFrame(clipboard_spect->frames[j]);
frames2[total++]->time += (thistime - timeoffset);
}
}
delete frames;
frames = frames2;
numframes = total;
return(result);
} // end of SpectSeq::ClipboardInsert


void SpectSeq::SetFrameLengths() void SpectSeq::SetFrameLengths()
{//============================= {//=============================
int frame; int frame;
} // end of ConstructVowel } // end of ConstructVowel






void SpectSeq::Draw(wxDC& dc, int start_y, int end_y)
{//==================================================
int fm;
int f, f1, f2;
int x;

if(end_y < start_y) return;

if((start_y -= 4) < 0) start_y = 0;

f1 = start_y / FRAME_HEIGHT;
f2 = end_y / FRAME_HEIGHT;

scaley = double(FRAME_HEIGHT) / max_y;
scalex = double(frame_width) / max_x;
// scalex = 0.6;

for(fm=f1; fm <= f2 && fm < numframes; fm++)
{
if(frames[fm]->keyframe)
{
dc.SetBrush(CREAM_BRUSH);
dc.SetPen(BORDER_PEN);
}
else
{
dc.SetBrush(*wxWHITE_BRUSH);
dc.SetPen(*wxTRANSPARENT_PEN);
}

if(frames[fm]->selected)
dc.SetPen(*wxRED_PEN);

dc.DrawRectangle(0,FRAME_HEIGHT*fm+2,frame_width,
FRAME_HEIGHT-2);
}

if(grid==1)
{
for(f=500; f<=MAX_DISPLAY_FREQ; f+=500)
{
x = int(f * scalex);
if(x > max_x) break;
if(f==3000 || f==6000 || f==9000)
dc.SetPen(*wxLIGHT_GREY_PEN);
else
dc.SetPen(VLIGHT_GREY_PEN);
dc.DrawLine(x,start_y,x,numframes*FRAME_HEIGHT);
}
}

for(fm=f1; fm <= f2 && fm < numframes; fm++)
{
frames[fm]->Draw(dc,FRAME_HEIGHT*(fm+1),frame_width,
scalex,scaley);
}

} // end of SpectSeq::Draw


void SpectSeq::InterpolatePeak(int peak) void SpectSeq::InterpolatePeak(int peak)
{//===================================== {//=====================================
int f, f1=0, f2; int f, f1=0, f2;
} // end of SpectSeq::InterpolatePeak } // end of SpectSeq::InterpolatePeak




void SpectSeq::InterpolateAdjacent(void)
{//=====================================
int ix;
int f1 = -1;
int select = -1;
int f2 = -1;
float ratio;
peak_t *p = NULL;
peak_t *p1 = NULL;
peak_t *p2 = NULL;

for(ix=0; ix<numframes; ix++)
{
if(frames[ix]->selected)
select = ix;
else
if(frames[ix]->keyframe)
{
if(select >= 0)
{
f2 = ix;
break;
}
else
f1 = ix;
}
}

if(f1 < 0)
{
wxLogError(_T("No previous keyframe"));
return;
}
if(select < 0)
{
wxLogError(_T("No selected frame"));
return;
}
if(f2 < 0)
{
wxLogError(_T("No subsequent keyframe"));
return;
}
// get ratio
ix = wxGetNumberFromUser(_T("Interpolate between adjacent frames"),_T("percent"),_T(""),50);
ratio = (float)ix/100.0;

for(ix=0; ix<N_PEAKS; ix++)
{
p = &frames[select]->peaks[ix];
p1 = &frames[f1]->peaks[ix];
p2 = &frames[f2]->peaks[ix];

p->pkfreq = p1->pkfreq + int((p2->pkfreq - p1->pkfreq)*ratio);
p->pkheight=p1->pkheight+int((p2->pkheight-p1->pkheight)*ratio);
p->pkwidth = p1->pkwidth + int((p2->pkwidth - p1->pkwidth)*ratio);
p->pkright =p1->pkright + int((p2->pkright - p1->pkright)*ratio);
}
frames[select]->keyframe = 1;
formantdlg->ShowFrame(this,select,1,0xff);
}


void SpectSeq::InterpolatePeaks(int control) void SpectSeq::InterpolatePeaks(int control)
{//========================================= {//=========================================
// 0=turn off 1=turn on // 0=turn off 1=turn on
}; };






void SpectSeq::MakeWave(int start, int end, PitchEnvelope &pitch)
{//==============================================================
int ix;
int length;
int len_samples;
int total_length;
float sum_length=0;
float prev_length=0;
int first;
char *fname_speech;
SpectFrame *sp1 = NULL;
SpectFrame *sp2;
double lfactor;
peak_t peaks0[N_PEAKS];
peak_t peaks1[N_PEAKS];
peak_t peaks2[N_PEAKS];
int synthesizer_type = 0;

if(voice->klattv[0])
{
synthesizer_type = 1;
#ifdef INCLUDE_KLATT
KlattReset(2);
#endif
}

SpeakNextClause(NULL,NULL,2); // stop speaking file

if(numframes==0) return;
SetFrameLengths();

// find overall length of sequence
for(ix=0; ix<numframes; ix++)
{
if(frames[ix]->keyframe)
{
sum_length += prev_length;
prev_length = frames[ix]->length;
sp2 = frames[ix];
if(sp1 == NULL)
sp1 = sp2;
}
}
if(sp1 == NULL)
{
wxLogError(_T("(No frames have peaks set"));
return;
}

total_length = int(sum_length);

if((start==end) || (total_length == 0))
{
sp1->MakeWaveF(0,voicedlg->pitchenv,amplitude,duration);
return;
}


if((duration > 0) && (duration < 40000))
lfactor = double(duration)/double(total_length);
else
{
duration = total_length;
lfactor = 1;
}

len_samples = int(((total_length * lfactor + 50) * samplerate) / 1000);
SetPitch(len_samples,pitch.env,9,44);

fname_speech = WavFileName();
OpenWaveFile2(fname_speech);

first = 0;
if(start > 0)
first=1; // a selection, use fade-in

sp2 = NULL;
for(ix=start; ix<=end; ix++)
{
if(frames[ix]->keyframe)
{
sp1 = sp2;
sp2 = frames[ix];
if(sp1 != NULL)
{
ApplyAmp_adjust(sp1,peaks1);
ApplyAmp_adjust(sp2,peaks2);

if(first)
{
PeaksZero(peaks1,peaks0); // fade in

SetSynth_mS(20,sp1,sp1,peaks0,peaks1,0);
MakeWaveFile(synthesizer_type);
first=0;
}

length = int(sp1->length * lfactor);
SetSynth_mS(length,sp1,sp2,peaks1,peaks2,0);
MakeWaveFile(synthesizer_type);
}
}
}

PeaksZero(peaks2,peaks0); // fade out

SetSynth_mS(30,sp2,sp2,peaks2,peaks0,2);
MakeWaveFile(synthesizer_type);

CloseWaveFile2();
PlayWavFile(fname_speech);

} // end of SpectSeq::MakeWave


void SpectFrame::MakeHtab(int numh, int *htab, int pitch) void SpectFrame::MakeHtab(int numh, int *htab, int pitch)
{//====================================================== {//======================================================
// interpolate the spectrum to give a harmonic table for // interpolate the spectrum to give a harmonic table for
// the given pitch (Hz<<12) // the given pitch (Hz<<12)


} // end of SpectFrame::MakeHtab } // end of SpectFrame::MakeHtab


void SpectFrame::MakeWaveF(int control, PitchEnvelope &pitche, int amplitude, int duration)
{//======================================================================================
// amplitude: percentage adjustment

int ix;
int length; // mS
int len_samples;
int y;
peak_t peaks0[N_PEAKS];
peak_t peaks1[N_PEAKS];
char *fname_speech;
int synthesizer_type = 0;

if(voice->klattv[0])
{
synthesizer_type = 1;
#ifdef INCLUDE_KLATT
KlattReset(2);
#endif
}

SpeakNextClause(NULL,NULL,2); // stop speaking file

length = duration;
if(length==0)
length = 200; // default length, mS

len_samples = (length * samplerate) / 1000;
SetPitch(len_samples + 50,pitche.env,9,44);

fname_speech = WavFileName();
if(OpenWaveFile2(fname_speech) != 0)
return;


if(control==0)
{
memcpy(peaks1,peaks,sizeof(peaks1));

for(ix=0; ix<N_PEAKS; ix++)
{
y = peaks1[ix].pkheight * amp_adjust * amplitude;
peaks1[ix].pkheight = y/10000;
}
PeaksZero(peaks1,peaks0);
SetSynth_mS(20,this,this,peaks0,peaks1,0);
MakeWaveFile(synthesizer_type);
SetSynth_mS(length,this,this,peaks1,peaks1,0);
MakeWaveFile(synthesizer_type);
SetSynth_mS(30,this,this,peaks1,peaks0,2);
MakeWaveFile(synthesizer_type);
}
else
{
#ifdef SPECT_EDITOR
int maxh;
USHORT htab0[600];

maxh = nx;
if(maxh >= 600)
maxh = 600-1;
for(ix=0; ix<=maxh; ix++)
htab0[ix] = 0;
// SetSynthHtab(20,htab0,maxh,dx,spect,maxh,dx);
SetSynthHtab(20,spect,maxh,dx,spect,maxh,dx);
MakeWaveFile(0);
SetSynthHtab(length,spect,maxh,dx,spect,maxh,dx);
MakeWaveFile(0);
SetSynthHtab(30,spect,maxh,dx,htab0,maxh,dx);
MakeWaveFile(0);
#endif
}

CloseWaveFile2();
PlayWavFile(fname_speech);

} // end of SpectFrame::MakeWaveFrame



+ 0
- 478
src/transldlg.cpp View File

/***************************************************************************
* Copyright (C) 2005 to 2013 by Jonathan Duddington *
* email: [email protected] *
* Copyright (C) 2013 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 "wx/wx.h"


#include "speak_lib.h"
#include "speech.h"
#include "phoneme.h"
#include "main.h"
#include "synthesize.h"
#include "voice.h"
#include "translate.h"
#include "prosodydisplay.h"

#ifdef PLATFORM_POSIX
#include <unistd.h>
#endif


#include "wx/font.h"
#include "wx/textctrl.h"
#include "wx/button.h"
#include "wx/checkbox.h"
#include "wx/filename.h"
#include "wx/sound.h"

#define T_SOURCE 501
#define T_PHONETIC 502
#define T_TRANSLATE 503
#define T_PROCESS 504
#define T_RULES 505
#define T_TRANSLATE_IPA 506

TranslDlg *transldlg = NULL;
extern char *speech_to_phonemes(char *data, char *phout);
extern ProsodyDisplay *prosodycanvas;
extern void Write4Bytes(FILE *f, int value);

BEGIN_EVENT_TABLE(TranslDlg, wxPanel)
EVT_BUTTON(T_TRANSLATE,TranslDlg::OnCommand)
EVT_BUTTON(T_PROCESS,TranslDlg::OnCommand)
EVT_BUTTON(T_RULES,TranslDlg::OnCommand)
EVT_BUTTON(T_TRANSLATE_IPA,TranslDlg::OnCommand)
END_EVENT_TABLE()


FILE *f_wave = NULL;
wxFont font_phonetic;
wxTextAttr style_phonetic;
wxFont font_phonetic_large;
wxTextAttr style_phonetic_large;


void PlayWavFile(const char *fname)
{//================================
char command[120];

#ifdef PLATFORM_WINDOWS
wxSound(wxString(fname,wxConvLocal)).Play(wxSOUND_SYNC);
#else
// wxSound(wxString(fname,wxConvLocal)).Play(wxSOUND_SYNC); // This gives a click at the start of each play
sprintf(command,"aplay %s",fname);
if(system(command) == -1)
{
sprintf(command,"play %s",fname);
if(system(command) == -1)
{
wxLogError(_T("Failed to run system command:\n\n"+wxString(command,wxConvLocal)));
}
}
#endif
}


char *WavFileName(void)
{//====================
static char f_speech[120];
if(!wxDirExists(wxPathOnly(path_speech)))
{
path_speech = wxFileSelector(_T("Speech output file"),
path_phsource,_T("speech.wav"),_T("*"),_T("*"),wxSAVE);
}
strcpy(f_speech,path_speech.mb_str(wxConvLocal));
return(f_speech);
}



int OpenWaveFile2(const char *path)
/*********************************/
{
// Set the length of 0x7fffffff for --stdout
// This will be changed to the correct length for -w (write to file)
static unsigned char wave_hdr[44] = {
'R','I','F','F',0,0,0,0,'W','A','V','E','f','m','t',' ',
0x10,0,0,0,1,0,1,0, 9,0x3d,0,0,0x12,0x7a,0,0,
2,0,0x10,0,'d','a','t','a', 0xff,0xff,0xff,0x7f};

if(path == NULL)
return(2);

if(strcmp(path,"stdout")==0)
f_wave = stdout;
else
f_wave = fopen(path,"wb");

if(f_wave != NULL)
{
fwrite(wave_hdr,1,24,f_wave);
Write4Bytes(f_wave,samplerate);
Write4Bytes(f_wave,samplerate * 2);
fwrite(&wave_hdr[32],1,12,f_wave);
return(0);
}
wxLogStatus(_T("Can't write to WAV file: '"+wxString(path,wxConvLocal))+_T("'"));
return(1);
} // end of OpenWaveFile




void CloseWaveFile2()
/******************/
{
unsigned int pos;

if((f_wave == NULL) || (f_wave == stdout))
return;

fflush(f_wave);
pos = ftell(f_wave);

fseek(f_wave,4,SEEK_SET);
Write4Bytes(f_wave,pos - 8);

fseek(f_wave,40,SEEK_SET);
Write4Bytes(f_wave,pos - 44);


fclose(f_wave);
f_wave = NULL;

} // end of CloseWaveFile




int WavegenFile2(void)
{//==================
int finished;
unsigned char wav_outbuf[1024];

out_ptr = out_start = wav_outbuf;
out_end = wav_outbuf + sizeof(wav_outbuf);

finished = WavegenFill(0);

if(f_wave != NULL)
{
fwrite(wav_outbuf, 1, out_ptr-wav_outbuf, f_wave);
}
return(finished);
} // end of WavegenFile


void MakeWave2(PHONEME_LIST *p, int n_phonemes)
{//============================================
int result;
char *fname_speech;
int n_ph;

#ifdef KLATT_TEST
KlattInit();
#endif
n_ph = n_phonemes;
fname_speech = WavFileName();
OpenWaveFile2(fname_speech);

Generate(p,&n_ph,0);

for(;;)
{
result = WavegenFile2();
if(result != 0)
break;
Generate(p,&n_ph,1);
}

CloseWaveFile2();
PlayWavFile(fname_speech);

} // end of MakeWave2




TranslDlg::TranslDlg(wxWindow *parent) : wxPanel(parent)
{//=====================================================

int height;
int width;
int x,y;
int font_size;
int height_ph = 350;


wxTextAttr attr;
wxFont font = wxFont(12,wxFONTFAMILY_ROMAN,wxFONTSTYLE_NORMAL,wxFONTWEIGHT_LIGHT,false,_T(""),wxFONTENCODING_SYSTEM);

attr.SetFont(font);

wxClientDisplayRect(&x,&y,&width, &height);
#ifdef PLATFORM_WINDOWS
if(height <= 768)
height_ph = height - 416;
#else
if(height <= 800)
height_ph = 280;
#endif


t_source = new wxTextCtrl(this,T_SOURCE,_T(""),wxPoint(0,4),
wxSize(298,250),wxTE_MULTILINE,wxDefaultValidator,_T("Text input window"));
t_source->SetDefaultStyle(attr);


t_phonetic = new wxTextCtrl(this,T_PHONETIC,_T(""),wxPoint(0,262),
wxSize(298,height_ph),wxTE_MULTILINE | wxTE_READONLY, wxDefaultValidator,_T("Phoneme translation window"));

style_phonetic = t_phonetic->GetDefaultStyle();
font_phonetic = style_phonetic.GetFont();
font_size = font_phonetic.GetPointSize();
font_phonetic_large = font_phonetic;
style_phonetic_large = style_phonetic;
//font_phonetic_large.SetFamily(wxFONTFAMILY_SWISS);
font_phonetic_large.SetPointSize(font_size+1);
style_phonetic_large.SetFont(font_phonetic_large);

y = height_ph + 270;
t_translate = new wxButton(this,T_TRANSLATE,_T("Translate"),wxPoint(4,y));
t_translate = new wxButton(this,T_RULES,_T("Show Rules"),wxPoint(4,y+32));
t_translate = new wxButton(this,T_TRANSLATE_IPA,_T("Show IPA"),wxPoint(100,y+32));
t_process = new wxButton(this,T_PROCESS,_T("Speak"),wxPoint(100,y));

t_source->SetFocus();
} // end of TransDlg::TransDlg



void TranslDlg::SpeakFile(void)
{//============================
wxString file;
wxFileName fname;
FILE *f_text;
char buf[200];

fname = wxFileName(path_speaktext);

file = wxFileSelector(_T("Text file to speak"),fname.GetPath(),fname.GetName(),_T(""),_T("*"),wxOPEN);
if(file == wxEmptyString) return;

strcpy(buf,file.mb_str(wxConvLocal));
f_text = fopen(buf,"r");
if(f_text == NULL)
{
wxLogError(_T("Failed to read: ")+file);
return;
}

path_speaktext = file;

InitText(0);
SpeakNextClause(f_text,NULL,0);
return;
} // end of SpeakFile



void TranslDlg::ReadVoice(int variant)
{//===================================
wxString path;
wxString filename;
char *p;
char vname[40];
char fname[sizeof(path_home)+30];

if(variant)
{
// remove variant from the previous voice name
if((p = strchr(voice_name2,'+')) != NULL)
*p = 0;

sprintf(fname,"%s/voices/!v",path_home);
path = wxFileSelector(_T("Load voice variant"),wxString(fname,wxConvLocal),_T(""),_T(""),_T("*"),wxOPEN);
if(path.IsEmpty())
{
strcpy(fname,voice_name2);
}
else
{
filename = path.Mid(strlen(fname)+1);
strcpy(vname,filename.mb_str(wxConvLocal));
sprintf(fname,"%s+%s",voice_name2,vname);
}
}
else
{
sprintf(fname,"%s/voices",path_home);
path = wxFileSelector(_T("Load voice"),wxString(fname,wxConvLocal),_T(""),_T(""),_T("*"),wxOPEN);
if(path.IsEmpty())
return;

filename = path.Mid(strlen(fname)+1);
strcpy(fname,filename.mb_str(wxConvLocal));
}

if(SetVoiceByName(fname) != EE_OK)
{
wxLogError(_T("Failed to load voice data"));
}
else
{
strcpy(voice_name2,fname);
}
WavegenSetVoice(voice);
}


void TranslDlg::OnCommand(wxCommandEvent& event)
{//=============================================
#define N_PH_LIST N_PHONEME_LIST

void *vp;
int translate_text = 0;
char buf[1000];
char phon_out[N_PH_LIST*2];
const char *phon_out2;
int clause_tone;
int clause_count;
FILE *f;
int fd_temp;
char fname_temp[100];
static int n_ph_list;
static PHONEME_LIST ph_list[N_PH_LIST+1];

if(translator==NULL)
{
wxLogError(_T("Voice not set"));
return;
}

option_phonemes = 0;

switch(event.GetId())
{
case T_RULES:
case MENU_SPEAK_RULES:
#ifdef PLATFORM_POSIX
strcpy(fname_temp,"/tmp/espeakXXXXXX");
if((fd_temp = mkstemp(fname_temp)) >= 0)
{
close(fd_temp);

if((f = fopen(fname_temp,"w+")) != NULL)
{
f_trans = f; // write translation rule trace to a temp file
}
}
#else
strcpy(fname_temp,tmpnam(NULL));
if((f = fopen(fname_temp,"w+")) != NULL)
{
f_trans = f; // write translation rule trace to a temp file
}
#endif
t_phonetic->SetDefaultStyle(style_phonetic);
translate_text = espeakPHONEMES_TRACE;
break;

case T_TRANSLATE:
case MENU_SPEAK_TRANSLATE:
t_phonetic->SetDefaultStyle(style_phonetic);
translate_text = espeakPHONEMES_SHOW;
break;

case T_TRANSLATE_IPA:
case MENU_SPEAK_IPA:
t_phonetic->SetDefaultStyle(style_phonetic_large);

translate_text = espeakPHONEMES_IPA;
break;

case T_PROCESS:
case MENU_SPEAK_TEXT:
myframe->OnProsody(event);
prosodycanvas->LayoutData(ph_list,n_ph_list);
myframe->Refresh();
option_phoneme_events = espeakINITIALIZE_PHONEME_EVENTS;
option_log_frames = 1;
MakeWave2(ph_list,n_ph_list);
option_log_frames = 0;
break;
}

if(translate_text)
{
option_phonemes = translate_text;

option_multibyte = espeakCHARS_AUTO;
SpeakNextClause(NULL,NULL,2); // stop speaking file

strncpy0(buf,t_source->GetValue().mb_str(wxConvUTF8),sizeof(buf));
phon_out[0] = 0;
n_ph_list = 0;
clause_count = 0;

vp = buf;
InitText(0);
while((vp != NULL) && (n_ph_list < N_PH_LIST))
{
vp = TranslateClause(translator,NULL,vp,&clause_tone,NULL);
CalcPitches(translator,clause_tone);
CalcLengths(translator);

phon_out2 = GetTranslatedPhonemeString(option_phonemes);
if(clause_count++ > 0)
strcat(phon_out," ||");
strcat(phon_out, phon_out2);
t_phonetic->SetValue(wxString(phon_out2, wxConvUTF8));

if((n_ph_list + n_phoneme_list) >= N_PH_LIST)
{
n_phoneme_list = N_PH_LIST - n_ph_list;
}

memcpy(&ph_list[n_ph_list],phoneme_list,sizeof(PHONEME_LIST)*n_phoneme_list);
n_ph_list += n_phoneme_list;
}

ph_list[N_PH_LIST].ph = NULL; // to recognize overrun off list (in Generate() )

t_phonetic->Clear();
if(option_phonemes & espeakPHONEMES_TRACE)
{
option_phonemes=0;
rewind(f_trans);
while(fgets(buf,sizeof(buf),f_trans) != NULL)
{
t_phonetic->AppendText(wxString(buf,wxConvUTF8));
}
t_phonetic->AppendText(_T("---\n"));
if(f_trans != NULL)
fclose(f_trans);
remove(fname_temp);
}
t_phonetic->AppendText(wxString(phon_out,wxConvUTF8));
}
} // end of TranslDlg::OnCommand

+ 0
- 299
src/voicedlg.cpp View File

/***************************************************************************
* Copyright (C) 2005 to 2007 by Jonathan Duddington *
* email: [email protected] *
* *
* 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, write see: *
* <http://www.gnu.org/licenses/>. *
***************************************************************************/


#include "wx/wx.h"


#include "speak_lib.h"
#include "main.h"
#include "speech.h"
#include "phoneme.h"
#include "synthesize.h"
#include "voice.h"
#include "spect.h"
#include "options.h"

#include "wx/dialog.h"
#include "wx/textctrl.h"
#include "wx/checkbox.h"
#include "wx/txtstrm.h"
#include "wx/wfstream.h"
#include "wx/filename.h"

VoiceDlg *voicedlg = NULL;

voice_t voice_data;
USHORT voice_pcnt[N_PEAKS+1][3];

static void VoiceSetup()
{//=====================
int pk;
voice_t *v = &voice_data;

for(pk=0; pk<N_PEAKS; pk++)
{
v->freq[pk] = int(voice_pcnt[pk][0] * 2.56001 * voice_pcnt[N_PEAKS][0] / 100.0);
v->height[pk] = int(voice_pcnt[pk][1] * 2.56001 * voice_pcnt[N_PEAKS][1] / 100.0);
v->width[pk] = int(voice_pcnt[pk][2] * 2.56001 * voice_pcnt[N_PEAKS][2] / 100.0);
}
}


static void VoiceInit()
{//====================
int pk, j;
voice_t *v;

v = &voice_data;

v->pitch_base = 71 << 12;
v->pitch_range = 0x1000; // default = 0x1000
for(pk=0; pk<N_PEAKS+1; pk++)
{
for(j=0; j<3; j++)
voice_pcnt[pk][j] = 100;
}
VoiceSetup();

voice = v;
} // end of voice_init


#define VD_DEFAULTS 401
#define VD_LOAD 402
#define VD_SAVE 403
#define VD_PITCHCHOICE 404
#define VD_PITCH1 405
#define VD_PITCH2 406
#define VD_USEPITCH 407

wxString pitchchoices[3] = {_T("From spectrum"),_T("Standard"),_T("Monotone")};

BEGIN_EVENT_TABLE(VoiceDlg, wxPanel)
EVT_BUTTON(VD_DEFAULTS,VoiceDlg::OnCommand)
EVT_BUTTON(VD_LOAD,VoiceDlg::OnCommand)
EVT_BUTTON(VD_SAVE,VoiceDlg::OnCommand)
EVT_SPINCTRL(VD_PITCH1,VoiceDlg::OnSpin)
EVT_SPINCTRL(VD_PITCH2,VoiceDlg::OnSpin)
EVT_CHECKBOX(VD_USEPITCH,VoiceDlg::OnCommand)
EVT_COMBOBOX(VD_PITCHCHOICE,VoiceDlg::OnCommand)
END_EVENT_TABLE()

VoiceDlg::VoiceDlg(wxWindow *parent) : wxPanel(parent)
{//=========================================================
int ix, j;
int y;
wxString string;
voice_t *v;
wxString captions[3] = {_T("Freq"),_T("Height"),_T("Width")};

voice_p = v = &voice_data;
VoiceInit();

pitch1 = 80;
pitch2 = 120;
for(j=0; j<3; j++)
new wxStaticText(this,-1,captions[j],wxPoint(34+j*56,6));

y = 26;
for(ix=0; ix<N_PEAKS+1; ix++)
{
if(ix==N_PEAKS)
{
string = _T("All");
y += 8;
}
else
string.Printf(_T("%2d"),ix);
vd_labpk[ix] = new wxStaticText(this,-1,string,wxPoint(8,y+2));

for(j=0; j<3; j++)
{
string.Printf(_T("%d"),voice_pcnt[ix][j]);
vd[ix][j] = new wxSpinCtrl(this,-1,string,
wxPoint(32+j*56,y),wxSize(52,22),wxSP_ARROW_KEYS,0,300);
}
y += 26;
}
for(ix=6; ix<N_PEAKS; ix++)
vd[ix][2]->Hide();

vd_defaults = new wxButton(this,VD_DEFAULTS,_T("Defaults"),wxPoint(32,293));

y = 324;
vd_pitch1 = new wxSpinCtrl(this,VD_PITCH1,_T("80"),
wxPoint(32,y),wxSize(52,24),wxTE_CENTRE,60,500);
vd_pitch2 = new wxSpinCtrl(this,VD_PITCH2,_T("120"),
wxPoint(88,y),wxSize(52,24),wxTE_CENTRE,60,500);
vd_lab[1] = new wxStaticText(this,-1,_T("Hz"),wxPoint(142,y+2));
vd_usepitch = new wxCheckBox(this,VD_USEPITCH,_T("Pitch from spectrum"),
wxPoint(4,y+24));
// vd_load = new wxButton(this,VD_LOAD,_T("Load"),wxPoint(16,y+56));
// vd_save = new wxButton(this,VD_SAVE,_T("Save"),wxPoint(106,y+56));

y = 422;
vd_duration = new wxTextCtrl(this,-1,_T(""),
wxPoint(4,y),wxSize(52,24),wxTE_CENTRE);
vd_lab[2] = new wxStaticText(this,-1,_T("Duration"),wxPoint(60,y+2));

y = 422;
vd_pitchchoice = new wxComboBox(this,VD_PITCHCHOICE,_T("Standard"),
wxPoint(4,y+30),wxSize(192,24),3,pitchchoices);
vd_pitchgraph = new ByteGraph(this,wxPoint(0,y+60),wxSize(200,100));
vd_pitchgraph->SetData(128,env_fall);
vd_pitchgraph->Show();

} // end of VoiceDlg::VoiceDlg


void VoiceDlg::OnCommand(wxCommandEvent& event)
{//============================================

// JSD EVT_COMBOBOX causes GDB lockup if a breakpoint is set

int id;
int ix, j;

switch(id = event.GetId())
{
case VD_DEFAULTS:
for(ix=0; ix<N_PEAKS+1; ix++)
{
for(j=0; j<3; j++)
{
voice_pcnt[ix][j] = 100;
vd[ix][j]->SetValue(_T("100"));
}
}
VoiceSetup();
break;

case VD_LOAD:
// Load();
break;

case VD_SAVE:
// Save();
break;

case VD_USEPITCH:
case VD_PITCHCHOICE:
if(currentcanvas != NULL)
SetFromSpect(currentcanvas->spectseq);
break;
}

if(currentcanvas != NULL) currentcanvas->SetFocus();
} // end of VoiceDlg::OnCommand



void VoiceDlg::ReadParams()
{//========================
int ix, j;

pitchenv.pitch1 = vd_pitch1->GetValue();
pitchenv.pitch2 = vd_pitch2->GetValue();

voice_data.pitch_base = (pitchenv.pitch1 - 9) << 12;
voice_data.pitch_range = (pitchenv.pitch2 - pitchenv.pitch1) * 108;
for(ix=0; ix<N_PEAKS+1; ix++)
{
for(j=0; j<3; j++)
{
voice_pcnt[ix][j] = vd[ix][j]->GetValue();
}
}
VoiceSetup();

} // end of VoiceDlg::ReadParams


void VoiceDlg::WriteParams()
{//========================
int ix;
voice_t *v = voice;
int val1, val2;

val1 = (v->pitch_base >> 12) + 9;
val2 = v->pitch_range/108 + val1;
vd_pitch1->SetValue(val1);
vd_pitch2->SetValue(val2);

for(ix=0; ix<N_PEAKS; ix++)
{
vd[ix][0]->SetValue(int(float(v->freq[ix]) / 2.56001 + 0.5));
vd[ix][1]->SetValue(int(float(v->height[ix]) / 2.56001 + 0.5));
vd[ix][2]->SetValue(int(float(v->width[ix]) / 2.56001 + 0.5));
}
vd[ix][0]->SetValue(100);
vd[ix][1]->SetValue(100);
vd[ix][2]->SetValue(100);

} // end of VoiceDlg::WriteParams



void VoiceDlg::OnSpin(wxSpinEvent& event)
{//======================================

ReadParams();
}


void VoiceDlg::SetFromSpect(SpectSeq* spect)
{//=========================================
if(spect==NULL) return;
if(vd_pitchchoice->GetValue() == _T("From spectrum"))
{
pitchenv = spect->pitchenv;
}
else
if(vd_pitchchoice->GetValue() == _T("Monotone"))
{
memset(pitchenv.env,127,128);
}
else
if(vd_pitchchoice->GetValue() == _T("Standard"))
{
memcpy(pitchenv.env,env_fall,128);
}
vd_pitchgraph->SetData(128,pitchenv.env);
vd_pitchgraph->Show();

if(vd_usepitch->GetValue())
{
SetSpinCtrl(vd_pitch1,spect->pitch1);
SetSpinCtrl(vd_pitch2,spect->pitch2);
}
else
{
SetSpinCtrl(vd_pitch1,pitch1);
SetSpinCtrl(vd_pitch2,pitch2);
}
} // end of VoiceDlg::SetFromSpect


+ 0
- 748
src/vowelchart.cpp View File

/***************************************************************************
* Copyright (C) 2005 to 2013 by Jonathan Duddington *
* email: [email protected] *
* Copyright (C) 2013-2015 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, write see: *
* <http://www.gnu.org/licenses/>. *
***************************************************************************/


#include <math.h>
#include "wx/wx.h"
#include <wx/dcmemory.h>
#include <wx/dc.h>
#include <wx/bitmap.h>
#include <wx/dirdlg.h>
#include "wx/filename.h"
#include "wx/wfstream.h"

#include "speak_lib.h"
#include "main.h"
#include "speech.h"
#include "phoneme.h"
#include "synthesize.h"
#include "voice.h"
#include "spect.h"
#include "translate.h"
#include "options.h"

/* Read a file of vowel symbols and f1,f2 formants, and produce a vowel diagram
*/
extern wxString path_phsource;

extern char *phondata_ptr;
extern USHORT *phoneme_index;
extern int n_phoneme_tables;


// size of the vowelchart png
#define WIDTH 1580
#define HEIGHT 800


#define ROUND(x) ((int) ((x) + 0.5))

static int HslValue (double n1, double n2, double hue)
{//===================================================
double value;
if (hue > 255)
hue -= 255;
else if (hue < 0)
hue += 255;
if (hue < 42.5)
value = n1 + (n2 - n1) * (hue / 42.5);
else if (hue < 127.5)
value = n2;
else if (hue < 170)
value = n1 + (n2 - n1) * ((170 - hue) / 42.5);
else
value = n1;
return ROUND (value * 255.0);
}

/**
* @hue: Hue channel, returns Red channel
* @saturation: Saturation channel, returns Green channel
* @lightness: Lightness channel, returns Blue channel
*
* The arguments are pointers to int, with the values pointed to in the
* following ranges: H [0, 360], L [0, 255], S [0, 255].
*
* The function changes the arguments to point to the RGB value
* corresponding, with the returned values all in the range [0, 255].
**/
void HslToRgb (int *hue, int *saturation, int *lightness)
{//======================================================
double h, s, l;

h = (*hue * 256)/360;
s = *saturation;
l = *lightness;

if (s == 0)
{
/* achromatic case */
*hue = (int)l;
*lightness = (int)l;
*saturation = (int)l;
}
else
{
double m1, m2;

if (l < 128)
m2 = (l * (255 + s)) / 65025.0;
else
m2 = (l + s - (l * s) / 255.0) / 255.0;

m1 = (l / 127.5) - m2;

/* chromatic case */
*hue = HslValue (m1, m2, h + 85);
*saturation = HslValue (m1, m2, h);
*lightness = HslValue (m1, m2, h - 85);
}
}


static int vowel_posn[N_PHONEME_TAB];
static int vowel_posn_ix;


static double log2a(double x)
{//========================
// log2(x) = log(x) / log(2)
return(log(x) / 0.693147);
}

static int VowelX(int f2)
{//======================
return(WIDTH - int((log2a(f2) - 9.40)*WIDTH/1.9));
// return(WIDTH - int((log2a(f2) - 9.49)*WIDTH/1.8));
}

static int VowelY(int f1)
{//======================
return(int((log2a(f1) - 7.85)*HEIGHT/2.15));
}

static int VowelZ(int f3)
{//======================
int z;
// range 2000-3000Hz, log2= 10.96 to 11.55
z = int((log2a(f3) - 11.05)*256/0.50);
if(z < 0) z = 0;
if(z > 255) z = 255;
return(z);
}


static void DrawVowel(wxDC *dc, wxString name, int f1, int f2, int f3, int g1, int g2)
{//==================================================================================
int ix;
int posn;
int collisions;
int x,y,z,x2,y2;
int r,g,b;
wxBrush brush;


y = VowelY(f1);
x = VowelX(f2);
z = VowelZ(f3);

if(y < 0) y = 0;
if(y > (HEIGHT-4)) y= (HEIGHT-4);
if(x < 0) x = 0;
if(x > (WIDTH-12)) x = (WIDTH-12);

r = z;
g = 255;
b = 100 + z/2;
HslToRgb(&r,&g,&b);
brush.SetColour(r,g,b);
dc->SetBrush(brush);
dc->DrawCircle(x,y,4);

// check for a label already at this position
collisions = 0;
posn = (x/8)*WIDTH + (y/8);
for(ix=0; ix<vowel_posn_ix; ix++)
{
if(posn == vowel_posn[ix])
collisions++;
}
vowel_posn[vowel_posn_ix++] = posn;

dc->DrawText(name,x+4,y+(collisions*10));

if(g2 != 0xffff)
{
y2 = VowelY(g1);
x2 = VowelX(g2);
dc->DrawLine(x,y,x2,y2);
}
}



static int VowelChartDir(wxDC *dc, wxBitmap *bitmap)
{//=================================================
int ix;
int nf;
int count = 0;
SpectSeq *spectseq;
SpectFrame *frame1;
SpectFrame *frame2=NULL;
wxFileName filename;

wxString dir = wxDirSelector(_T("Directory of vowel files"),path_phsource);
if(dir.IsEmpty()) return(0);

wxString path = wxFindFirstFile(dir+_T("/*"),wxFILE);

while (!path.empty())
{
if((spectseq = new SpectSeq) == NULL) break;

filename = wxFileName(path);
wxFileInputStream stream(path);
if(stream.Ok() == FALSE)
{
path = wxFindNextFile();
delete spectseq;
continue;
}
spectseq->Load(stream);

nf = 0;
frame1 = NULL;

if(spectseq->numframes > 0)
{
frame2 = spectseq->frames[0];
}
for(ix=0; ix<spectseq->numframes; ix++)
{
if(spectseq->frames[ix]->keyframe)
{
nf++;
frame2 = spectseq->frames[ix];
if(frame2->markers & FRFLAG_VOWEL_CENTRE)
frame1 = frame2;
}
}
if((nf >= 3) && (frame1 != NULL))
{
DrawVowel(dc,wxString(filename.GetName()),
frame1->peaks[1].pkfreq, frame1->peaks[2].pkfreq, frame1->peaks[3].pkfreq,
frame2->peaks[1].pkfreq, frame2->peaks[2].pkfreq);

count++;
}
delete spectseq;
path = wxFindNextFile();
}
filename.SetPath(dir);
filename.SetFullName(_T("vowelchart.png"));
bitmap->SaveFile(filename.GetFullPath(),wxBITMAP_TYPE_PNG);
return(count);
}


static int VowelChartList(wxDC *dc, wxBitmap *bitmap, char *fname)
{//===============================================================
// Plot a graph of vowel formants.
// y-axis is decreasing f1 (closeness)
// x-axis is decreasing f2 (backness)
FILE *f_in;
int ix;
int f1,f2,f3,g1,g2;
int colour;
int count=0;
wxFileName filename;
char name[40];
char buf[200];
wxString path;

if(fname != NULL)
{
path = wxString(fname,wxConvLocal);
}
else
{
path = wxFileSelector(_T("Read file of vowel formants"),path_phsource,
_T(""),_T(""),_T("*"),wxOPEN);
}
if(path.IsEmpty())
{
return(0);
}

filename = wxFileName(path);
strcpy(buf,path.mb_str(wxConvLocal));
f_in = fopen(buf,"r");
if(f_in == NULL)
{
wxLogError(_T("Can't read file: %s"),buf);
return(0);
}


while(fgets(buf,sizeof(buf),f_in) != NULL)
{
g2 = 0xffff;
ix = sscanf(buf,"%s %d %d %d %d %d %d",name,&colour,&f1,&f2,&f3,&g1,&g2);
if(ix >= 4)
{
if(colour == 1)
{
dc->SetPen(*wxMEDIUM_GREY_PEN);
dc->SetTextForeground(wxColour(100,100,128));
}
else
{
dc->SetPen(*wxBLACK_PEN);
dc->SetTextForeground(*wxBLACK);
}

DrawVowel(dc,wxString(name,wxConvLocal),
f1,f2,f3,g1,g2);
count++;
}
}

filename.SetExt(_T("png"));
bitmap->SaveFile(filename.GetFullPath(),wxBITMAP_TYPE_PNG);
fclose(f_in);
return(count);
}


void VowelChart(int control, char *fname)
{//======================================
// Plot a graph of vowel formants.
// y-axis is decreasing f1 (closeness)
// x-axis is decreasing f2 (backness)
// control=1 from directory of lists
// control=2 from single list
// control=3 from directory of phoneme source data files

int ix;
int x,y;
int count;
wxFileName filename;

wxBitmap bitmap(WIDTH,HEIGHT);

// Create a memory DC
wxMemoryDC dc;
dc.SelectObject(bitmap);
dc.SetBrush(*wxWHITE_BRUSH);
dc.SetFont(*wxSWISS_FONT);
dc.Clear();

// draw grid
dc.SetPen(*wxLIGHT_GREY_PEN);
for(ix=200; ix<=1000; ix+=50)
{
y = VowelY(ix);
dc.DrawLine(0,y,WIDTH,y);
if((ix % 100) == 0)
dc.DrawText(wxString::Format(_T("%d"),ix),1,y);
}
for(ix=700; ix<=2400; ix+=100)
{
x = VowelX(ix);
dc.DrawLine(x,0,x,HEIGHT);
if((ix % 200)==0)
dc.DrawText(wxString::Format(_T("%d"),ix),x+1,0);
}
dc.SetPen(*wxBLACK_PEN);
vowel_posn_ix = 0;
if(control==3)
count = VowelChartDir(&dc, &bitmap);
else
count = VowelChartList(&dc, &bitmap, fname);

dc.SetTextForeground(*wxBLACK);

if(control != 1)
wxLogStatus(_T("Plotted %d vowels"),count);
}



void FindPhonemesUsed(void)
{//========================
int hash;
char *p;
unsigned int *pw;
char *next;
unsigned char c;
int count = 0;
int ignore;
char phonetic[N_WORD_PHONEMES];

// look through all the phoneme strings in the **_rules data
// and mark these phoneme codes as used.
p = translator->data_dictrules;
while(*p != 0)
{
if(*p == RULE_CONDITION)
p+=2;
if(*p == RULE_LINENUM)
p+=3;
if(*p == RULE_GROUP_END)
{
p++;
if(*p == 0) break;
}
if(*p == RULE_GROUP_START)
{
if(p[1] == RULE_REPLACEMENTS)
{
p++;
pw = (unsigned int *)(((long)p+4) & ~3); // advance to next word boundary
while(pw[0] != 0)
{
pw += 2; // find the end of the replacement list, each entry is 2 words.
}
p = (char *)(pw+1);
continue;
}

if(p[1] == RULE_LETTERGP2)
{
while(*p != RULE_GROUP_END) p++;
continue;
}

p += (strlen(p)+1);
}

while((c = *p) != 0)
{
if(c == RULE_CONDITION)
p++; // next byte is the condition number, which may be 3 (= RULE_PHONEMES)
if(c == RULE_PHONEMES)
break;
p++;
}


count++;
if(c == RULE_PHONEMES)
{
ignore = 0;
p++;
while((c = *p) != 0)
{
if(c == phonSWITCH)
ignore = 1;

if(ignore == 0)
phoneme_tab_flags[c] |= 2;
p++;
}
}
p++;
}

// NOTE, we should recognise langopts.textmode and ignore the *_list file (lang=zh)

for(hash=0; hash<N_HASH_DICT; hash++)
{
p = translator->dict_hashtab[hash];
if(p == NULL)
continue;

while(*p != 0)
{
next = p + p[0];
if((p[1] & 0x80) == 0)
{
p += ((p[1] & 0x3f) + 2);
strcpy(phonetic,p);
p += strlen(phonetic) +1;

// examine flags
ignore = 0;
while(p < next)
{
if(*p == BITNUM_FLAG_TEXTMODE)
{
ignore = 1;
break;
}
p++;
}

if(ignore == 0)
{
p = phonetic;
while((c = *p) != 0)
{
if(c == phonSWITCH)
break;

phoneme_tab_flags[c] |= 2;
p++;
}
}
}
p = next;
}
}
} // end of FindPhonemesUsed




#define N_VOWELFMT_ADDR 20
int n_vowelfmt_addr;
int vowelfmt_addr[N_VOWELFMT_ADDR]; // FMT() statements found in a phoneme definition

static void FindVowelFmt(int prog_start, int length)
{//=================================================
USHORT *prog;
USHORT instn;
int prog_end;

prog_end = prog_start + length;
n_vowelfmt_addr = 0;

for(prog = &phoneme_index[prog_start]; prog < &phoneme_index[prog_end]; prog += NumInstnWords(prog))
{
instn = *prog;
if((instn >> 12) == 11)
{
// FMT instruction
if(n_vowelfmt_addr < N_VOWELFMT_ADDR)
{
vowelfmt_addr[n_vowelfmt_addr++] = ((instn & 0xf) << 18) + (prog[1] << 2);
}
}
}
} // end of FindVowelFmt


static int prog_log_sorter(PHONEME_PROG_LOG *p1, PHONEME_PROG_LOG *p2)
{//===================================================================
return(p1->addr - p2->addr);
}

void MakeVowelLists(void)
{//======================
// For each phoneme table, make a list of its vowels and their
// formant frequencies (f1,f2,f3) for use by VowelChart()

int table;
int ix;
int phcode;
PHONEME_TAB *ph;
FILE *f;
FILE *f_prog_log;
SPECT_SEQ *seq;
SPECT_SEQK *seqk;
frame_t *frame;
int n_prog_log;
int vowelfmt_ix;
int colour;
int voice_found;
PHONEME_PROG_LOG *prog_log_table;
PHONEME_PROG_LOG *found_prog;
PHONEME_PROG_LOG this_prog;
char dirname[sizeof(path_source)+20];
char fname[sizeof(dirname)+40];
char save_voice_name[80];

strcpy(save_voice_name,voice_name2);

sprintf(fname,"%s%s",path_source,"compile_prog_log");
if((f_prog_log = fopen(fname,"rb")) == NULL)
{
wxLogError(_T("Can't read 'compile_prog_log;"));
return;
}
ix = GetFileLength(fname);
prog_log_table = (PHONEME_PROG_LOG *)malloc(ix);
if(prog_log_table == NULL)
{
fclose(f_prog_log);
return;
}
ix = fread(prog_log_table, 1, ix, f_prog_log);
fclose(f_prog_log);
n_prog_log = ix / sizeof(PHONEME_PROG_LOG);

progress = new wxProgressDialog(_T("Vowel charts"),_T(""),n_phoneme_tables);

sprintf(dirname,"%s%s",path_source,"vowelcharts");
mkdir(dirname,S_IRWXU | S_IRGRP | S_IROTH);

sprintf(fname,"%s/vowel_log",dirname);

for(table=0; table<n_phoneme_tables; table++)
{
sprintf(fname,"%s/%s",dirname,phoneme_tab_list[table].name);
if((f = fopen(fname,"w"))==NULL) continue;

progress->Update(table);

// select the phoneme table by name
// if(SetVoiceByName(phoneme_tab_list[table].name) != 0) continue;
if(SelectPhonemeTableName(phoneme_tab_list[table].name) < 0)
{
fclose(f);
continue;
}

voice_found = 0;
if((LoadVoice(phoneme_tab_list[table].name, 0) != NULL) && (translator->data_dictrules != NULL))
{
voice_found = 1;
FindPhonemesUsed();
}

// phoneme table is terminated by a phoneme with no name (=0)
for(phcode=1; phcode < n_phoneme_tab; phcode++)
{
ph = phoneme_tab[phcode];

if((ph==NULL) || (ph->type != phVOWEL) || (ph->program == 0))
continue;

if(voice_found && (phoneme_tab_flags[phcode] & 3) == 0)
{
continue; // inherited, and not used
}

// find the size of this program
this_prog.addr = ph->program;
found_prog = (PHONEME_PROG_LOG *)bsearch((void *)&this_prog, (void *)prog_log_table, n_prog_log, sizeof(PHONEME_PROG_LOG), (int(*)(const void *,const void *))prog_log_sorter);

FindVowelFmt(ph->program, found_prog->length);

for(vowelfmt_ix=0; vowelfmt_ix < n_vowelfmt_addr; vowelfmt_ix++)
{
ix = vowelfmt_addr[vowelfmt_ix];

seq = (SPECT_SEQ *)(&phondata_ptr[ix]);
seqk = (SPECT_SEQK *)seq;
if(seq->frame[0].frflags & FRFLAG_KLATT)
frame = &seqk->frame[1];
else
frame = (frame_t *)&seq->frame[1];

if((n_vowelfmt_addr - vowelfmt_ix) == 1)
colour = 0;
else
colour = 1;

fprintf(f,"%s\t %d %3d %4d %4d",WordToString(ph->mnemonic), colour,
frame->ffreq[1],frame->ffreq[2],frame->ffreq[3]);
if(seq->frame[0].frflags & FRFLAG_KLATT)
frame = &seqk->frame[seqk->n_frames-1];
else
frame = (frame_t *)&seq->frame[seq->n_frames-1];
fprintf(f," %3d %4d %4d\n",frame->ffreq[1],frame->ffreq[2],frame->ffreq[3]);
}
}
fclose(f);

VowelChart(1,fname); // draw the vowel chart
}
free(prog_log_table);
LoadVoice(voice_name2,0); // reset the original phoneme table
delete progress;
LoadVoiceVariant(save_voice_name,0);
}


#define N_ENVELOPES 30
extern int n_envelopes;
extern char envelope_paths[N_ENVELOPES][80];
extern unsigned char envelope_dat[N_ENVELOPES][ENV_LEN];

#define HT_ENV 140
#define WD_ENV 128*2

void DrawEnvelopes()
{//================
int ix_env;
int y_base;
int x;
FILE *f_txt=NULL;
unsigned char *env;
char name[200];

wxBitmap bitmap(WD_ENV,HT_ENV*n_envelopes);

// Create a memory DC
wxMemoryDC dc;
dc.SelectObject(bitmap);
dc.SetBrush(*wxWHITE_BRUSH);
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++)
{
y_base = HT_ENV * ix_env;
dc.SetPen(*wxLIGHT_GREY_PEN);
dc.DrawLine(0,y_base+0,256,y_base+0);
dc.DrawLine(0,y_base+64,256,y_base+64);
dc.DrawLine(0,y_base+128,256,y_base+128);
dc.DrawLine(128,y_base+0,128,y_base+128);

dc.SetPen(*wxBLACK_PEN);
strncpy0(name,envelope_paths[ix_env],sizeof(name));
dc.DrawText(wxString(name,wxConvLocal),1,y_base);

env = envelope_dat[ix_env];
y_base = y_base+128;
for(x=0; x<127; x++)
{
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);
}


Write Preview
Loading…
Cancel
Save