diff options
Diffstat (limited to 'pico/compat/src')
-rwxr-xr-x | pico/compat/src/com/android/tts/compat/CompatTtsService.java | 145 | ||||
-rwxr-xr-x | pico/compat/src/com/android/tts/compat/SynthProxy.java | 183 |
2 files changed, 328 insertions, 0 deletions
diff --git a/pico/compat/src/com/android/tts/compat/CompatTtsService.java b/pico/compat/src/com/android/tts/compat/CompatTtsService.java new file mode 100755 index 0000000..1ec7ebf --- /dev/null +++ b/pico/compat/src/com/android/tts/compat/CompatTtsService.java @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.android.tts.compat; + +import android.database.Cursor; +import android.net.Uri; +import android.speech.tts.SynthesisRequest; +import android.speech.tts.TextToSpeech; +import android.speech.tts.TextToSpeechService; +import android.util.Log; + +import java.io.File; + +public abstract class CompatTtsService extends TextToSpeechService { + + private static final boolean DBG = false; + private static final String TAG = "CompatTtsService"; + + private SynthProxy mNativeSynth = null; + + protected abstract String getSoFilename(); + + @Override + public void onCreate() { + if (DBG) Log.d(TAG, "onCreate()"); + super.onCreate(); + + String soFilename = getSoFilename(); + + File f = new File(soFilename); + if (!f.exists()) { + Log.e(TAG, "Invalid TTS Binary: " + soFilename); + return; + } + + if (mNativeSynth != null) { + mNativeSynth.stopSync(); + mNativeSynth.shutdown(); + mNativeSynth = null; + } + + // Load the engineConfig from the plugin if it has any special configuration + // to be loaded. By convention, if an engine wants the TTS framework to pass + // in any configuration, it must put it into its content provider which has the URI: + // content://<packageName>.providers.SettingsProvider + // That content provider must provide a Cursor which returns the String that + // is to be passed back to the native .so file for the plugin when getString(0) is + // called on it. + // Note that the TTS framework does not care what this String data is: it is something + // that comes from the engine plugin and is consumed only by the engine plugin itself. + String engineConfig = ""; + Cursor c = getContentResolver().query(Uri.parse("content://" + getPackageName() + + ".providers.SettingsProvider"), null, null, null, null); + if (c != null){ + c.moveToFirst(); + engineConfig = c.getString(0); + c.close(); + } + mNativeSynth = new SynthProxy(soFilename, engineConfig); + } + + @Override + public void onDestroy() { + if (DBG) Log.d(TAG, "onDestroy()"); + super.onDestroy(); + + if (mNativeSynth != null) { + mNativeSynth.shutdown(); + } + mNativeSynth = null; + } + + @Override + protected String[] onGetLanguage() { + if (mNativeSynth == null) return null; + return mNativeSynth.getLanguage(); + } + + @Override + protected int onIsLanguageAvailable(String lang, String country, String variant) { + if (DBG) Log.d(TAG, "onIsLanguageAvailable(" + lang + "," + country + "," + variant + ")"); + if (mNativeSynth == null) return TextToSpeech.ERROR; + return mNativeSynth.isLanguageAvailable(lang, country, variant); + } + + @Override + protected int onLoadLanguage(String lang, String country, String variant) { + if (DBG) Log.d(TAG, "onLoadLanguage(" + lang + "," + country + "," + variant + ")"); + int result = onIsLanguageAvailable(lang, country, variant); + // TODO: actually load language + return result; + } + + @Override + protected int onSynthesizeText(SynthesisRequest request) { + if (mNativeSynth == null) return TextToSpeech.ERROR; + + // Set language + String lang = request.getLanguage(); + String country = request.getCountry(); + String variant = request.getVariant(); + if (mNativeSynth.setLanguage(lang, country, variant) != TextToSpeech.SUCCESS) { + Log.e(TAG, "setLanguage(" + lang + "," + country + "," + variant + ") failed"); + return TextToSpeech.ERROR; + } + + // Set speech rate + int speechRate = request.getSpeechRate(); + if (mNativeSynth.setSpeechRate(speechRate) != TextToSpeech.SUCCESS) { + Log.e(TAG, "setSpeechRate(" + speechRate + ") failed"); + return TextToSpeech.ERROR; + } + + // Set speech + int pitch = request.getPitch(); + if (mNativeSynth.setPitch(pitch) != TextToSpeech.SUCCESS) { + Log.e(TAG, "setPitch(" + pitch + ") failed"); + return TextToSpeech.ERROR; + } + + // Synthesize + return mNativeSynth.speak(request); + } + + @Override + protected void onStop() { + if (DBG) Log.d(TAG, "onStop()"); + if (mNativeSynth == null) return; + mNativeSynth.stop(); + } + +} diff --git a/pico/compat/src/com/android/tts/compat/SynthProxy.java b/pico/compat/src/com/android/tts/compat/SynthProxy.java new file mode 100755 index 0000000..68d0d92 --- /dev/null +++ b/pico/compat/src/com/android/tts/compat/SynthProxy.java @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.android.tts.compat; + +import android.speech.tts.SynthesisRequest; +import android.util.Log; + +/** + * The SpeechSynthesis class provides a high-level api to create and play + * synthesized speech. This class is used internally to talk to a native + * TTS library that implements the interface defined in + * frameworks/base/include/tts/TtsEngine.h + * + */ +public class SynthProxy { + + static { + System.loadLibrary("ttscompat"); + } + + private final static String TAG = "SynthProxy"; + + // Default parameters of a filter to be applied when using the Pico engine. + // Such a huge filter gain is justified by how much energy in the low frequencies is "wasted" at + // the output of the synthesis. The low shelving filter removes it, leaving room for + // amplification. + private final static float PICO_FILTER_GAIN = 5.0f; // linear gain + private final static float PICO_FILTER_LOWSHELF_ATTENUATION = -18.0f; // in dB + private final static float PICO_FILTER_TRANSITION_FREQ = 1100.0f; // in Hz + private final static float PICO_FILTER_SHELF_SLOPE = 1.0f; // Q + + private int mJniData = 0; + + /** + * Constructor; pass the location of the native TTS .so to use. + */ + public SynthProxy(String nativeSoLib, String engineConfig) { + boolean applyFilter = shouldApplyAudioFilter(nativeSoLib); + Log.v(TAG, "About to load "+ nativeSoLib + ", applyFilter=" + applyFilter); + mJniData = native_setup(nativeSoLib, engineConfig); + if (mJniData == 0) { + throw new RuntimeException("Failed to load " + nativeSoLib); + } + native_setLowShelf(applyFilter, PICO_FILTER_GAIN, PICO_FILTER_LOWSHELF_ATTENUATION, + PICO_FILTER_TRANSITION_FREQ, PICO_FILTER_SHELF_SLOPE); + } + + // HACK: Apply audio filter if the engine is pico + private boolean shouldApplyAudioFilter(String nativeSoLib) { + return nativeSoLib.toLowerCase().contains("pico"); + } + + /** + * Stops and clears the AudioTrack. + */ + public int stop() { + return native_stop(mJniData); + } + + /** + * Synchronous stop of the synthesizer. This method returns when the synth + * has completed the stop procedure and doesn't use any of the resources it + * was using while synthesizing. + * + * @return {@link android.speech.tts.TextToSpeech#SUCCESS} or + * {@link android.speech.tts.TextToSpeech#ERROR} + */ + public int stopSync() { + return native_stopSync(mJniData); + } + + public int speak(SynthesisRequest request) { + return native_speak(mJniData, request.getText(), request); + } + + /** + * Queries for language support. + * Return codes are defined in android.speech.tts.TextToSpeech + */ + public int isLanguageAvailable(String language, String country, String variant) { + return native_isLanguageAvailable(mJniData, language, country, variant); + } + + /** + * Updates the engine configuration. + */ + public int setConfig(String engineConfig) { + return native_setProperty(mJniData, "engineConfig", engineConfig); + } + + /** + * Sets the language. + */ + public int setLanguage(String language, String country, String variant) { + return native_setLanguage(mJniData, language, country, variant); + } + + /** + * Loads the language: it's not set, but prepared for use later. + */ + public int loadLanguage(String language, String country, String variant) { + return native_loadLanguage(mJniData, language, country, variant); + } + + /** + * Sets the speech rate. + */ + public final int setSpeechRate(int speechRate) { + return native_setProperty(mJniData, "rate", String.valueOf(speechRate)); + } + + /** + * Sets the pitch of the synthesized voice. + */ + public final int setPitch(int pitch) { + return native_setProperty(mJniData, "pitch", String.valueOf(pitch)); + } + + /** + * Returns the currently set language, country and variant information. + */ + public String[] getLanguage() { + return native_getLanguage(mJniData); + } + + /** + * Shuts down the native synthesizer. + */ + public void shutdown() { + native_shutdown(mJniData); + } + + @Override + protected void finalize() { + if (mJniData != 0) { + Log.w(TAG, "SynthProxy finalized without being shutdown"); + native_finalize(mJniData); + mJniData = 0; + } + } + + private native final int native_setup(String nativeSoLib, String engineConfig); + + private native final int native_setLowShelf(boolean applyFilter, float filterGain, + float attenuationInDb, float freqInHz, float slope); + + private native final void native_finalize(int jniData); + + private native final int native_stop(int jniData); + + private native final int native_stopSync(int jniData); + + private native final int native_speak(int jniData, String text, SynthesisRequest request); + + private native final int native_isLanguageAvailable(int jniData, String language, + String country, String variant); + + private native final int native_setLanguage(int jniData, String language, String country, + String variant); + + private native final int native_loadLanguage(int jniData, String language, String country, + String variant); + + private native final int native_setProperty(int jniData, String name, String value); + + private native final String[] native_getLanguage(int jniData); + + private native final void native_shutdown(int jniData); + +} |