Говореща Java!

Защо искате да накарате вашите приложения да говорят? Като начало е забавно и подходящо за забавни приложения като игри. И има по-сериозна страна за достъпност. Тук имам предвид не само онези, които са естествено в неравностойно положение при използване на визуален интерфейс, но и онези ситуации, при които е невъзможно - или дори незаконно - да откъснеш поглед от това, което правиш.

Напоследък работя с някои технологии за вземане на HTML и XML информация от мрежата [вижте „Достъп до най-голямата база данни в света чрез Web DataBase Connectivity“ ( JavaWorld, март 2001 г.)]. Хрумна ми, че мога да свържа тази работа и тази идея заедно, за да изградя говорещ уеб браузър. Такъв браузър би се оказал полезен за слушане на фрагменти от информация от любимите ви сайтове - например заглавия на новини - точно като слушането на радио, докато разхождате кучето си или шофирате на работа. Разбира се, с настоящата технология ще трябва да носите своя преносим компютър с прикрепен мобилен телефон, но този непрактичен сценарий може да се промени в близко бъдеще с пристигането на смартфони с активирана Java, като Nokia 9210 (9290 в НАС).

Може би по-полезен в краткосрочен план би бил четец на имейли, също възможно благодарение на API на JavaMail. Това приложение ще проверява входящата ви поща периодично и вниманието ви ще бъде привлечено от глас от нищото, който провъзгласява „Имате нова поща, искате ли да ви я прочета?“ По подобен начин помислете за напомняне за говорене - свързано с приложението на дневника ви, което извиква „Не забравяйте срещата си с шефа след 10 минути!

Ако приемем, че сте продадени за тези идеи или имате някои свои собствени добри идеи, ще продължим напред. Ще започна, като покажа как да настроя предоставения ми zip файл да работи, за да можете веднага да стартирате и да пропуснете подробностите за изпълнението, ако смятате, че това е прекалено много работа.

Тествайте говорния двигател

За да използвате речевия механизъм, ще трябва да включите файла jw-0817-javatalk.zip във вашия CLASSPATH и да стартирате com.lotontech.speech.Talkerкласа от командния ред или от Java програма.

За да го стартирате от командния ред, напишете:

java com.lotontech.speech.Talker "h | e | l | oo" 

За да го стартирате от програма на Java, просто включете два реда код:

com.lotontech.speech.Talker говорящ = нов com.lotontech.speech.Talker (); talker.sayPhoneWord ("h | e | l | oo");

На този етап вероятно се чудите за формата на "h|e|l|oo"низа, който предоставяте в командния ред или предоставяте на sayPhoneWord(...)метода. Нека обясня.

Речевият механизъм работи чрез обединяване на кратки звукови образци, които представляват най-малките единици човешка - в случая английска - реч. Тези звукови образци, наречени алофони, са етикетирани с идентификатор с една, две или три букви. Някои идентификатори са очевидни, а други не толкова очевидни, както можете да видите от фонетичното представяне на думата „здравей“.

  • h - звучи както бихте очаквали
  • д - звучи както бихте очаквали
  • l - звучи както бихте очаквали, но забележете, че съм намалил двойно "l" до едно
  • oo - звукът е за "здравей", а не за "бот", а не за "твърде"

Ето списък с наличните алофони:

  • а - като в кат
  • b - като в кабината
  • в - като в кат
  • d - като в точка
  • д - като при залог
  • f - като при жаба
  • g - като при жаба
  • h - като при свиня
  • i - както при свинята
  • j - като в джиг
  • k - като в кег
  • л - като в крак
  • m - като в met
  • n - като в начало
  • o - като в не
  • p - като в пот
  • r - като при гниене
  • s - като в сб
  • t - като в сб
  • u - както е поставено
  • v - като в have
  • w - като в мокро
  • y - все още
  • z - като в зоопарка
  • аа - като при фалшив
  • ай - като при сено
  • ее - като при пчела
  • ii - като при висок
  • oo - като в go
  • bb - вариация на b с различен акцент
  • dd - вариация на d с различен акцент
  • ggg - вариация на g с различен акцент
  • hh - вариация на h с различен акцент
  • ll - вариация на l с различен акцент
  • nn - вариация на n с различен акцент
  • rr - вариация на r с различен акцент
  • tt - вариация на t с различен акцент
  • yy - вариация на y с различен акцент
  • ar - като в колата
  • aer - като в грижа
  • ch - като в коя
  • ck - като при проверка
  • ухо - като при бира
  • ъ-ъ - както по-късно
  • грешка - както по-късно (по-дълъг звук)
  • ng - като при хранене
  • или - както е в закона
  • ou - като в зоопарка
  • ouu - като в зоопарка (по-дълъг звук)
  • оу - като при кравата
  • ой - като при момче
  • ш - като в затворено
  • й - като в нещо
  • dth - както в този
  • ъ-ъ - вариация на u
  • wh - като в къде
  • zh - като в азиатски

