Telecom programs 2a and 2b

You are to write the following two programs, again involving manipulation of .wav files. Both involve loading the sound file into a big array, eg short[] samples, and then applying the "convolution" operation of setting result[i] to be a suitable "moving average" of values in samples[].

Specifically, convolution of an array samples[] by a "kernel" K, a shorter array of double of length len, means to set result[n] as follows, for 0≤n<samples.length-len

	double sum = 0;
	for (int i = 0; i<len; i++) sum += samples[i+n]*K[i];
	result[n] = (short) sum;

Program 2a: echo

You can do this directly: result[i] = samples[i]+A*samples[i-delay]. Or you can convolve by a kernel of the following form:

A 0 0 0 0 0 ... (length depends on delay) ... 0 0 1

Program 2b: bandpass

The simplest approach is to create two separate kernels: a lowpass filter to reject all frequencies > f2, and a highpass filter to then reject all frequencies < f1. However, it is a little more efficient to combine these into a single kernel, by convolving them together. If you do this, you must handle the "tails" properly. Consider each kernel as extended by 0's in each direction, and allow for any possible degree of overlap. If n is the length of each separate kernel, then their convolution will have length 2*n-1.

The lowpass filter uses the sinc function, y = sin(x)/x. Specifically, let f_low = f2/samplerate (do the division as a double; note f_low is the higher of f1 and f2), and let n be the number of components to be used on either side of the center. The entire kernel will thus have length 2*n+1. Ideally n will be close to a multiple of the wavelength 1.0/f_low; typically, n is in the range of 5 to 20 wavelengths. Set

	L[i] = A*Math.sin(2*pi*f_low*(i-n)) / (i-n);

    for (int i = 0; i<= 2*n; i++) {
        if (i!=n) L[i] = Math.sin(2*pi*freq*(i-n)) / (i-n);  // make sure you have the right units for freq
    }
    L[n] = 2*pi*freq;

The above kernel ends abruptly at the ends; to taper it more gradually, the following tweak (the "Blackman window") is recommended. It would be applied after you have built L as above.

    for (int i = 0; i<=n; i++) {
        double factor = 0.42 - 0.5*Math.cos(pi*i/n) + 0.08*Math.cos(2*pi*i/n);
        L[i] *= factor;
        L[2*n-i] *= factor;
    }

After you create your basic filter kernel L, without A, normalize it by adding up the sum of all the components L[i] and then multiplying every component by A = 1.0/sum. This will ensure that the sum of the coefficients is now 1.0.

To create a highpass filter H, just subtract the lowpass filter from the identity. In other words,

	H[i] = -L[i], i ≠ n
	H[n] = 1.0 - L[n];		// the 1.0 appears at i=n only!

    SincFilter Lo = new SincFilter(f2/samplerate, n);
    SincFilter Hi = new SincFilter(f1/samplerate, n);
    Hi.invert();

Testing