Delete android.speech.srec.* (b39dfe87) · Commits · e / os / android_frameworks_base

core/java/android/speech/srec/MicrophoneInputStream.java

deleted100644 → 0

+0 −110

Original line number	Original line	Diff line number	Diff line
	/---------------------------------------------------------------------------
	* MicrophoneInputStream.java *
	* *
	* Copyright 2007 Nuance Communciations, Inc. *
	* *
	* 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.srec;

	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.IllegalStateException;


	/**
	* PCM input stream from the microphone, 16 bits per sample.
	*/
	public final class MicrophoneInputStream extends InputStream {
	static {
	System.loadLibrary("srec_jni");
	}

	private final static String TAG = "MicrophoneInputStream";
	private long mAudioRecord = 0;
	private byte[] mOneByte = new byte[1];

	/**
	* MicrophoneInputStream constructor.
	* @param sampleRate sample rate of the microphone, typically 11025 or 8000.
	* @param fifoDepth depth of the real time fifo, measured in sampleRate clock ticks.
	* This determines how long an application may delay before losing data.
	*/
	public MicrophoneInputStream(int sampleRate, int fifoDepth) throws IOException {
	mAudioRecord = AudioRecordNew(sampleRate, fifoDepth);
	if (mAudioRecord == 0) throw new IOException("AudioRecord constructor failed - busy?");
	int status = AudioRecordStart(mAudioRecord);
	if (status != 0) {
	close();
	throw new IOException("AudioRecord start failed: " + status);
	}
	}

	@Override
	public int read() throws IOException {
	if (mAudioRecord == 0) throw new IllegalStateException("not open");
	int rtn = AudioRecordRead(mAudioRecord, mOneByte, 0, 1);
	return rtn == 1 ? ((int)mOneByte[0] & 0xff) : -1;
	}

	@Override
	public int read(byte[] b) throws IOException {
	if (mAudioRecord == 0) throw new IllegalStateException("not open");
	return AudioRecordRead(mAudioRecord, b, 0, b.length);
	}

	@Override
	public int read(byte[] b, int offset, int length) throws IOException {
	if (mAudioRecord == 0) throw new IllegalStateException("not open");
	// TODO: should we force all reads to be a multiple of the sample size?
	return AudioRecordRead(mAudioRecord, b, offset, length);
	}

	/**
	* Closes this stream.
	*/
	@Override
	public void close() throws IOException {
	if (mAudioRecord != 0) {
	try {
	AudioRecordStop(mAudioRecord);
	} finally {
	try {
	AudioRecordDelete(mAudioRecord);
	} finally {
	mAudioRecord = 0;
	}
	}
	}
	}

	@Override
	protected void finalize() throws Throwable {
	if (mAudioRecord != 0) {
	close();
	throw new IOException("someone forgot to close MicrophoneInputStream");
	}
	}

	//
	// AudioRecord JNI interface
	//
	private static native long AudioRecordNew(int sampleRate, int fifoDepth);
	private static native int AudioRecordStart(long audioRecord);
	private static native int AudioRecordRead(long audioRecord, byte[] b, int offset, int length) throws IOException;
	private static native void AudioRecordStop(long audioRecord) throws IOException;
	private static native void AudioRecordDelete(long audioRecord) throws IOException;
	}

core/java/android/speech/srec/Recognizer.java

deleted100644 → 0

+0 −716

File deleted.

Preview size limit exceeded, changes collapsed.

core/java/android/speech/srec/UlawEncoderInputStream.java

deleted100644 → 0

+0 −187

