FileDocCategorySizeDatePackage
WaveHeader.javaAPI DocAndroid 1.5 API8731Wed May 06 22:41:56 BST 2009android.speech.srec

WaveHeader

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

Fields Summary
private static final String
TAG
private static final int
HEADER_LENGTH
public static final short
FORMAT_PCM
Indicates PCM format.
public static final short
FORMAT_ALAW
Indicates ALAW format.
public static final short
FORMAT_ULAW
Indicates ULAW format.
private short
mFormat
private short
mNumChannels
private int
mSampleRate
private short
mBitsPerSample
private int
mNumBytes
Constructors Summary
public WaveHeader()
Construct a WaveHeader, with all fields defaulting to zero.

    
                  
      
    
public WaveHeader(short format, short numChannels, int sampleRate, short bitsPerSample, int numBytes)
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.

        mFormat = format;
        mSampleRate = sampleRate;
        mNumChannels = numChannels;
        mBitsPerSample = bitsPerSample;
        mNumBytes = numBytes;
    
Methods Summary
public shortgetBitsPerSample()
Get the number of bits per sample.

return
number of bits per sample, usually 16 for PCM, 8 for ULAW or 8 for ALAW.

        return mBitsPerSample;
    
public shortgetFormat()
Get the format field.

return
format field, one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.

        return mFormat;
    
public intgetNumBytes()
Get the size of audio data after this header, in bytes.

return
size of audio data after this header, in bytes.

        return mNumBytes;
    
public shortgetNumChannels()
Get the number of channels.

return
number of channels, 1 for mono, 2 for stereo.

        return mNumChannels;
    
public intgetSampleRate()
Get the sample rate.

return
sample rate, typically 8000, 11025, 16000, 22050, or 44100 hz.

        return mSampleRate;
    
public intread(java.io.InputStream in)
Read and initialize a WaveHeader.

param
in {@link java.io.InputStream} to read from.
return
number of bytes consumed.
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 voidreadId(java.io.InputStream in, java.lang.String id)

        for (int i = 0; i < id.length(); i++) {
            if (id.charAt(i) != in.read()) throw new IOException( id + " tag not present");
        }
    
private static intreadInt(java.io.InputStream in)

        return in.read() | (in.read() << 8) | (in.read() << 16) | (in.read() << 24);
    
private static shortreadShort(java.io.InputStream in)

        return (short)(in.read() | (in.read() << 8));
    
public android.speech.srec.WaveHeadersetBitsPerSample(short bitsPerSample)
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.

        mBitsPerSample = bitsPerSample;
        return this;
    
public android.speech.srec.WaveHeadersetFormat(short format)
Set the format field.

param
format one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
return
reference to this WaveHeader instance.

        mFormat = format;
        return this;
    
public android.speech.srec.WaveHeadersetNumBytes(int numBytes)
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.

        mNumBytes = numBytes;
        return this;
    
public android.speech.srec.WaveHeadersetNumChannels(short numChannels)
Set the number of channels.

param
numChannels 1 for mono, 2 for stereo.
return
reference to this WaveHeader instance.

        mNumChannels = numChannels;
        return this;
    
public android.speech.srec.WaveHeadersetSampleRate(int sampleRate)
Set the sample rate.

param
sampleRate sample rate, typically 8000, 11025, 16000, 22050, or 44100 hz.
return
reference to this WaveHeader instance.

        mSampleRate = sampleRate;
        return this;
    
public java.lang.StringtoString()

        return String.format(
                "WaveHeader format=%d numChannels=%d sampleRate=%d bitsPerSample=%d numBytes=%d",
                mFormat, mNumChannels, mSampleRate, mBitsPerSample, mNumBytes);
    
public intwrite(java.io.OutputStream out)
Write a WAVE file header.

param
out {@link java.io.OutputStream} to receive the header.
return
number of bytes written.
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 voidwriteId(java.io.OutputStream out, java.lang.String id)

        for (int i = 0; i < id.length(); i++) out.write(id.charAt(i));
    
private static voidwriteInt(java.io.OutputStream out, int val)

        out.write(val >> 0);
        out.write(val >> 8);
        out.write(val >> 16);
        out.write(val >> 24);
    
private static voidwriteShort(java.io.OutputStream out, short val)

        out.write(val >> 0);
        out.write(val >> 8);