* Reconstruct a wave from a wave, sts, and lpc     *     * @param sampleRate the sample rate to use     * @param lpc lpc     * @param lpc_min minimum lpc value     * @param lpc_range range of lpc values     */    public Wave(int sampleRate, STS[] stsData, LPC lpc, float lpc_min,            float lpc_range) {        // set number of samples and sample rate        numSamples = 0;        for (int i = 0; i < lpc.getNumFrames(); i++) {            numSamples += stsData[i].getNumSamples();        }        samples = new short[numSamples];        this.sampleRate = sampleRate;        int start = 0;        int end;        int[] lpcResTimes = new int[lpc.getNumFrames()];        int[] lpcResSizes = new int[lpc.getNumFrames()];        short[] lpcResResidual = new short[numSamples];        int[][] lpcResFrames = new int[lpc.getNumFrames()][];        int lpcResNumChannels = lpc.getNumChannels() - 1;        // load initial data        for (int i = 0; i < lpc.getNumFrames(); i++) {            lpcResTimes[i] = (int) (lpc.getTime(i) * sampleRate);            lpcResFrames[i] = stsData[i].getFrame();            end = start + stsData[i].getNumSamples();            lpcResSizes[i] = stsData[i].getNumSamples();            start = end;        }        for (int r = 0, i = 0; i < lpc.getNumFrames(); i++) {            for (int j = 0; j < stsData[i].getNumSamples(); j++, r++) {                lpcResResidual[r] = stsData[i].getResidual(j);            }        }        float[] lpcCoefs = new float[lpcResNumChannels];        float[] outbuf = new float[lpcResNumChannels + 1];        int ci, cr;        //float pp = 0;  // the C code uses this unnecessarily (for now)        for (int r = 0, o = lpcResNumChannels, i = 0; i <                lpc.getNumFrames(); i++) {            // residual_fold is hard-coded to 1.            int pm_size_samps = lpcResSizes[i];//  * residual_fold;            // Unpack the LPC coefficients            for (int k = 0; k < lpcResNumChannels; k++) {                lpcCoefs[k] = (float)                    ((((double) lpcResFrames[i][k])/65535.0) * lpc_range)                    + lpc_min;            }            // resynthesize the signal            for (int j = 0; j < pm_size_samps; j++, r++) {                outbuf[o] = (float)                    Utility.ulawToShort(lpcResResidual[r/* /residual_fold */]);                cr = (o == 0 ? lpcResNumChannels : o-1);                for (ci = 0; ci < lpcResNumChannels; ci++) {                        outbuf[o] += lpcCoefs[ci] * outbuf[cr];                        cr = (cr == 0 ? lpcResNumChannels : cr - 1);                }                samples[r] = (short) (outbuf[o]                    /* + pp * lpcres->post_emphasis)*/); // post_emphasis = 0                // pp = outbuf[o];                o = (o == lpcResNumChannels ? 0 : o+1);            }        }    }    /**     * Compare two waves and output how close the two are.     * Useful for checking the general accuracy of find sts.     *     * <p>     * Output may not exactly match that of flite find_sts     * on Intel platforms due to discrepencies in the way that     * Intel Pentiums perform floating point computations.     * </p>     *     * @param the wave to compare this wave against     *     */    public void compare(Wave wave2) {        if (numSamples > wave2.numSamples) {            wave2.compare(this);        } else {            double r = 0;            int i = 0;            for (i = 0; i < this.numSamples; i++) {                r += (double)((float)this.samples[i] - (float)wave2.samples[i])                    *(double)((float)this.samples[i] - (float)wave2.samples[i]);            }            r /= this.numSamples;            System.out.println("a/b diff " + Double.toString(StrictMath.sqrt(r)));        }    }    /**     * Make sure that a string of characters appear next in the file     *     * @param dis DataInputStream to read in     * @param chars a String containing the ascii characters you     *          want the <code>dis</code> to contain.     *     * @return <code>true</code> if <code>chars</code> appears next     *          in <code>dis</code>, else <code>false</code>     * @throws on ill-formatted input (end of file, for example)     */    private boolean checkChars(DataInputStream dis, String chars)            throws IOException {        char[] carray = chars.toCharArray();        for (int i = 0; i < carray.length; i++) {            if ((char) dis.readByte() != carray[i]) {                return false;            }        }        return true;    }    /**     * Get the sample rate for this wave     *     * @return sample rate     */    public int getSampleRate() {        return sampleRate;    }    /**     * Get the number of samples for this wave     *     * @return number of samples     */    public int getNumSamples() {        return numSamples;    }    /* Get the sample data of this wave     *     * @return samples     */    public short[] getSamples() {        return samples;    }}/** * The sts data */class STS {    private int[] frame;    private int numSamples;    private short[] residual;    /**     * Create an empty STS     */    public STS() {    }    /**     * Create an sts with the given data     *     * @param frame frame for this sts     * @param numSamples number of samples this sts will contain     * @param residual the residual for this sts     *      */    public STS(int[] frame, int numSamples, short[] residual) {        this.frame = new int[frame.length];        System.arraycopy(frame, 0, this.frame, 0, frame.length);        this.numSamples = numSamples;        this.residual = new short[residual.length];        System.arraycopy(residual, 0, this.residual, 0, residual.length);    }    /**     * Get the number of samples associated with this sts     *     * @return the number of samples for this sts     */    public int getNumSamples() {        return numSamples;    }    /**     * Get the residual associated with this sts     *     * @return residual associated with this sts     */    public short getResidual(int i) {        return residual[i];    }    /**     * Get the frame associated with this sts     *     * @return a copy of the frame associated with this sts     */    public int[] getFrame() {        int[] f = new int[frame.length];        System.arraycopy(frame, 0, f, 0, frame.length);        return f;    }    /**     * Get an entry out of the frame     *     * @param index the index into the frame     *     * @return the entry in the frame at offset <code>index</code>     */    public int getFrameEntry(int index) {        return frame[index];    }}/** * This class is for general purpose functions such as reading and * writing from files, or converting formats of numbers. */class Utility {    /**     * Reads the next word (text separated by whitespace) from the     * given stream     *     * @param dis the input stream     *     * @return the next word     *     * @throws IOException on error     */    public static String readWord(DataInputStream dis) throws IOException {        StringBuffer sb = new StringBuffer();        char c;        // skip leading whitespace        do {            c = readChar(dis);        } while(Character.isWhitespace(c));        // read the word        do {            sb.append(c);            c = readChar(dis);        } while (!Character.isWhitespace(c));        return sb.toString();    }    /**     * Reads a single char from the stream     *     * @param dis the stream to read     * @return the next character on the stream     *     * @throws IOException if an error occurs     */    public static char readChar(DataInputStream dis) throws IOException {        return (char) dis.readByte();    }    /**     * Reads a given number of chars from the stream     *     * @param dis the stream to read     * @param num the number of chars to read     * @return a character array containing the next <code>num<code>     *          in the stream     *     * @throws IOException if an error occurs     */    public static char[] readChars(DataInputStream dis, int num)            throws IOException {        char[] carray = new char[num];        for (int i = 0; i < num; i++) {            carray[i] = readChar(dis);        }        return carray;    }    /**     * Read a float from the input stream, byte-swapping as     * necessary     *     * @param dis the inputstream     * @param isBigEndian whether or not the data being read in is in     *          big endian format.     *     * @return a floating pint value     *     * @throws IOException on error     */    public static float readFloat(DataInputStream dis, boolean isBigEndian)            throws IOException {        float val;        if (!isBigEndian) {            val =  readLittleEndianFloat(dis);        } else {            val =  dis.readFloat();        }        return val;    }    /**     * Reads the next float from the given DataInputStream,     * where the data is in little endian.     *     * @param dataStream the DataInputStream to read from     *     * @return a float     */    public static float readLittleEndianFloat(DataInputStream dataStream)            throws IOException {        return Float.intBitsToFloat(readLittleEndianInt(dataStream));    }    /**     * Read an integer from the input stream, byte-swapping as     * necessary     *     * @param dis the inputstream     * @param isBigEndian whether or not the data being read in is in     *          big endian format.     *     * @return an integer value     *     * @throws IOException on error     */    public static int readInt(DataInputStream dis, boolean isBigEndian)            throws IOException {        if (!isBigEndian) {            return readLittleEndianInt(dis);        } else {            return dis.readInt();        }    }    /**     * Reads the next little-endian integer from the given DataInputStream.     *     * @param dataStream the DataInputStream to read from     *     * @return an integer     */    public static int readLittleEndianInt(DataInputStream dataStream)            throws IOException {        int bits = 0x00000000;        for (int shift = 0; shift < 32; shift += 8) {            int byteRead = (0x000000ff & dataStream.readByte());            bits |= (byteRead << shift);        }        return bits;    }    /**     * Read a short from the input stream, byte-swapping as     * necessary     *     * @param dis the inputstream     * @param isBigEndian whether or not the data being read in is in     *          big endian format.     *     * @return an integer value     *     * @throws IOException on error     */    public static short readShort(DataInputStream dis, boolean isBigEndian)        throws IOException {        if (!isBigEndian) {            return readLittleEndianShort(dis);        } else {            return dis.readShort();        }    }    /**     * Reads the next little-endian short from the given DataInputStream.     *     * @param dataStream the DataInputStream to read from     *     * @return a short     */    public static short readLittleEndianShort(DataInputStream dis)        throws IOException {        short bits = (short)(0x0000ff & dis.readByte());        bits |= (((short)(0x0000ff & dis.readByte())) << 8);        return bits;    }    /**     * Convert a short to ulaw format     *      * @param sample the short to convert     *     * @return a short containing an unsigned 8-bit quantity     *          representing the ulaw     */    public static short shortToUlaw(short sample) {        final int[] exp_lut = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,                                   4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,                                   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,                                   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,                                   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,                                   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,                                   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,                                   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,                                   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};        int sign, exponent, mantissa;        short ulawbyte;        final short CLIP = 32635;        final short BIAS = 0x0084;        /* Get the sample into sign-magnitude. */        sign = (sample >> 8) & 0x80; /* set aside the sign */        if ( sign != 0 ) {            sample = (short) -sample; /* get magnitude */        }        if ( sample > CLIP ) sample = CLIP; /* clip the magnitude */        /* Convert from 16 bit linear to ulaw. */        sample = (short) (sample + BIAS);        exponent = exp_lut[( sample >> 7 ) & 0xFF];        mantissa = ( sample >> ( exponent + 3 ) ) & 0x0F;        ulawbyte = (short)            ((~ ( sign | ( exponent << 4 ) | mantissa)) & 0x00FF);        if ( ulawbyte == 0 ) ulawbyte = 0x02; /* optional CCITT trap */        return ulawbyte;    }    /**     * Convert a ulaw format to short     *      * @param ulawbyte a short containing an unsigned 8-but quantity     *          representing a ulaw     *     * @return the short equivalent of the ulaw     */    public static short ulawToShort(short ulawbyte) {        final int[] exp_lut = { 0, 132, 396, 924, 1980, 4092, 8316, 16764 };        int sign, exponent, mantissa;        short sample;        ulawbyte = (short) (ulawbyte & 0x00FF);        ulawbyte = (short) (~ulawbyte);        sign = ( ulawbyte & ((short) 0x80) );        exponent = (int) ( (ulawbyte & (short) 0x00FF) >> 4 ) & 0x07;        mantissa = ulawbyte & (short) 0x0F;        sample = (short) (exp_lut[exponent] + (mantissa << (exponent + 3)));        if ( sign != 0 ) sample = (short) (-sample);        return sample;    }    /**     * Print a float type's internal bit representation in hex     *     * @param f the float to print     *     * @return a string containing the hex value of <code>f</code>     */    public static String hex(float f) {        return Integer.toHexString(Float.floatToIntBits(f));    }}