Parlando di Java!

Perché vorresti far parlare le tue applicazioni? Per cominciare, è divertente e adatto ad applicazioni divertenti come i giochi. E c'è un lato dell'accessibilità più serio. Sto pensando qui non solo a coloro che sono naturalmente svantaggiati quando si utilizza un'interfaccia visiva, ma anche a quelle situazioni in cui è impossibile, o addirittura illegale, distogliere lo sguardo da ciò che si sta facendo.

Recentemente ho lavorato con alcune tecnologie per prendere informazioni HTML e XML dal Web [vedere "Accesso al database più grande del mondo con Web DataBase Connectivity" ( JavaWorld, marzo 2001)]. Mi è venuto in mente che avrei potuto collegare quel lavoro e questa idea insieme per costruire un browser Web parlante. Un browser di questo tipo si rivelerebbe utile per ascoltare frammenti di informazioni dai tuoi siti preferiti - titoli di notizie, ad esempio - proprio come ascoltare la radio mentre sei fuori a spasso con il tuo cane o guidi al lavoro. Naturalmente, con la tecnologia attuale dovresti portare in giro il tuo computer portatile con il telefono cellulare collegato, ma questo scenario poco pratico potrebbe cambiare nel prossimo futuro con l'arrivo di smartphone abilitati a Java come il Nokia 9210 (9290 nel NOI).

Forse più utile a breve termine sarebbe un lettore di posta elettronica, possibile anche grazie all'API JavaMail. Questa applicazione controllerebbe periodicamente la tua casella di posta e la tua attenzione sarebbe attratta da una voce dal nulla che proclama "Hai nuovi messaggi, vuoi che te li legga?" Allo stesso modo, prendi in considerazione un promemoria parlante - collegato all'applicazione del tuo diario - che grida "Non dimenticare il tuo incontro con il capo tra 10 minuti!"

Supponendo che tu sia venduto su quelle idee, o che tu abbia alcune buone idee tue, andremo avanti. Inizierò mostrando come mettere al lavoro il mio file zip fornito in modo che tu possa essere subito operativo e saltare i dettagli di implementazione se pensi che sia troppo faticoso.

Prova il motore vocale

Per utilizzare il motore vocale, è necessario includere il file jw-0817-javatalk.zip nel CLASSPATH ed eseguire la com.lotontech.speech.Talkerclasse dalla riga di comando o da un programma Java.

Per eseguirlo dalla riga di comando, digita:

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

Per eseguirlo da un programma Java, includi semplicemente due righe di codice:

com.lotontech.speech.Talker talker = nuovo com.lotontech.speech.Talker (); talker.sayPhoneWord ("h | e | l | oo");

A questo punto probabilmente ti chiederai quale sia il formato della "h|e|l|oo"stringa che fornisci sulla riga di comando o fornisci al sayPhoneWord(...)metodo. Lasciatemi spiegare.

Il motore vocale funziona concatenando brevi campioni sonori che rappresentano le unità più piccole del linguaggio umano, in questo caso l'inglese. Quei campioni sonori, chiamati allofoni, sono etichettati con un identificatore di una, due o tre lettere. Alcuni identificatori sono evidenti e altri meno, come puoi vedere dalla rappresentazione fonetica della parola "ciao".

  • h - suona come ti aspetteresti
  • e - suona come ti aspetteresti
  • l - suona come ti aspetteresti, ma nota che ho ridotto una doppia "l" a una singola
  • oo - è il suono per "ciao", non per "bot" e non per "troppo"

Ecco un elenco degli allofoni disponibili:

  • a - come nel gatto
  • b - come in cabina
  • c - come in cat
  • d - come in punto
  • e - come nella scommessa
  • f - come nella rana
  • g - come nella rana
  • h - come nel maiale
  • io - come nel maiale
  • j - come in jig
  • k - come in barile
  • l - come nella gamba
  • m - come in met
  • n - come all'inizio
  • o - come in no
  • p - come in pentola
  • r - come in rot
  • s - come in sat
  • t - come in sat
  • u - come in put
  • v - come in avere
  • w - come sul bagnato
  • y - come ancora
  • z - come nello zoo
  • aa - come in fake
  • ay - come nel fieno
  • ee : come nell'ape
  • ii - come in alto
  • oo - come in go
  • bb - variazione di b con diversa enfasi
  • dd - variazione di d con diversa enfasi
  • ggg - variazione di g con diversa enfasi
  • hh - variazione di h con diversa enfasi
  • ll - variazione di l con enfasi diversa
  • nn - variazione di n con diversa enfasi
  • rr - variazione di r con diversa enfasi
  • tt - variazione di t con diversa enfasi
  • yy - variazione di y con enfasi diversa
  • ar - come in macchina
  • aer : come in cura
  • ch - come in cui
  • ck - come nel controllo
  • orecchio - come nella birra
  • ehm - come in seguito
  • err - come in seguito (suono più lungo)
  • ng : come nel nutrirsi
  • o - come nella legge
  • ou - come nello zoo
  • ouu - come in zoo (suono più lungo)
  • ow - come nella mucca
  • oy - come nel ragazzo
  • sh - come chiuso
  • th - come in cosa
  • dth - come in questo
  • uh - variazione di u
  • wh - come in dove
  • zh - come in asiatico

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....