/* * 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 android.speech.tts; import android.speech.tts.TextToSpeechService.AudioOutputParams; import android.speech.tts.TextToSpeechService.UtteranceProgressDispatcher; import android.util.Log; /** * Speech synthesis request that plays the audio as it is received. */ class PlaybackSynthesisCallback extends AbstractSynthesisCallback { private static final String TAG = "PlaybackSynthesisRequest"; private static final boolean DBG = false; private static final int MIN_AUDIO_BUFFER_SIZE = 8192; private final AudioOutputParams mAudioParams; /** * Guards {@link #mAudioTrackHandler}, {@link #mItem} and {@link #mStopped}. */ private final Object mStateLock = new Object(); // Handler associated with a thread that plays back audio requests. private final AudioPlaybackHandler mAudioTrackHandler; // A request "token", which will be non null after start() has been called. private SynthesisPlaybackQueueItem mItem = null; private volatile boolean mDone = false; /** Status code of synthesis */ protected int mStatusCode; private final UtteranceProgressDispatcher mDispatcher; private final Object mCallerIdentity; private final AbstractEventLogger mLogger; PlaybackSynthesisCallback(AudioOutputParams audioParams, AudioPlaybackHandler audioTrackHandler, UtteranceProgressDispatcher dispatcher, Object callerIdentity, AbstractEventLogger logger, boolean clientIsUsingV2) { super(clientIsUsingV2); mAudioParams = audioParams; mAudioTrackHandler = audioTrackHandler; mDispatcher = dispatcher; mCallerIdentity = callerIdentity; mLogger = logger; mStatusCode = TextToSpeech.SUCCESS; } @Override void stop() { if (DBG) Log.d(TAG, "stop()"); SynthesisPlaybackQueueItem item; synchronized (mStateLock) { if (mDone) { return; } if (mStatusCode == TextToSpeech.STOPPED) { Log.w(TAG, "stop() called twice"); return; } item = mItem; mStatusCode = TextToSpeech.STOPPED; } if (item != null) { // This might result in the synthesis thread being woken up, at which // point it will write an additional buffer to the item - but we // won't worry about that because the audio playback queue will be cleared // soon after (see SynthHandler#stop(String). item.stop(TextToSpeech.STOPPED); } else { // This happens when stop() or error() were called before start() was. // In all other cases, mAudioTrackHandler.stop() will // result in onSynthesisDone being called, and we will // write data there. mLogger.onCompleted(TextToSpeech.STOPPED); mDispatcher.dispatchOnStop(); } } @Override public int getMaxBufferSize() { // The AudioTrack buffer will be at least MIN_AUDIO_BUFFER_SIZE, so that should always be // a safe buffer size to pass in. return MIN_AUDIO_BUFFER_SIZE; } @Override public boolean hasStarted() { synchronized (mStateLock) { return mItem != null; } } @Override public boolean hasFinished() { synchronized (mStateLock) { return mDone; } } @Override public int start(int sampleRateInHz, int audioFormat, int channelCount) { if (DBG) Log.d(TAG, "start(" + sampleRateInHz + "," + audioFormat + "," + channelCount + ")"); int channelConfig = BlockingAudioTrack.getChannelConfig(channelCount); synchronized (mStateLock) { if (channelConfig == 0) { Log.e(TAG, "Unsupported number of channels :" + channelCount); mStatusCode = TextToSpeech.ERROR_OUTPUT; return TextToSpeech.ERROR; } if (mStatusCode == TextToSpeech.STOPPED) { if (DBG) Log.d(TAG, "stop() called before start(), returning."); return errorCodeOnStop(); } if (mStatusCode != TextToSpeech.SUCCESS) { if (DBG) Log.d(TAG, "Error was raised"); return TextToSpeech.ERROR; } if (mItem != null) { Log.e(TAG, "Start called twice"); return TextToSpeech.ERROR; } SynthesisPlaybackQueueItem item = new SynthesisPlaybackQueueItem( mAudioParams, sampleRateInHz, audioFormat, channelCount, mDispatcher, mCallerIdentity, mLogger); mAudioTrackHandler.enqueue(item); mItem = item; } return TextToSpeech.SUCCESS; } @Override public int audioAvailable(byte[] buffer, int offset, int length) { if (DBG) Log.d(TAG, "audioAvailable(byte[" + buffer.length + "]," + offset + "," + length + ")"); if (length > getMaxBufferSize() || length <= 0) { throw new IllegalArgumentException("buffer is too large or of zero length (" + + length + " bytes)"); } SynthesisPlaybackQueueItem item = null; synchronized (mStateLock) { if (mItem == null) { mStatusCode = TextToSpeech.ERROR_OUTPUT; return TextToSpeech.ERROR; } if (mStatusCode != TextToSpeech.SUCCESS) { if (DBG) Log.d(TAG, "Error was raised"); return TextToSpeech.ERROR; } if (mStatusCode == TextToSpeech.STOPPED) { return errorCodeOnStop(); } item = mItem; } // Sigh, another copy. final byte[] bufferCopy = new byte[length]; System.arraycopy(buffer, offset, bufferCopy, 0, length); // Might block on mItem.this, if there are too many buffers waiting to // be consumed. try { item.put(bufferCopy); } catch (InterruptedException ie) { synchronized (mStateLock) { mStatusCode = TextToSpeech.ERROR_OUTPUT; return TextToSpeech.ERROR; } } mLogger.onEngineDataReceived(); return TextToSpeech.SUCCESS; } @Override public int done() { if (DBG) Log.d(TAG, "done()"); int statusCode = 0; SynthesisPlaybackQueueItem item = null; synchronized (mStateLock) { if (mDone) { Log.w(TAG, "Duplicate call to done()"); // Not an error that would prevent synthesis. Hence no // setStatusCode return TextToSpeech.ERROR; } if (mStatusCode == TextToSpeech.STOPPED) { if (DBG) Log.d(TAG, "Request has been aborted."); return errorCodeOnStop(); } mDone = true; if (mItem == null) { // .done() was called before .start. Treat it as successful synthesis // for a client, despite service bad implementation. Log.w(TAG, "done() was called before start() call"); if (mStatusCode == TextToSpeech.SUCCESS) { mDispatcher.dispatchOnSuccess(); } else { mDispatcher.dispatchOnError(mStatusCode); } mLogger.onEngineComplete(); return TextToSpeech.ERROR; } item = mItem; statusCode = mStatusCode; } // Signal done or error to item if (statusCode == TextToSpeech.SUCCESS) { item.done(); } else { item.stop(statusCode); } mLogger.onEngineComplete(); return TextToSpeech.SUCCESS; } @Override public void error() { error(TextToSpeech.ERROR_SYNTHESIS); } @Override public void error(int errorCode) { if (DBG) Log.d(TAG, "error() [will call stop]"); synchronized (mStateLock) { if (mDone) { return; } mStatusCode = errorCode; } } }