In human speech the pitch of words rises and falls throughout any spoken sentence. This intonation makes the speech sound more natural, more emotive, and allows questions to be distinguished from statements. If you've ever heard Stephen Hawking's synthetic voice, you understand what I'm talking about. Consider these two sentences:

  • It is fake -- f|aa|k
  • Is it fake? -- f|AA|k

As you might have guessed, the way to raise the intonation is to use capital letters. You need to experiment with this a little, and my hint is that you should concentrate on the long vowel sounds.

That's all you need to know to use the software, but if you're interested in what's going on under the hood, read on.

Implement the speech engine

The speech engine requires just one class to implement, with four methods. It employs the Java Sound API included with J2SE 1.3. I won't provide a comprehensive tutorial of the Java Sound API, but you'll learn by example. You'll find there's not much to it, and the comments tell you what you need to know.

Here's the basic definition of the Talker class:

package com.lotontech.speech; import javax.sound.sampled.*; import java.io.*; import java.util.*; import java.net.*; public class Talker { private SourceDataLine line=null; } 

If you run Talker from the command line, the main(...) method below will serve as the entry point. It takes the first command line argument, if one exists, and passes it to the sayPhoneWord(...) method:

/* * This method speaks a phonetic word specified on the command line. */ public static void main(String args[]) { Talker player=new Talker(); if (args.length>0) player.sayPhoneWord(args[0]); System.exit(0); } 

The sayPhoneWord(...) method is called by main(...) above, or it may be called directly from your Java application or plug-in supported applet. It looks more complicated than it is. Essentially, it simply steps though the word allophones -- separated by "|" symbols in the input text -- and plays them one by one through a sound-output channel. To make it sound more natural, I merge the end of each sound sample with the beginning of the next one:

