playermodelimpl.java

FreeTTS is a speech synthesis system written entirely in the Java programming language. It is based

     *
     * @return the volume, or -1 if unknown, or an error occurred
     */
    public float getVolume() {
	try {
	    float adjustedVolume =
		synthesizer.getSynthesizerProperties().getVolume();
	    if (adjustedVolume < 0.5) {
		volume = 0;
	    } else {
		volume = (float) ((adjustedVolume - 0.5) * 20);
	    }
	} catch (Exception e) {
	    e.printStackTrace();
	} 
	return volume;
    }
    

    /**
     * Sets the volume, in the range of 0 to 10.
     *
     * @param volume the new volume
     *
     * @return true if new volume is set; false otherwise
     */
    public boolean setVolume(float volume) {
	try {
	    float adjustedVolume = (float) (volume/20 + 0.5);
	    if (synthesizer != null) {
		synthesizer.getSynthesizerProperties().setVolume
		    (adjustedVolume);
		this.volume = volume;
		return true;
	    } else {
		this.volume = volume;
		return false;
	    }
	} catch (PropertyVetoException pve) {
	    try {
		synthesizer.getSynthesizerProperties().setVolume(this.volume);
	    } catch (PropertyVetoException pe) {
		pe.printStackTrace();
	    }
	    return false;
	}
    }
                

    /**
     * Returns the speaking rate.
     *
     * @return the speaking rate, or -1 if unknown or an error occurred
     */
    public float getSpeakingRate() {
	if (synthesizer != null) {
	    return synthesizer.getSynthesizerProperties().getSpeakingRate();
	} else {
	    return -1;
	}
    }
	

    /**
     * Sets the speaking rate in terms of words per minute.
     *
     * @param wordsPerMin the new speaking rate
     *
     * @return the speaking rate, or -1 if unknown or an error occurred
     */
    public boolean setSpeakingRate(float wordsPerMin) {
	float oldSpeed = getSpeakingRate();
	SynthesizerProperties properties =
	    synthesizer.getSynthesizerProperties();
	try {
	    properties.setSpeakingRate(wordsPerMin);
	    return true;
	} catch (PropertyVetoException pve) {
	    try {
		properties.setSpeakingRate(oldSpeed);
	    } catch (PropertyVetoException pe) {
		pe.printStackTrace();
	    }
	    return false;
	}
    }	


    /**
     * Returns the baseline pitch for the current synthesis voice.
     *
     * @return the baseline pitch for the current synthesis voice
     */
    public float getPitch() {
	return synthesizer.getSynthesizerProperties().getPitch();
    }	


    /**
     * Sets the baseline pitch for the current synthesis voice.
     *
     * @param pitch the baseline pitch
     *
     * @return true if new pitch is set; false otherwise
     */
    public boolean setPitch(float pitch) {
	float oldPitch = getPitch();
	try {
	    synthesizer.getSynthesizerProperties().setPitch(pitch);
	    return true;
	} catch (PropertyVetoException pve) {
	    try {
		synthesizer.getSynthesizerProperties().setPitch(oldPitch);
	    } catch (PropertyVetoException pe) {
		pe.printStackTrace();
	    }
	    return false;
	}
    }
    

    /**
     * Returns the pitch range for the current synthesis voice.
     *
     * @return the pitch range for the current synthesis voice
     */
    public float getRange() {
	return synthesizer.getSynthesizerProperties().getPitchRange();
    }
    

    /**
     * Sets the pitch range for the current synthesis voice.
     *
     * @param range the pitch range
     *
     * @return true if new range is set; false otherwise
     */
    public boolean setRange(float range) {
	float oldRange = getRange();
	try {
	    synthesizer.getSynthesizerProperties().setPitchRange(range);
	    return true;
	} catch (PropertyVetoException pve) {
	    try {
		synthesizer.getSynthesizerProperties().setPitchRange(oldRange);
	    } catch (PropertyVetoException pe) {
		pe.printStackTrace();
	    }
	    return false;
	}
    }
         

    /**
     * Sets the list of voices using the given Synthesizer mode description.
     *
     * @param modeDesc the synthesizer mode description
     */
    public void setVoiceList(SynthesizerModeDesc modeDesc) {
	Voice[] voices = modeDesc.getVoices();
	voiceList.removeAllElements();
	for (int i = 0; i < voices.length; i++) {
	    voiceList.addElement(new MyVoice(voices[i].getName(),
					     voices[i].getGender(),
					     voices[i].getAge(),
					     voices[i].getStyle()));
	}
    }


    /**
     * Returns the play list.
     *
     * @return the play list
     */
    public ListModel getPlayList() {
	return playList;
    }


    /**
     * Returns the list of voices.
     *
     * @return the list of voices
     */
    public ListModel getVoiceList() {
	return voiceList;
    }


    /**
     * Returns the list synthesizers
     *
     * @return the synthesizer list
     */
    public ListModel getSynthesizerList() {
	return synthesizerList;
    }

    
    /**
     * Returns the Playable object at the given index of the play list.
     *
     * @return the Playable object
     */
    public Object getPlayableAt(int index) {
	return null;
    }
    

    /**
     * Adds the given Playable object to the end of the play list.
     *
     * @param playable the Playable object to add
     */
    public void addPlayable(Playable playable) {
	playList.addElement(playable);
    }


    /**
     * Removes the playable at the given position from the list
     *
     * @param index the index of the Playable to remove
     */
    public void removePlayableAt(int index) {
	if (index < playList.getSize()) {
	    playList.removeElementAt(index);
	}
    }


    /**
     * Prints debug statements.
     *
     * @param statement debug statements
     */
    public static void debugPrint(String statement) {
	if (debug) {
	    System.out.println(statement);
	}
    }
}


