freetts.java

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

    public void setSilentMode(boolean silent) {
	this.silent = silent;
    }

    /**
     * Gets silent mode.
     *
     * @return true if in silent mode
     *
     * @see #setSilentMode
     */
    public boolean getSilentMode() {
	return this.silent;
    }


    /**
     * Sets the input mode.
     *
     * @param inputMode the input mode
     */
    public void setInputMode(InputMode inputMode) {
	this.inputMode = inputMode;
    }

    
    /**
     * Returns the InputMode.
     *
     * @return the input mode
     *
     * @see #setInputMode
     */
    public InputMode getInputMode() {
	return this.inputMode;
    }

    /**
     * Sets the audio file .
     *
     * @param audioFile the audioFile 
     */
    public void setAudioFile(String audioFile) {
	this.audioFile = audioFile;
    }

    /**
     * Sets multi audio. If true, and an audio file has been set
     * output will be sent to  multiple files
     *
     * @param multiAudio if <code>true</code> send output to multiple
     * files.
     */
    public void setMultiAudio(boolean multiAudio) {
	this.multiAudio = multiAudio;
    }

    /**
     * Sets streaming audio. If true, output will be sent to 
     *
     * @param streamingAudio if <code>true</code> stream audio
     */
    public void setStreamingAudio(boolean streamingAudio) {
	this.streamingAudio = streamingAudio;
    }

    /**
     * Prints the usage message for FreeTTS.
     */
    static void usage(String voices) {
        System.out.println(VERSION);
        System.out.println("Usage:");
        System.out.println("    -detailedMetrics: turn on detailed metrics");
	System.out.println("    -dumpAudio file : dump audio to file ");
        System.out.println("    -dumpAudioTypes : dump the possible" +
                           " output types");
	System.out.println("    -dumpMultiAudio file : dump audio to file ");
        System.out.println("    -dumpRelations  : dump the relations ");
        System.out.println("    -dumpUtterance  : dump the final utterance");
	System.out.println("    -dumpASCII file : dump the final wave to file as ASCII");
	System.out.println("    -file file      : speak text from given file");
	System.out.println("    -lines file     : render lines from a file");
	System.out.println("    -help           : shows usage information");
        System.out.println("    -voiceInfo      : print detailed voice info");
        System.out.println("    -metrics        : turn on metrics");
        System.out.println("    -run  name      : sets the name of the run");
        System.out.println("    -silent         : don't say anything");
        System.out.println("    -streaming      : use streaming audio player");
        System.out.println("    -text say me    : speak given text");
	System.out.println("    -url path       : speak text from given URL");
        System.out.println("    -verbose        : verbose output");
        System.out.println("    -version        : shows version number");
        System.out.println("    -voice VOICE    : " + voices);
    }

    /**
     * Starts interactive mode on the given FreeTTS. Reads text
     * from the console and gives it to FreeTTS to speak.
     * terminates on end of file.
     *
     * @param freetts the engine
     */
    private static void interactiveMode(FreeTTS freetts) {
	try {
	    while (true) {
		String text;
		BufferedReader reader;
		reader = new BufferedReader(
		    new InputStreamReader(System.in));
		System.out.print("Enter text: ");
		System.out.flush();
		text = reader.readLine();
		if ((text == null) || (text.length() == 0)) {
		    freetts.shutdown();
	  	    System.exit(0);
		} else {
		    freetts.batchTextToSpeech(text);
		}
	    }
	} catch (IOException e) {
	}
    }

    /**
     * Dumps the possible audio output file types
     */
    private static void dumpAudioTypes() {
	AudioFileFormat.Type[] types =
	    AudioSystem.getAudioFileTypes();

	for (int i = 0; i < types.length; i++) {
	    System.out.println(types[i].getExtension());
	}
    }

    /**
     * The main entry point for FreeTTS.
     */
    public static void main(String[] args) {

	String text = null;
	String inFile = null;
	String protocol = null;
        boolean dumpAudioTypes = false;
        Voice voice = null;

        VoiceManager voiceManager = VoiceManager.getInstance();
        String voices = voiceManager.toString();
        
        // find out what Voice to use first
        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("-voice")) {
                if (++i < args.length) {
		    String voiceName = args[i];
		    if (voiceManager.contains(voiceName)) {
                        voice = voiceManager.getVoice(voiceName);
		    } else {
			System.out.println("Invalid voice: " + voiceName);
			System.out.println
                            ("  Valid voices are " + voices);
			System.exit(1);
		    }
		} else {
		    usage(voices);
                    System.exit(1);
                }
                break;
            }
        }

        if (voice == null) { // default Voice is kevin16
            voice = voiceManager.getVoice("kevin16");
        }

        if (voice == null) {
            throw new Error ("The specified voice is not defined");
        }
        FreeTTS freetts = new FreeTTS(voice);

        for (int i = 0; i < args.length; i++) {
	    if (args[i].equals("-metrics")) {
		voice.setMetrics(true);
	    } else if (args[i].equals("-detailedMetrics")) {
		voice.setDetailedMetrics(true);
	    } else if (args[i].equals("-silent")) {
		freetts.setSilentMode(true);
	    } else if (args[i].equals("-streaming")) {
		freetts.setStreamingAudio(true);
	    } else if (args[i].equals("-verbose")) {
		voice.setVerbose(true);
	    } else if (args[i].equals("-dumpUtterance")) {
		voice.setDumpUtterance(true);
	    } else if (args[i].equals("-dumpAudioTypes")) {
		dumpAudioTypes = true;
	    } else if (args[i].equals("-dumpRelations")) {
		voice.setDumpRelations(true);
	    } else if (args[i].equals("-dumpASCII")) {
		if (++i < args.length) {
		    voice.setWaveDumpFile(args[i]);
		} else {
		    usage(voices);
		}
	    } else if (args[i].equals("-dumpAudio")) {
		if (++i < args.length) {
		    freetts.setAudioFile(args[i]);
		} else {
		    usage(voices);
		}
	    } else if (args[i].equals("-dumpMultiAudio")) {
		if (++i < args.length) {
		    freetts.setAudioFile(args[i]);
		    freetts.setMultiAudio(true);
		} else {
		    usage(voices);
		}
	    } else if (args[i].equals("-version")) {
		System.out.println(VERSION);
	    } else if (args[i].equals("-voice")) {
                // do nothing here, just skip the voice name
                i++;
	    } else if (args[i].equals("-help")) {
		usage(voices);
                System.exit(0);
            } else if (args[i].equals("-voiceInfo")) {
                System.out.println(VoiceManager.getInstance().getVoiceInfo());
                System.exit(0);
	    } else if (args[i].equals("-text")) {
		freetts.setInputMode(InputMode.TEXT);
		// add the rest of the args as text
		StringBuffer sb = new StringBuffer();
		for (int j = i + 1; j < args.length; j++) {
		    sb.append(args[j]);
		    sb.append(" ");
		}
		text = sb.toString();
		break;
	    } else if (args[i].equals("-file")) {
		if (++i < args.length) {
		    inFile = args[i];
		    freetts.setInputMode(InputMode.FILE);
		} else {
		    usage(voices);
		}
	    } else if (args[i].equals("-lines")) {
		if (++i < args.length) {
		    inFile = args[i];
		    freetts.setInputMode(InputMode.LINES);
		} else {
		    usage(voices);
		}
	    } else if (args[i].equals("-url")) {
		if (++i < args.length) {
		    inFile = args[i];
		    freetts.setInputMode(InputMode.URL);
		} else {
		    usage(voices);
		}
	    } else if (args[i].equals("-run")) {
		if (++i < args.length) {
		    voice.setRunTitle(args[i]);
		} else {
		    usage(voices);
		}
	    } else {
		System.out.println("Unknown option:" + args[i]);
	    }
	}

	if (dumpAudioTypes) {
	    dumpAudioTypes();
	}

	freetts.startup();

	if (freetts.getInputMode() == InputMode.TEXT) {
	    freetts.batchTextToSpeech(text);
	} else if (freetts.getInputMode() == InputMode.FILE) {
	    freetts.fileToSpeech(inFile);
	} else if (freetts.getInputMode() == InputMode.URL) {
	    freetts.urlToSpeech(inFile);
	} else if (freetts.getInputMode() == InputMode.LINES) {
	    freetts.lineToSpeech(inFile);
	} else {
	    interactiveMode(freetts);
        }

	if (freetts.getVoice().isMetrics() &&
	    !freetts.getSilentMode()) {
	    // [[[ TODO: get first byte timer times back in ]]]
	    // freetts.getFirstByteTimer().showTimes();
	    // freetts.getFirstSoundTimer().showTimes();
	}
	
	freetts.shutdown();
	System.exit(0);
    }
}