/* * This method speaks the given phonetic word. */ public void sayPhoneWord(String word) { // -- Set up a dummy byte array for the previous sound -- byte[] previousSound=null; // -- Split the input string into separate allophones -- StringTokenizer st=new StringTokenizer(word,"|",false); while (st.hasMoreTokens()) { // -- Construct a file name for the allophone -- String thisPhoneFile=st.nextToken(); thisPhoneFile="/allophones/"+thisPhoneFile+".au"; // -- Get the data from the file -- byte[] thisSound=getSound(thisPhoneFile); if (previousSound!=null) { // -- Merge the previous allophone with this one, if we can -- int mergeCount=0; if (previousSound.length>=500 && thisSound.length>=500) mergeCount=500; for (int i=0; i
   
    

At the end of sayPhoneWord(), you'll see it calls playSound(...) to output an individual sound sample (an allophone), and it calls drain(...) to flush the sound channel. Here's the code for playSound(...):

/* * This method plays a sound sample. */ private void playSound(byte[] data) { if (data.length>0) line.write(data, 0, data.length); } 

And for drain(...):

/* * This method flushes the sound channel. */ private void drain() { if (line!=null) line.drain(); try {Thread.sleep(100);} catch (Exception e) {} } 

Now, if you look back at the sayPhoneWord(...) method, you'll see there's one method I've not yet covered: getSound(...).

getSound(...) reads in a prerecorded sound sample, as byte data, from an au file. When I say a file, I mean a resource held within the supplied zip file. I draw the distinction because the way you get hold of a JAR resource -- using the getResource(...) method -- proceeds differently from the way you get hold of a file, a not obvious fact.

For a blow-by-blow account of reading the data, converting the sound format, instantiating a sound output line (why they call it a SourceDataLine, I don't know), and assembling the byte data, I refer you to the comments in the code that follows:

/* * This method reads the file for a single allophone and * constructs a byte vector. */ private byte[] getSound(String fileName) { try { URL url=Talker.class.getResource(fileName); AudioInputStream stream = AudioSystem.getAudioInputStream(url); AudioFormat format = stream.getFormat(); // -- Convert an ALAW/ULAW sound to PCM for playback -- if ((format.getEncoding() == AudioFormat.Encoding.ULAW) || (format.getEncoding() == AudioFormat.Encoding.ALAW)) { AudioFormat tmpFormat = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, format.getSampleRate(), format.getSampleSizeInBits() * 2, format.getChannels(), format.getFrameSize() * 2, format.getFrameRate(), true); stream = AudioSystem.getAudioInputStream(tmpFormat, stream); format = tmpFormat; } DataLine.Info info = new DataLine.Info( Clip.class, format, ((int) stream.getFrameLength() * format.getFrameSize())); if (line==null) { // -- Output line not instantiated yet -- // -- Can we find a suitable kind of line? -- DataLine.Info outInfo = new DataLine.Info(SourceDataLine.class, format); if (!AudioSystem.isLineSupported(outInfo)) { System.out.println("Line matching " + outInfo + " not supported."); throw new Exception("Line matching " + outInfo + " not supported."); } // -- Open the source data line (the output line) -- line = (SourceDataLine) AudioSystem.getLine(outInfo); line.open(format, 50000); line.start(); } // -- Some size calculations -- int frameSizeInBytes = format.getFrameSize(); int bufferLengthInFrames = line.getBufferSize() / 8; int bufferLengthInBytes = bufferLengthInFrames * frameSizeInBytes; byte[] data=new byte[bufferLengthInBytes]; // -- Read the data bytes and count them -- int numBytesRead = 0; if ((numBytesRead = stream.read(data)) != -1) { int numBytesRemaining = numBytesRead; } // -- Truncate the byte array to the correct size -- byte[] newData=new byte[numBytesRead]; for (int i=0; i
     
      

So, that's it. A speech synthesizer in about 150 lines of code, including comments. But it's not quite over.

Text-to-speech conversion

Specifying words phonetically might seem a bit tedious, so if you intend to build one of the example applications I suggested in the introduction, you want to provide ordinary text as input to be spoken.

After looking into the issue, I've provided an experimental text-to-speech conversion class in the zip file. When you run it, the output will give you insight into what it does.

You can run a text-to-speech converter with a command like this:

java com.lotontech.speech.Converter "hello there" 

What you'll see as output looks something like:

hello -> h|e|l|oo there -> dth|aer 

Or, how about running it like:

java com.lotontech.speech.Converter "I like to read JavaWorld" 

to see (and hear) this:

i -> ii like -> l|ii|k to -> t|ouu read -> r|ee|a|d java -> j|a|v|a world -> w|err|l|d 

If you're wondering how it works, I can tell you that my approach is quite simple, consisting of a set of text replacement rules applied in a certain order. Here are some example rules that you might like to apply mentally, in order, for the words "ant," "want," "wanted," "unwanted," and "unique":

  1. Replace "*unique*" with "|y|ou|n|ee|k|"
  2. Replace "*want*" with "|w|o|n|t|"
  3. Replace "*a*" with "|a|"
  4. Replace "*e*" with "|e|"
  5. Replace "*d*" with "|d|"
  6. Replace "*n*" with "|n|"
  7. Replace "*u*" with "|u|"
  8. Replace "*t*" with "|t|"

For "unwanted" the sequence would be thus:

unwantedun[|w|o|n|t|]ed (rule 2) [|u|][|n|][|w|o|n|t|][|e|][|d|] (rules 4, 5, 6, 7) u|n|w|o|n|t|e|d (with surplus characters removed) 

You should see how words containing the letters wont will be spoken in a different way to words containing the letters ant. You should also see how the special case rule for the complete word unique takes precedence over the other rules so that this word is spoken as y|ou... rather than u|n....