/**
 * A Voice that implements the <code>toString()</code> method so that
 * it returns the name of the person who owns this Voice.
 */
class MyVoice extends Voice {


    /**
     * Constructor provided with voice name, gender, age and style.
     *
     * @param name the name of the person who owns this Voice
     * @param gender the gender of the person
     * @param age the age of the person
     * @param style the style of the person
     */
    public MyVoice(String name, int gender, int age, String style) {
	super(name, gender, age, style);
    }


    /**
     * Returns the name of the person who owns this Voice.
     *
     * @param String the name of the person
     */
    public String toString() {
	return getName();
    }
}


/**
 * A SynthesizerModeDesc that implements the <code>toString()</code>
 * method so that it returns the name of the synthesizer.
 */
class MySynthesizerModeDesc extends SynthesizerModeDesc {

    private PlayerModel playerModel = null;
    private Synthesizer synthesizer = null;
    private Monitor monitor = null;
    private boolean synthesizerLoaded = false;
    

    /**
     * Constructs a MySynthesizerModeDesc with the attributes from
     * the given SynthesizerModeDesc.
     *
     * @param modeDesc the SynthesizerModeDesc to get attributes from
     */
    public MySynthesizerModeDesc(SynthesizerModeDesc modeDesc,
				 PlayerModel playerModel) {
	super(modeDesc.getEngineName(), modeDesc.getModeName(),
	      modeDesc.getLocale(), modeDesc.getRunning(), 
	      modeDesc.getVoices());
	this.playerModel = playerModel;
    }
    
    
    /**
     * Returns true if the synthesizer is already loaded.
     *
     * @return true if the synthesizer is already loaded
     */
    public synchronized boolean isSynthesizerLoaded() {
	if (synthesizer == null) {
	    return false;
	}
	return ((synthesizer.getEngineState() & Engine.ALLOCATED) != 0);
    }
    
    
    /**
     * Returns a Synthesizer that fits the description of this
     * MySynthesizerModeDesc. If the synthesize was never loaded,
     * it is loaded in a separate thread.
     *
     * @return a Synthesizer
     */
    public synchronized Synthesizer getSynthesizer() {
	debugPrint("MyModeDesc.getSynthesizer(): " + getEngineName());
	return synthesizer;
    }


    /**
     * Creates the Synthesizer and its Monitor.
     *
     * @return the created Synthesizer
     */
    public Synthesizer createSynthesizer() {
	try {
	    debugPrint("Creating " + getEngineName() + "...");
	    synthesizer = Central.createSynthesizer(this);
	    
	    if (synthesizer == null) {
		System.out.println("Central created null synthesizer");
	    } else {
		synthesizer.allocate();
		synthesizer.resume();
		monitor = new Monitor(synthesizer, getEngineName());
		debugPrint("...created monitor");
	    }
	} catch (Exception e) {
	    e.printStackTrace();
	} 
	return synthesizer;
    }

    

    /**
     * Allocates the synthesizer if it has never been allocated. This
     * method should be called after method <code>createSynthesizer()</code>.
     * It spawns a new thread to allocate the synthesizer.
     */
    public Synthesizer loadSynthesizer() {
	try {
	    if (!synthesizerLoaded) {
		debugPrint("Loading " + getEngineName() + "...");
		synthesizerLoaded = true;
		SynthesizerLoader loader = new SynthesizerLoader
		    (synthesizer, this);
		loader.start();
	    }
	} catch (Exception e) {
	    e.printStackTrace();
	}
	return synthesizer;
    }


    /**
     * Returns the Monitor of this Synthesizer.
     *
     * @return the Monitor
     */
    public synchronized Monitor getMonitor() {
	if (monitor == null) {
	    createSynthesizer();
	}
	return monitor;
    }

    
    /**
     * Returns the PlayerModel.
     *
     * @return the PlayerModel
     */
    public PlayerModel getPlayerModel() {
	return playerModel;
    }

    
    /**
     * Returns the name of the Synthesizer.
     *
     * @return the name of the Synthesizer
     */
    public String toString() {
	return getEngineName();
    }

    
    /**
     * Prints debug statements.
     *
     * @param statement debug statements
     */
    private void debugPrint(String statement) {
	PlayerModelImpl.debugPrint(statement);
    }
}


/**
 * A Thread that loads the Synthesizer.
 */
class SynthesizerLoader extends Thread {
    private Synthesizer synthesizer;
    private MySynthesizerModeDesc modeDesc;
    private PlayerModel playerModel;
   
    
    /**
     * Constructs a SynthesizerLoaded which loads the given Synthesizer.
     *
     * @param synthesizer the Synthesizer to load
     * @param modeDesc the MySynthesizerModeDesc from which we can retrieve
     *    the PlayerModel
     */
    public SynthesizerLoader(Synthesizer synthesizer,
			     MySynthesizerModeDesc modeDesc) {
	this.synthesizer = synthesizer;
	this.modeDesc = modeDesc;
	this.playerModel = modeDesc.getPlayerModel();
    }
    

    /**
     * Implements the <code>run()</code> method of the Thread class.
     */
    public void run() {
	try {
	    System.out.println("allocating...");
	    synthesizer.allocate();
	    System.out.println("...allocated");
	    synthesizer.resume();
	    System.out.println("...resume");
	    playerModel.setVoiceList(modeDesc);
	} catch (Exception e) {
	    e.printStackTrace();
	}
    }
}