Original line number	Original line	Diff line number	Diff line
	/*
	* ---------------------------------------------------------------------------
	* UlawEncoderInputStream.java
	*
	* Copyright 2008 Nuance Communciations, Inc.
	*
	* 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.srec;

	import java.io.IOException;
	import java.io.InputStream;

	/**
	* InputStream which transforms 16 bit pcm data to ulaw data.
	*
	* Not yet ready to be supported, so
	* @hide
	*/
	public final class UlawEncoderInputStream extends InputStream {
	private final static String TAG = "UlawEncoderInputStream";

	private final static int MAX_ULAW = 8192;
	private final static int SCALE_BITS = 16;

	private InputStream mIn;

	private int mMax = 0;

	private final byte[] mBuf = new byte[1024];
	private int mBufCount = 0; // should be 0 or 1

	private final byte[] mOneByte = new byte[1];


	public static void encode(byte[] pcmBuf, int pcmOffset,
	byte[] ulawBuf, int ulawOffset, int length, int max) {

	// from 'ulaw' in wikipedia
	// +8191 to +8159 0x80
	// +8158 to +4063 in 16 intervals of 256 0x80 + interval number
	// +4062 to +2015 in 16 intervals of 128 0x90 + interval number
	// +2014 to +991 in 16 intervals of 64 0xA0 + interval number
	// +990 to +479 in 16 intervals of 32 0xB0 + interval number
	// +478 to +223 in 16 intervals of 16 0xC0 + interval number
	// +222 to +95 in 16 intervals of 8 0xD0 + interval number
	// +94 to +31 in 16 intervals of 4 0xE0 + interval number
	// +30 to +1 in 15 intervals of 2 0xF0 + interval number
	// 0 0xFF

	// -1 0x7F
	// -31 to -2 in 15 intervals of 2 0x70 + interval number
	// -95 to -32 in 16 intervals of 4 0x60 + interval number
	// -223 to -96 in 16 intervals of 8 0x50 + interval number
	// -479 to -224 in 16 intervals of 16 0x40 + interval number
	// -991 to -480 in 16 intervals of 32 0x30 + interval number
	// -2015 to -992 in 16 intervals of 64 0x20 + interval number
	// -4063 to -2016 in 16 intervals of 128 0x10 + interval number
	// -8159 to -4064 in 16 intervals of 256 0x00 + interval number
	// -8192 to -8160 0x00

	// set scale factors
	if (max <= 0) max = MAX_ULAW;

	int coef = MAX_ULAW * (1 << SCALE_BITS) / max;

	for (int i = 0; i < length; i++) {
	int pcm = (0xff & pcmBuf[pcmOffset++]) + (pcmBuf[pcmOffset++] << 8);
	pcm = (pcm * coef) >> SCALE_BITS;

	int ulaw;
	if (pcm >= 0) {
	ulaw = pcm <= 0 ? 0xff :
	pcm <= 30 ? 0xf0 + (( 30 - pcm) >> 1) :
	pcm <= 94 ? 0xe0 + (( 94 - pcm) >> 2) :
	pcm <= 222 ? 0xd0 + (( 222 - pcm) >> 3) :
	pcm <= 478 ? 0xc0 + (( 478 - pcm) >> 4) :
	pcm <= 990 ? 0xb0 + (( 990 - pcm) >> 5) :
	pcm <= 2014 ? 0xa0 + ((2014 - pcm) >> 6) :
	pcm <= 4062 ? 0x90 + ((4062 - pcm) >> 7) :
	pcm <= 8158 ? 0x80 + ((8158 - pcm) >> 8) :
	0x80;
	} else {
	ulaw = -1 <= pcm ? 0x7f :
	-31 <= pcm ? 0x70 + ((pcm - -31) >> 1) :
	-95 <= pcm ? 0x60 + ((pcm - -95) >> 2) :
	-223 <= pcm ? 0x50 + ((pcm - -223) >> 3) :
	-479 <= pcm ? 0x40 + ((pcm - -479) >> 4) :
	-991 <= pcm ? 0x30 + ((pcm - -991) >> 5) :
	-2015 <= pcm ? 0x20 + ((pcm - -2015) >> 6) :
	-4063 <= pcm ? 0x10 + ((pcm - -4063) >> 7) :
	-8159 <= pcm ? 0x00 + ((pcm - -8159) >> 8) :
	0x00;
	}
	ulawBuf[ulawOffset++] = (byte)ulaw;
	}
	}

	/**
	* Compute the maximum of the absolute value of the pcm samples.
	* The return value can be used to set ulaw encoder scaling.
	* @param pcmBuf array containing 16 bit pcm data.
	* @param offset offset of start of 16 bit pcm data.
	* @param length number of pcm samples (not number of input bytes)
	* @return maximum abs of pcm data values
	*/
	public static int maxAbsPcm(byte[] pcmBuf, int offset, int length) {
	int max = 0;
	for (int i = 0; i < length; i++) {
	int pcm = (0xff & pcmBuf[offset++]) + (pcmBuf[offset++] << 8);
	if (pcm < 0) pcm = -pcm;
	if (pcm > max) max = pcm;
	}
	return max;
	}

	/**
	* Create an InputStream which takes 16 bit pcm data and produces ulaw data.
	* @param in InputStream containing 16 bit pcm data.
	* @param max pcm value corresponding to maximum ulaw value.
	*/
	public UlawEncoderInputStream(InputStream in, int max) {
	mIn = in;
	mMax = max;
	}

	@Override
	public int read(byte[] buf, int offset, int length) throws IOException {
	if (mIn == null) throw new IllegalStateException("not open");

	// return at least one byte, but try to fill 'length'
	while (mBufCount < 2) {
	int n = mIn.read(mBuf, mBufCount, Math.min(length * 2, mBuf.length - mBufCount));
	if (n == -1) return -1;
	mBufCount += n;
	}

	// compand data
	int n = Math.min(mBufCount / 2, length);
	encode(mBuf, 0, buf, offset, n, mMax);

	// move data to bottom of mBuf
	mBufCount -= n * 2;
	for (int i = 0; i < mBufCount; i++) mBuf[i] = mBuf[i + n * 2];

	return n;
	}

	@Override
	public int read(byte[] buf) throws IOException {
	return read(buf, 0, buf.length);
	}

	@Override
	public int read() throws IOException {
	int n = read(mOneByte, 0, 1);
	if (n == -1) return -1;
	return 0xff & (int)mOneByte[0];
	}

	@Override
	public void close() throws IOException {
	if (mIn != null) {
	InputStream in = mIn;
	mIn = null;
	in.close();
	}
	}

	@Override
	public int available() throws IOException {
	return (mIn.available() + mBufCount) / 2;
	}
	}

