package android.speech.tts;
import android.media.AudioFormat;
import android.media.AudioTrack;
import android.speech.tts.TextToSpeechService.AudioOutputParams;
import android.util.Log;
class BlockingAudioTrack {
private static final String TAG = "TTS.BlockingAudioTrack";
private static final boolean DBG = false;
private static final long MIN_SLEEP_TIME_MS = 20;
private static final long MAX_SLEEP_TIME_MS = 2500;
private static final long MAX_PROGRESS_WAIT_MS = MAX_SLEEP_TIME_MS;
private static final int MIN_AUDIO_BUFFER_SIZE = 8192;
private final AudioOutputParams mAudioParams;
private final int mSampleRateInHz;
private final int mAudioFormat;
private final int mChannelCount;
private final int mBytesPerFrame;
private boolean mIsShortUtterance;
private int mAudioBufferSize;
private int mBytesWritten = 0;
private Object mAudioTrackLock = new Object();
private AudioTrack mAudioTrack;
private volatile boolean mStopped;
private int mSessionId;
BlockingAudioTrack(AudioOutputParams audioParams, int sampleRate,
int audioFormat, int channelCount) {
mAudioParams = audioParams;
mSampleRateInHz = sampleRate;
mAudioFormat = audioFormat;
mChannelCount = channelCount;
mBytesPerFrame = AudioFormat.getBytesPerSample(mAudioFormat) * mChannelCount;
mIsShortUtterance = false;
mAudioBufferSize = 0;
mBytesWritten = 0;
mAudioTrack = null;
mStopped = false;
}
public boolean init() {
AudioTrack track = createStreamingAudioTrack();
synchronized (mAudioTrackLock) {
mAudioTrack = track;
}
if (track == null) {
return false;
} else {
return true;
}
}
public void stop() {
synchronized (mAudioTrackLock) {
if (mAudioTrack != null) {
mAudioTrack.stop();
}
mStopped = true;
}
}
public int write(byte[] data) {
AudioTrack track = null;
synchronized (mAudioTrackLock) {
track = mAudioTrack;
}
if (track == null || mStopped) {
return -1;
}
final int bytesWritten = writeToAudioTrack(track, data);
mBytesWritten += bytesWritten;
return bytesWritten;
}
public void waitAndRelease() {
AudioTrack track = null;
synchronized (mAudioTrackLock) {
track = mAudioTrack;
}
if (track == null) {
if (DBG) Log.d(TAG, "Audio track null [duplicate call to waitAndRelease ?]");
return;
}
if (mBytesWritten < mAudioBufferSize && !mStopped) {
if (DBG) {
Log.d(TAG, "Stopping audio track to flush audio, state was : " +
track.getPlayState() + ",stopped= " + mStopped);
}
mIsShortUtterance = true;
track.stop();
}
if (!mStopped) {
if (DBG) Log.d(TAG, "Waiting for audio track to complete : " + mAudioTrack.hashCode());
blockUntilDone(mAudioTrack);
}
if (DBG) Log.d(TAG, "Releasing audio track [" + track.hashCode() + "]");
synchronized (mAudioTrackLock) {
mAudioTrack = null;
}
track.release();
}
static int getChannelConfig(int channelCount) {
if (channelCount == 1) {
return AudioFormat.CHANNEL_OUT_MONO;
} else if (channelCount == 2){
return AudioFormat.CHANNEL_OUT_STEREO;
}
return 0;
}
long getAudioLengthMs(int numBytes) {
final int unconsumedFrames = numBytes / mBytesPerFrame;
final long estimatedTimeMs = unconsumedFrames * 1000 / mSampleRateInHz;
return estimatedTimeMs;
}
private static int writeToAudioTrack(AudioTrack audioTrack, byte[] bytes) {
if (audioTrack.getPlayState() != AudioTrack.PLAYSTATE_PLAYING) {
if (DBG) Log.d(TAG, "AudioTrack not playing, restarting : " + audioTrack.hashCode());
audioTrack.play();
}
int count = 0;
while (count < bytes.length) {
int written = audioTrack.write(bytes, count, bytes.length);
if (written <= 0) {
break;
}
count += written;
}
return count;
}
private AudioTrack createStreamingAudioTrack() {
final int channelConfig = getChannelConfig(mChannelCount);
int minBufferSizeInBytes
= AudioTrack.getMinBufferSize(mSampleRateInHz, channelConfig, mAudioFormat);
int bufferSizeInBytes = Math.max(MIN_AUDIO_BUFFER_SIZE, minBufferSizeInBytes);
AudioFormat audioFormat = (new AudioFormat.Builder())
.setChannelMask(channelConfig)
.setEncoding(mAudioFormat)
.setSampleRate(mSampleRateInHz).build();
AudioTrack audioTrack = new AudioTrack(mAudioParams.mAudioAttributes,
audioFormat, bufferSizeInBytes, AudioTrack.MODE_STREAM,
mAudioParams.mSessionId);
if (audioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
Log.w(TAG, "Unable to create audio track.");
audioTrack.release();
return null;
}
mAudioBufferSize = bufferSizeInBytes;
setupVolume(audioTrack, mAudioParams.mVolume, mAudioParams.mPan);
return audioTrack;
}
private void blockUntilDone(AudioTrack audioTrack) {
if (mBytesWritten <= 0) {
return;
}
if (mIsShortUtterance) {
blockUntilEstimatedCompletion();
} else {
blockUntilCompletion(audioTrack);
}
}
private void blockUntilEstimatedCompletion() {
final int lengthInFrames = mBytesWritten / mBytesPerFrame;
final long estimatedTimeMs = (lengthInFrames * 1000 / mSampleRateInHz);
if (DBG) Log.d(TAG, "About to sleep for: " + estimatedTimeMs + "ms for a short utterance");
try {
Thread.sleep(estimatedTimeMs);
} catch (InterruptedException ie) {
}
}
private void blockUntilCompletion(AudioTrack audioTrack) {
final int lengthInFrames = mBytesWritten / mBytesPerFrame;
int previousPosition = -1;
int currentPosition = 0;
long blockedTimeMs = 0;
while ((currentPosition = audioTrack.getPlaybackHeadPosition()) < lengthInFrames &&
audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING && !mStopped) {
final long estimatedTimeMs = ((lengthInFrames - currentPosition) * 1000) /
audioTrack.getSampleRate();
final long sleepTimeMs = clip(estimatedTimeMs, MIN_SLEEP_TIME_MS, MAX_SLEEP_TIME_MS);
if (currentPosition == previousPosition) {
blockedTimeMs += sleepTimeMs;
if (blockedTimeMs > MAX_PROGRESS_WAIT_MS) {
Log.w(TAG, "Waited unsuccessfully for " + MAX_PROGRESS_WAIT_MS + "ms " +
"for AudioTrack to make progress, Aborting");
break;
}
} else {
blockedTimeMs = 0;
}
previousPosition = currentPosition;
if (DBG) {
Log.d(TAG, "About to sleep for : " + sleepTimeMs + " ms," +
" Playback position : " + currentPosition + ", Length in frames : "
+ lengthInFrames);
}
try {
Thread.sleep(sleepTimeMs);
} catch (InterruptedException ie) {
break;
}
}
}
private static void setupVolume(AudioTrack audioTrack, float volume, float pan) {
final float vol = clip(volume, 0.0f, 1.0f);
final float panning = clip(pan, -1.0f, 1.0f);
float volLeft = vol;
float volRight = vol;
if (panning > 0.0f) {
volLeft *= (1.0f - panning);
} else if (panning < 0.0f) {
volRight *= (1.0f + panning);
}
if (DBG) Log.d(TAG, "volLeft=" + volLeft + ",volRight=" + volRight);
if (audioTrack.setStereoVolume(volLeft, volRight) != AudioTrack.SUCCESS) {
Log.e(TAG, "Failed to set volume");
}
}
private static final long clip(long value, long min, long max) {
return value < min ? min : (value < max ? value : max);
}
private static final float clip(float value, float min, float max) {
return value < min ? min : (value < max ? value : max);
}
public void setPlaybackPositionUpdateListener(
AudioTrack.OnPlaybackPositionUpdateListener listener) {
synchronized (mAudioTrackLock) {
if (mAudioTrack != null) {
mAudioTrack.setPlaybackPositionUpdateListener(listener);
}
}
}
public void setNotificationMarkerPosition(int frames) {
synchronized (mAudioTrackLock) {
if (mAudioTrack != null) {
mAudioTrack.setNotificationMarkerPosition(frames);
}
}
}
}