core/java/android/speech/srec/WaveHeader.java

deleted100644 → 0

+0 −276

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2009 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.srec;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;

	/**
	* This class represents the header of a WAVE format audio file, which usually
	* have a .wav suffix. The following integer valued fields are contained:
	* <ul>
	* <li> format - usually PCM, ALAW or ULAW.
	* <li> numChannels - 1 for mono, 2 for stereo.
	* <li> sampleRate - usually 8000, 11025, 16000, 22050, or 44100 hz.
	* <li> bitsPerSample - usually 16 for PCM, 8 for ALAW, or 8 for ULAW.
	* <li> numBytes - size of audio data after this header, in bytes.
	* </ul>
	*
	* Not yet ready to be supported, so
	* @hide
	*/
	public class WaveHeader {

	// follows WAVE format in http://ccrma.stanford.edu/courses/422/projects/WaveFormat

	private static final String TAG = "WaveHeader";

	private static final int HEADER_LENGTH = 44;

	/** Indicates PCM format. */
	public static final short FORMAT_PCM = 1;
	/** Indicates ALAW format. */
	public static final short FORMAT_ALAW = 6;
	/** Indicates ULAW format. */
	public static final short FORMAT_ULAW = 7;

	private short mFormat;
	private short mNumChannels;
	private int mSampleRate;
	private short mBitsPerSample;
	private int mNumBytes;

	/**
	* Construct a WaveHeader, with all fields defaulting to zero.
	*/
	public WaveHeader() {
	}

	/**
	* Construct a WaveHeader, with fields initialized.
	* @param format format of audio data,
	* one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
	* @param numChannels 1 for mono, 2 for stereo.
	* @param sampleRate typically 8000, 11025, 16000, 22050, or 44100 hz.
	* @param bitsPerSample usually 16 for PCM, 8 for ULAW or 8 for ALAW.
	* @param numBytes size of audio data after this header, in bytes.
	*/
	public WaveHeader(short format, short numChannels, int sampleRate, short bitsPerSample, int numBytes) {
	mFormat = format;
	mSampleRate = sampleRate;
	mNumChannels = numChannels;
	mBitsPerSample = bitsPerSample;
	mNumBytes = numBytes;
	}

	/**
	* Get the format field.
	* @return format field,
	* one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
	*/
	public short getFormat() {
	return mFormat;
	}

	/**
	* Set the format field.
	* @param format
	* one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
	* @return reference to this WaveHeader instance.
	*/
	public WaveHeader setFormat(short format) {
	mFormat = format;
	return this;
	}

	/**
	* Get the number of channels.
	* @return number of channels, 1 for mono, 2 for stereo.
	*/
	public short getNumChannels() {
	return mNumChannels;
	}

	/**
	* Set the number of channels.
	* @param numChannels 1 for mono, 2 for stereo.
	* @return reference to this WaveHeader instance.
	*/
	public WaveHeader setNumChannels(short numChannels) {
	mNumChannels = numChannels;
	return this;
	}

	/**
	* Get the sample rate.
	* @return sample rate, typically 8000, 11025, 16000, 22050, or 44100 hz.
	*/
	public int getSampleRate() {
	return mSampleRate;
	}

	/**
	* Set the sample rate.
	* @param sampleRate sample rate, typically 8000, 11025, 16000, 22050, or 44100 hz.
	* @return reference to this WaveHeader instance.
	*/
	public WaveHeader setSampleRate(int sampleRate) {
	mSampleRate = sampleRate;
	return this;
	}

	/**
	* Get the number of bits per sample.
	* @return number of bits per sample,
	* usually 16 for PCM, 8 for ULAW or 8 for ALAW.
	*/
	public short getBitsPerSample() {
	return mBitsPerSample;
	}

	/**
	* Set the number of bits per sample.
	* @param bitsPerSample number of bits per sample,
	* usually 16 for PCM, 8 for ULAW or 8 for ALAW.
	* @return reference to this WaveHeader instance.
	*/
	public WaveHeader setBitsPerSample(short bitsPerSample) {
	mBitsPerSample = bitsPerSample;
	return this;
	}

	/**
	* Get the size of audio data after this header, in bytes.
	* @return size of audio data after this header, in bytes.
	*/
	public int getNumBytes() {
	return mNumBytes;
	}

	/**
	* Set the size of audio data after this header, in bytes.
	* @param numBytes size of audio data after this header, in bytes.
	* @return reference to this WaveHeader instance.
	*/
	public WaveHeader setNumBytes(int numBytes) {
	mNumBytes = numBytes;
	return this;
	}

	/**
	* Read and initialize a WaveHeader.
	* @param in {@link java.io.InputStream} to read from.
	* @return number of bytes consumed.
	* @throws IOException
	*/
	public int read(InputStream in) throws IOException {
	/* RIFF header */
	readId(in, "RIFF");
	int numBytes = readInt(in) - 36;
	readId(in, "WAVE");

	/* fmt chunk */
	readId(in, "fmt ");
	if (16 != readInt(in)) throw new IOException("fmt chunk length not 16");
	mFormat = readShort(in);
	mNumChannels = readShort(in);
	mSampleRate = readInt(in);
	int byteRate = readInt(in);
	short blockAlign = readShort(in);
	mBitsPerSample = readShort(in);
	if (byteRate != mNumChannels * mSampleRate * mBitsPerSample / 8) {
	throw new IOException("fmt.ByteRate field inconsistent");
	}
	if (blockAlign != mNumChannels * mBitsPerSample / 8) {
	throw new IOException("fmt.BlockAlign field inconsistent");
	}

	/* data chunk */
	readId(in, "data");
	mNumBytes = readInt(in);

	return HEADER_LENGTH;
	}

	private static void readId(InputStream in, String id) throws IOException {
	for (int i = 0; i < id.length(); i++) {
	if (id.charAt(i) != in.read()) throw new IOException( id + " tag not present");
	}
	}

	private static int readInt(InputStream in) throws IOException {
	return in.read() \| (in.read() << 8) \| (in.read() << 16) \| (in.read() << 24);
	}

	private static short readShort(InputStream in) throws IOException {
	return (short)(in.read() \| (in.read() << 8));
	}

	/**
	* Write a WAVE file header.
	* @param out {@link java.io.OutputStream} to receive the header.
	* @return number of bytes written.
	* @throws IOException
	*/
	public int write(OutputStream out) throws IOException {
	/* RIFF header */
	writeId(out, "RIFF");
	writeInt(out, 36 + mNumBytes);
	writeId(out, "WAVE");

	/* fmt chunk */
	writeId(out, "fmt ");
	writeInt(out, 16);
	writeShort(out, mFormat);
	writeShort(out, mNumChannels);
	writeInt(out, mSampleRate);
	writeInt(out, mNumChannels * mSampleRate * mBitsPerSample / 8);
	writeShort(out, (short)(mNumChannels * mBitsPerSample / 8));
	writeShort(out, mBitsPerSample);

	/* data chunk */
	writeId(out, "data");
	writeInt(out, mNumBytes);

	return HEADER_LENGTH;
	}

	private static void writeId(OutputStream out, String id) throws IOException {
	for (int i = 0; i < id.length(); i++) out.write(id.charAt(i));
	}

	private static void writeInt(OutputStream out, int val) throws IOException {
	out.write(val >> 0);
	out.write(val >> 8);
	out.write(val >> 16);
	out.write(val >> 24);
	}

	private static void writeShort(OutputStream out, short val) throws IOException {
	out.write(val >> 0);
	out.write(val >> 8);
	}

	@Override
	public String toString() {
	return String.format(
	"WaveHeader format=%d numChannels=%d sampleRate=%d bitsPerSample=%d numBytes=%d",
	mFormat, mNumChannels, mSampleRate, mBitsPerSample, mNumBytes);
	}

	}

core/java/android/speech/srec/package.html

deleted100644 → 0

+0 −6

Original line number	Original line	Diff line number	Diff line
	<HTML>
	<BODY>
	Simple, synchronous SREC speech recognition API.
	@hide
	</BODY>
	</HTML>