added library for audio-processing
This commit is contained in:
Raybz@Raybz committed
1 parent
7975382705
commit
6eabb15f07
20 files changed
+4174
No files matched your search
@@ -0,0 +1,97 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*
|
||||
* This Code is based on the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/io/AudioDevice.java
|
||||
*/
|
||||
package org.wyrez.audio;
|
||||
|
||||
import javax.sound.sampled.AudioFormat;
|
||||
import javax.sound.sampled.AudioSystem;
|
||||
import javax.sound.sampled.SourceDataLine;
|
||||
|
||||
/**
|
||||
* Class that allows directly passing PCM float data to the sound card for
|
||||
* playback.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public class AudioDevice {
|
||||
|
||||
private final SourceDataLine out;
|
||||
private byte[] buffer;
|
||||
|
||||
/**
|
||||
* Constructor, initializes the audio system for 16-bit signed stereo output
|
||||
* with a sampling rate of 44100 and a buffer size of 2048.
|
||||
*
|
||||
* @throws Exception in case the audio system could not be initialized
|
||||
*/
|
||||
public AudioDevice() throws Exception {
|
||||
this(44100, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructor, initializes the audio system for 16-bit signed output. Sets
|
||||
* the buffer size to 1024*channels
|
||||
*
|
||||
* @param samplingRate The sampling rate
|
||||
* @param channels The number of channels
|
||||
* @throws Exception in case the audio system could not be initialized
|
||||
*/
|
||||
public AudioDevice(float samplingRate, int channels) throws Exception {
|
||||
this(samplingRate, channels, 1024 * channels);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructor, initializes the audio system for 16-bit signed output.
|
||||
*
|
||||
* @param samplingRate The sampling rate
|
||||
* @param channels The number of channels
|
||||
* @param bufferSize The buffer size (have to be a even number)
|
||||
* @throws Exception in case the audio system could not be initialized
|
||||
*/
|
||||
public AudioDevice(float samplingRate, int channels, int bufferSize) throws Exception {
|
||||
AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
||||
samplingRate, 16, channels, channels * 2, samplingRate, false);
|
||||
buffer = new byte[bufferSize * 2];
|
||||
out = AudioSystem.getSourceDataLine(format);
|
||||
out.open(format);
|
||||
out.start();
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes the given samples to the audio device. The samples have to be in
|
||||
* the range [-1,1].
|
||||
*
|
||||
* @param samples The samples.
|
||||
*/
|
||||
public void writeSamples(float[] samples) {
|
||||
fillBuffer(samples);
|
||||
out.write(buffer, 0, buffer.length);
|
||||
}
|
||||
|
||||
private void fillBuffer(float[] samples) {
|
||||
for (int i = 0, j = 0; i < samples.length; i++, j += 2) {
|
||||
short value = (short) (samples[i] * Short.MAX_VALUE);
|
||||
buffer[j] = (byte) (value | 0xff);
|
||||
buffer[j + 1] = (byte) (value >> 8);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,418 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* This code is based on a tutorial by http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The whole tutorial can be found here:
|
||||
* http://www.badlogicgames.com/wordpress/?cat=18&paged=3
|
||||
*/
|
||||
package org.wyrez.audio;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import org.wyrez.audio.analysis.FFT;
|
||||
import org.wyrez.audio.decoder.Decoder;
|
||||
import org.wyrez.audio.util.Band;
|
||||
import org.wyrez.audio.util.SampleHelper;
|
||||
|
||||
/**
|
||||
* Processor to create analysis-data of audio samples
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public class AudioProcessor {
|
||||
|
||||
private Band band;
|
||||
private int bufferSize;
|
||||
private final float[] samples;
|
||||
private float[] spectralFlux;
|
||||
private float[] threshold;
|
||||
private float[] prunedSpectralFlux;
|
||||
private float[] peaks;
|
||||
private float peakAverage;
|
||||
private final float samplingRate;
|
||||
private float bpm;
|
||||
|
||||
/**
|
||||
* Constructor, initializes an AudioProcessor for the given Decoder.
|
||||
*
|
||||
* @param decoder The decoder to process
|
||||
*/
|
||||
public AudioProcessor(Decoder decoder) {
|
||||
this.samples = SampleHelper.readAllSamples(decoder);
|
||||
this.samplingRate = decoder.getSamplingRate();
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructor, initializes an AudioProcessor for the given Decoder and
|
||||
* band.
|
||||
*
|
||||
* @param decoder The decoder to process
|
||||
* @param band The band to process
|
||||
*/
|
||||
public AudioProcessor(Decoder decoder, Band band) {
|
||||
this.samples = SampleHelper.readAllSamples(decoder);
|
||||
this.samplingRate = decoder.getSamplingRate();
|
||||
this.band = band;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes cached objects to save some memory.
|
||||
*/
|
||||
public void clean() {
|
||||
spectralFlux = null;
|
||||
threshold = null;
|
||||
prunedSpectralFlux = null;
|
||||
peaks = null;
|
||||
bpm = 0f;
|
||||
bufferSize = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a full analysis of the samples data using default values:
|
||||
* BufferSize = 1024 ThresholdWindowSize = 10 ThresholdMultiplier = 1.5
|
||||
*/
|
||||
public void calculate() {
|
||||
calculate(1024, 10, 1.5f);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a full analysis of the samples data using a given threshold.
|
||||
*
|
||||
* @param thresholdWindowSize The window -size used to calculate the
|
||||
* threshold
|
||||
* @param thresholdMultiplier The multiplier used to calculate the threshold
|
||||
*/
|
||||
public void calculate(int thresholdWindowSize, float thresholdMultiplier) {
|
||||
calculate(1024, thresholdWindowSize, thresholdMultiplier);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a full analysis of the samples data using a given threshold
|
||||
* and a custom buffer size.
|
||||
*
|
||||
* @param bufferSize The size of the buffer
|
||||
* @param thresholdWindowSize The window -size used to calculate the
|
||||
* threshold
|
||||
* @param thresholdMultiplier The multiplier used to calculate the threshold
|
||||
*/
|
||||
public void calculate(int bufferSize, int thresholdWindowSize, float thresholdMultiplier) {
|
||||
calculate(bufferSize, thresholdWindowSize, thresholdMultiplier, -1f, -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a full analysis of the samples data using a given
|
||||
* threshold-multiplier and cuts fast peaks.
|
||||
*
|
||||
* @param thresholdWindowSize The window -size used to calculate the
|
||||
* threshold
|
||||
* @param minPeakDiff The minimum difference in samples between to peaks
|
||||
*/
|
||||
public void calculate(int thresholdWindowSize, float thresholdMultiplier, int minPeakDiff) {
|
||||
calculate(bufferSize, thresholdWindowSize, thresholdMultiplier, -1f, -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a full analysis of the samples data using a given
|
||||
* threshold-multiplier and cuts low peaks.
|
||||
*
|
||||
* @param thresholdWindowSize The window -size used to calculate the
|
||||
* threshold
|
||||
* @param percentageToKeep The minimum amplitude in percent of the avarage
|
||||
* amplitude
|
||||
*/
|
||||
public void calculate(int thresholdWindowSize, float thresholdMultiplier, float percentageToKeep) {
|
||||
calculate(bufferSize, thresholdWindowSize, thresholdMultiplier, percentageToKeep, -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a full analysis of the samples data.
|
||||
*
|
||||
* @param bufferSize The size of the buffer
|
||||
* @param thresholdWindowSize The window -size used to calculate the
|
||||
* threshold
|
||||
* @param thresholdMultiplier The multiplier used to calculate the threshold
|
||||
* @param percentageToKeep The minimum amplitude in percent of the avarage
|
||||
* amplitude
|
||||
* @param minPeakDiff The minimum difference in samples between to peaks
|
||||
*/
|
||||
public void calculate(int bufferSize, int thresholdWindowSize, float thresholdMultiplier, float percentageToKeep, int minPeakDiff) {
|
||||
if ((bufferSize & (bufferSize - 1)) != 0) {
|
||||
throw new IllegalArgumentException("FFT: bufferSize must be a power of two.");
|
||||
}
|
||||
this.bufferSize = bufferSize;
|
||||
calculateSpectralFlux();
|
||||
calculateThreshold(thresholdWindowSize, thresholdMultiplier);
|
||||
calculatePrunedSpectralFlux();
|
||||
calculatePeaks();
|
||||
if (percentageToKeep > 0f) {
|
||||
cutLowPeaks(percentageToKeep);
|
||||
}
|
||||
if (minPeakDiff > 0) {
|
||||
cutFastPeaks(minPeakDiff);
|
||||
}
|
||||
}
|
||||
|
||||
private void calculateSpectralFlux() {
|
||||
FFT fft = new FFT(bufferSize, samplingRate);
|
||||
fft.window(FFT.HAMMING);
|
||||
float[] buffer;
|
||||
float[] spectrum = new float[fft.getBandSize(band)];
|
||||
float[] lastSpectrum = new float[spectrum.length];
|
||||
List<Float> spectralFlux = new ArrayList<Float>();
|
||||
|
||||
for (int i = 0; i < samples.length; i += bufferSize) {
|
||||
buffer = SampleHelper.splitSampleArray(samples, i, bufferSize);
|
||||
fft.forward(buffer);
|
||||
System.arraycopy(spectrum, 0, lastSpectrum, 0, spectrum.length);
|
||||
System.arraycopy(fft.getSpectrum(band), 0, spectrum, 0, spectrum.length);
|
||||
|
||||
float flux = 0;
|
||||
for (int j = 0; j < spectrum.length; j++) {
|
||||
float value = (spectrum[j] - lastSpectrum[j]);
|
||||
flux += value < 0 ? 0 : value;
|
||||
}
|
||||
spectralFlux.add(flux);
|
||||
}
|
||||
this.spectralFlux = SampleHelper.convertToFloatArray(spectralFlux);
|
||||
}
|
||||
|
||||
private void calculateThreshold(int thresholdWindowSize, float multiplier) {
|
||||
threshold = new float[spectralFlux.length];
|
||||
for (int i = 0; i < spectralFlux.length; i++) {
|
||||
int start = Math.max(0, i - thresholdWindowSize);
|
||||
int end = Math.min(spectralFlux.length - 1, i + thresholdWindowSize);
|
||||
float mean = 0;
|
||||
for (int j = start; j <= end; j++) {
|
||||
mean += spectralFlux[j];
|
||||
}
|
||||
mean /= (end - start);
|
||||
threshold[i] = mean * multiplier;
|
||||
}
|
||||
}
|
||||
|
||||
private void calculatePrunedSpectralFlux() {
|
||||
prunedSpectralFlux = new float[threshold.length];
|
||||
for (int i = 0; i < threshold.length; i++) {
|
||||
prunedSpectralFlux[i] = (threshold[i] <= spectralFlux[i]) ? spectralFlux[i] - threshold[i] : 0f;
|
||||
}
|
||||
}
|
||||
|
||||
private void calculatePeaks() {
|
||||
peaks = new float[prunedSpectralFlux.length - 1];
|
||||
for (int i = 0; i < prunedSpectralFlux.length - 1; i++) {
|
||||
peaks[i] = (prunedSpectralFlux[i] > prunedSpectralFlux[i + 1]) ? prunedSpectralFlux[i] : 0f;
|
||||
}
|
||||
calculatePeakData();
|
||||
}
|
||||
|
||||
private void calculatePeakData() {
|
||||
calculatePeakAverage();
|
||||
calculateBPM();
|
||||
}
|
||||
|
||||
private void calculatePeakAverage() {
|
||||
int counter = 0;
|
||||
float sum = 0f;
|
||||
for (int i = 0; i < peaks.length; i++) {
|
||||
if (peaks[i] > 0f) {
|
||||
sum += peaks[i];
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
peakAverage = sum / counter;
|
||||
}
|
||||
|
||||
private void calculateBPM() {
|
||||
HashMap<Integer, Integer> peakDiff = new HashMap<Integer, Integer>();
|
||||
int counter = 0;
|
||||
boolean first = true;
|
||||
for (int i = 0; i < peaks.length; i++) {
|
||||
if (peaks[i] > 0f) {
|
||||
if (!first) {
|
||||
Integer value = peakDiff.get(counter);
|
||||
if (value == null) {
|
||||
value = 1;
|
||||
} else {
|
||||
value += 1;
|
||||
}
|
||||
peakDiff.put(counter, value);
|
||||
} else {
|
||||
first = false;
|
||||
}
|
||||
counter = 1;
|
||||
} else {
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
|
||||
int most = -1;
|
||||
int highestCount = -1;
|
||||
for (Integer i : peakDiff.keySet()) {
|
||||
if (peakDiff.get(i) > highestCount) {
|
||||
highestCount = peakDiff.get(i);
|
||||
most = i;
|
||||
}
|
||||
}
|
||||
float timePerPeak = (1 / samplingRate) * bufferSize;
|
||||
bpm = 1f / (timePerPeak * most) * 60f;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cuts the last calculated peaks. Removes every peak with a amplitude lower
|
||||
* than peakAverage*percentageToKeep.
|
||||
*/
|
||||
public void cutLowPeaks(float percentageToKeep) {
|
||||
if (peaks == null) {
|
||||
return;
|
||||
}
|
||||
float valueToKeep = peakAverage * percentageToKeep;
|
||||
for (int i = 0; i < peaks.length; i++) {
|
||||
if (peaks[i] < valueToKeep) {
|
||||
peaks[i] = 0f;
|
||||
}
|
||||
}
|
||||
calculatePeakData();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cuts the last calculated peaks. Removes peaks witch a sample difference
|
||||
* lower than minPeakDiff. (This algorithm does NOT analyse the whole data
|
||||
* therfore the result may be a bit inaccurately)
|
||||
*/
|
||||
public void cutFastPeaks(int minPeakDiff) {
|
||||
if (peaks == null) {
|
||||
return;
|
||||
}
|
||||
int counter = 1;
|
||||
boolean first = true;
|
||||
for (int i = 0; i < peaks.length; i++) {
|
||||
if (peaks[i] > 0f) {
|
||||
if (!first) {
|
||||
if (counter < minPeakDiff) {
|
||||
peaks[i] = 0f;
|
||||
} else {
|
||||
counter = 1;
|
||||
}
|
||||
} else {
|
||||
first = false;
|
||||
}
|
||||
} else {
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
calculatePeakData();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the samples which are analysed.
|
||||
*
|
||||
* @returns A float array containing the samples
|
||||
*/
|
||||
public float[] getSamples() {
|
||||
return samples;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last calculated spectral flux.
|
||||
*
|
||||
* @returns A float array containing the spectral flux data
|
||||
*/
|
||||
public float[] getSpectralFlux() {
|
||||
return spectralFlux;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last calculated threshold.
|
||||
*
|
||||
* @returns A float array containing the threshold data
|
||||
*/
|
||||
public float[] getThreshold() {
|
||||
return threshold;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last calculated pruned spectral flux.
|
||||
*
|
||||
* @returns A float array containing the pruned spectral flux data
|
||||
*/
|
||||
public float[] getPrunedSpectralFlux() {
|
||||
return prunedSpectralFlux;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last calculated peaks.
|
||||
*
|
||||
* @returns A float array containing the peaks
|
||||
*/
|
||||
public float[] getPeaks() {
|
||||
return peaks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last calculated avarage peak amplitude.
|
||||
*
|
||||
* @returns The avarage peak amplitude as float
|
||||
*/
|
||||
public float getPeakAverage() {
|
||||
return peakAverage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the sampling rate of the used samples.
|
||||
*
|
||||
* @return The sampling rate as float
|
||||
*/
|
||||
public float getSamplingRate() {
|
||||
return samplingRate;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last calculated bpm.
|
||||
*
|
||||
* @returns The bpm as float
|
||||
*/
|
||||
public float getBpm() {
|
||||
return bpm;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the buffer size used for the last calculation.
|
||||
*
|
||||
* @returns The buffer size as int
|
||||
*/
|
||||
public int getBufferSize() {
|
||||
return bufferSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the band used for the last calculation.
|
||||
*
|
||||
* @returns The band
|
||||
*/
|
||||
public Band getBand() {
|
||||
return band;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the band.
|
||||
*
|
||||
* @param band Band to use
|
||||
*/
|
||||
public void setBand(Band band) {
|
||||
this.band = band;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* Copyright (c) 2007 - 2008 by Damien Di Fede <ddf@compartmental.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Library General Public License as published
|
||||
* by the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* This Code is taken from the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/analysis/DFT.java
|
||||
*/
|
||||
package org.wyrez.audio.analysis;
|
||||
|
||||
/**
|
||||
* DFT stands for Discrete Fourier Transform and is the most widely used Fourier
|
||||
* Transform. You will never want to use this class due to the fact that it is a
|
||||
* brute force implementation of the DFT and as such is quite slow. Use an FFT
|
||||
* instead. This exists primarily as a way to ensure that other implementations
|
||||
* of the DFT are working properly. This implementation expects an even
|
||||
* <code>timeSize</code> and will throw and IllegalArgumentException if this is
|
||||
* not the case.
|
||||
*
|
||||
* @author Damien Di Fede
|
||||
*
|
||||
* @see FourierTransform
|
||||
* @see FFT
|
||||
* @see <a href="http://www.dspguide.com/ch8.htm">The Discrete Fourier
|
||||
* Transform</a>
|
||||
*
|
||||
*/
|
||||
public class DFT extends FourierTransform {
|
||||
|
||||
/**
|
||||
* Constructs a DFT that expects audio buffers of length
|
||||
* <code>timeSize</code> that have been recorded with a sample rate of
|
||||
* <code>sampleRate</code>. Will throw an IllegalArgumentException if
|
||||
* <code>timeSize</code> is not even.
|
||||
*
|
||||
* @param timeSize the length of the audio buffers you plan to analyze
|
||||
* @param sampleRate the sample rate of the audio samples you plan to
|
||||
* analyze
|
||||
*/
|
||||
public DFT(int timeSize, float sampleRate) {
|
||||
super(timeSize, sampleRate);
|
||||
if (timeSize % 2 != 0) {
|
||||
throw new IllegalArgumentException("DFT: timeSize must be even.");
|
||||
}
|
||||
buildTrigTables();
|
||||
}
|
||||
|
||||
protected void allocateArrays() {
|
||||
spectrum = new float[timeSize / 2 + 1];
|
||||
real = new float[timeSize / 2 + 1];
|
||||
imag = new float[timeSize / 2 + 1];
|
||||
}
|
||||
|
||||
/**
|
||||
* Not currently implemented.
|
||||
*/
|
||||
public void scaleBand(int i, float s) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Not currently implemented.
|
||||
*/
|
||||
public void setBand(int i, float a) {
|
||||
}
|
||||
|
||||
public void forward(float[] samples) {
|
||||
if (samples.length != timeSize) {
|
||||
throw new IllegalArgumentException("DFT.forward: The length of the passed sample buffer must be equal to DFT.timeSize().");
|
||||
}
|
||||
doWindow(samples);
|
||||
int N = samples.length;
|
||||
for (int f = 0; f <= N / 2; f++) {
|
||||
real[f] = 0.0f;
|
||||
imag[f] = 0.0f;
|
||||
for (int t = 0; t < N; t++) {
|
||||
real[f] += samples[t] * cos(t * f);
|
||||
imag[f] += samples[t] * -sin(t * f);
|
||||
}
|
||||
}
|
||||
fillSpectrum();
|
||||
}
|
||||
|
||||
public void inverse(float[] buffer) {
|
||||
int N = buffer.length;
|
||||
real[0] /= N;
|
||||
imag[0] = -imag[0] / (N / 2);
|
||||
real[N / 2] /= N;
|
||||
imag[N / 2] = -imag[0] / (N / 2);
|
||||
for (int i = 0; i < N / 2; i++) {
|
||||
real[i] /= (N / 2);
|
||||
imag[i] = -imag[i] / (N / 2);
|
||||
}
|
||||
for (int t = 0; t < N; t++) {
|
||||
buffer[t] = 0.0f;
|
||||
for (int f = 0; f < N / 2; f++) {
|
||||
buffer[t] += real[f] * cos(t * f) + imag[f] * sin(t * f);
|
||||
}
|
||||
}
|
||||
}
|
||||
// lookup table data and functions
|
||||
private float[] sinlookup;
|
||||
private float[] coslookup;
|
||||
|
||||
private void buildTrigTables() {
|
||||
int N = spectrum.length * timeSize;
|
||||
sinlookup = new float[N];
|
||||
coslookup = new float[N];
|
||||
for (int i = 0; i < N; i++) {
|
||||
sinlookup[i] = (float) Math.sin(i * TWO_PI / timeSize);
|
||||
coslookup[i] = (float) Math.cos(i * TWO_PI / timeSize);
|
||||
}
|
||||
}
|
||||
|
||||
private float sin(int i) {
|
||||
return sinlookup[i];
|
||||
}
|
||||
|
||||
private float cos(int i) {
|
||||
return coslookup[i];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
/*
|
||||
* Copyright (c) 2007 - 2008 by Damien Di Fede <ddf@compartmental.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Library General Public License as published
|
||||
* by the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* This Code is taken from the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/analysis/FFT.java
|
||||
*/
|
||||
package org.wyrez.audio.analysis;
|
||||
|
||||
/**
|
||||
* FFT stands for Fast Fourier Transform. It is an efficient way to calculate
|
||||
* the Complex Discrete Fourier Transform. There is not much to say about this
|
||||
* class other than the fact that when you want to analyze the spectrum of an
|
||||
* audio buffer you will almost always use this class. One restriction of this
|
||||
* class is that the audio buffers you want to analyze must have a length that
|
||||
* is a power of two. If you try to construct an FFT with a
|
||||
* <code>timeSize</code> that is not a power of two, an IllegalArgumentException
|
||||
* will be thrown.
|
||||
*
|
||||
* @see FourierTransform
|
||||
* @see <a href="http://www.dspguide.com/ch12.htm">The Fast Fourier
|
||||
* Transform</a>
|
||||
*
|
||||
* @author Damien Di Fede
|
||||
*
|
||||
*/
|
||||
public class FFT extends FourierTransform {
|
||||
|
||||
/**
|
||||
* Constructs an FFT that will accept sample buffers that are
|
||||
* <code>timeSize</code> long and have been recorded with a sample rate of
|
||||
* <code>sampleRate</code>.
|
||||
* <code>timeSize</code> <em>must</em> be a power of two. This will throw an
|
||||
* exception if it is not.
|
||||
*
|
||||
* @param timeSize the length of the sample buffers you will be analyzing
|
||||
* @param sampleRate the sample rate of the audio you will be analyzing
|
||||
*/
|
||||
public FFT(int timeSize, float sampleRate) {
|
||||
super(timeSize, sampleRate);
|
||||
if ((timeSize & (timeSize - 1)) != 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"FFT: timeSize must be a power of two.");
|
||||
}
|
||||
buildReverseTable();
|
||||
buildTrigTables();
|
||||
}
|
||||
|
||||
protected void allocateArrays() {
|
||||
spectrum = new float[timeSize / 2 + 1];
|
||||
real = new float[timeSize];
|
||||
imag = new float[timeSize];
|
||||
}
|
||||
|
||||
public void scaleBand(int i, float s) {
|
||||
if (s < 0) {
|
||||
throw new IllegalArgumentException("Can't scale a frequency band by a negative value.");
|
||||
}
|
||||
if (spectrum[i] != 0) {
|
||||
real[i] /= spectrum[i];
|
||||
imag[i] /= spectrum[i];
|
||||
spectrum[i] *= s;
|
||||
real[i] *= spectrum[i];
|
||||
imag[i] *= spectrum[i];
|
||||
}
|
||||
if (i != 0 && i != timeSize / 2) {
|
||||
real[timeSize - i] = real[i];
|
||||
imag[timeSize - i] = -imag[i];
|
||||
}
|
||||
}
|
||||
|
||||
public void setBand(int i, float a) {
|
||||
if (a < 0) {
|
||||
throw new IllegalArgumentException("Can't set a frequency band to a negative value.");
|
||||
}
|
||||
if (real[i] == 0 && imag[i] == 0) {
|
||||
real[i] = a;
|
||||
spectrum[i] = a;
|
||||
} else {
|
||||
real[i] /= spectrum[i];
|
||||
imag[i] /= spectrum[i];
|
||||
spectrum[i] = a;
|
||||
real[i] *= spectrum[i];
|
||||
imag[i] *= spectrum[i];
|
||||
}
|
||||
if (i != 0 && i != timeSize / 2) {
|
||||
real[timeSize - i] = real[i];
|
||||
imag[timeSize - i] = -imag[i];
|
||||
}
|
||||
}
|
||||
|
||||
// performs an in-place fft on the data in the real and imag arrays
|
||||
// bit reversing is not necessary as the data will already be bit reversed
|
||||
private void fft() {
|
||||
for (int halfSize = 1; halfSize < real.length; halfSize *= 2) {
|
||||
// float k = -(float)Math.PI/halfSize;
|
||||
// phase shift step
|
||||
// float phaseShiftStepR = (float)Math.cos(k);
|
||||
// float phaseShiftStepI = (float)Math.sin(k);
|
||||
// using lookup table
|
||||
float phaseShiftStepR = cos(halfSize);
|
||||
float phaseShiftStepI = sin(halfSize);
|
||||
// current phase shift
|
||||
float currentPhaseShiftR = 1.0f;
|
||||
float currentPhaseShiftI = 0.0f;
|
||||
for (int fftStep = 0; fftStep < halfSize; fftStep++) {
|
||||
for (int i = fftStep; i < real.length; i += 2 * halfSize) {
|
||||
int off = i + halfSize;
|
||||
float tr = (currentPhaseShiftR * real[off]) - (currentPhaseShiftI * imag[off]);
|
||||
float ti = (currentPhaseShiftR * imag[off]) + (currentPhaseShiftI * real[off]);
|
||||
real[off] = real[i] - tr;
|
||||
imag[off] = imag[i] - ti;
|
||||
real[i] += tr;
|
||||
imag[i] += ti;
|
||||
}
|
||||
float tmpR = currentPhaseShiftR;
|
||||
currentPhaseShiftR = (tmpR * phaseShiftStepR) - (currentPhaseShiftI * phaseShiftStepI);
|
||||
currentPhaseShiftI = (tmpR * phaseShiftStepI) + (currentPhaseShiftI * phaseShiftStepR);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void forward(float[] buffer) {
|
||||
if (buffer.length != timeSize) {
|
||||
throw new IllegalArgumentException("FFT.forward: The length of the passed sample buffer must be equal to timeSize().");
|
||||
}
|
||||
doWindow(buffer);
|
||||
// copy samples to real/imag in bit-reversed order
|
||||
bitReverseSamples(buffer);
|
||||
// perform the fft
|
||||
fft();
|
||||
// fill the spectrum buffer with amplitudes
|
||||
fillSpectrum();
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a forward transform on the passed buffers.
|
||||
*
|
||||
* @param buffReal the real part of the time domain signal to transform
|
||||
* @param buffImag the imaginary part of the time domain signal to transform
|
||||
*/
|
||||
public void forward(float[] buffReal, float[] buffImag) {
|
||||
if (buffReal.length != timeSize || buffImag.length != timeSize) {
|
||||
throw new IllegalArgumentException("FFT.forward: The length of the passed buffers must be equal to timeSize().");
|
||||
}
|
||||
setComplex(buffReal, buffImag);
|
||||
bitReverseComplex();
|
||||
fft();
|
||||
fillSpectrum();
|
||||
}
|
||||
|
||||
public void inverse(float[] buffer) {
|
||||
if (buffer.length > real.length) {
|
||||
throw new IllegalArgumentException("FFT.inverse: the passed array's length must equal FFT.timeSize().");
|
||||
}
|
||||
// conjugate
|
||||
for (int i = 0; i < timeSize; i++) {
|
||||
imag[i] *= -1;
|
||||
}
|
||||
bitReverseComplex();
|
||||
fft();
|
||||
// copy the result in real into buffer, scaling as we do
|
||||
for (int i = 0; i < buffer.length; i++) {
|
||||
buffer[i] = real[i] / real.length;
|
||||
}
|
||||
}
|
||||
private int[] reverse;
|
||||
|
||||
private void buildReverseTable() {
|
||||
int N = timeSize;
|
||||
reverse = new int[N];
|
||||
|
||||
// set up the bit reversing table
|
||||
reverse[0] = 0;
|
||||
for (int limit = 1, bit = N / 2; limit < N; limit <<= 1, bit >>= 1) {
|
||||
for (int i = 0; i < limit; i++) {
|
||||
reverse[i + limit] = reverse[i] + bit;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// copies the values in the samples array into the real array
|
||||
// in bit reversed order. the imag array is filled with zeros.
|
||||
private void bitReverseSamples(float[] samples) {
|
||||
for (int i = 0; i < samples.length; i++) {
|
||||
real[i] = samples[reverse[i]];
|
||||
imag[i] = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
// bit reverse real[] and imag[]
|
||||
private void bitReverseComplex() {
|
||||
float[] revReal = new float[real.length];
|
||||
float[] revImag = new float[imag.length];
|
||||
for (int i = 0; i < real.length; i++) {
|
||||
revReal[i] = real[reverse[i]];
|
||||
revImag[i] = imag[reverse[i]];
|
||||
}
|
||||
real = revReal;
|
||||
imag = revImag;
|
||||
}
|
||||
// lookup tables
|
||||
private float[] sinlookup;
|
||||
private float[] coslookup;
|
||||
|
||||
private float sin(int i) {
|
||||
return sinlookup[i];
|
||||
}
|
||||
|
||||
private float cos(int i) {
|
||||
return coslookup[i];
|
||||
}
|
||||
|
||||
private void buildTrigTables() {
|
||||
int N = timeSize;
|
||||
sinlookup = new float[N];
|
||||
coslookup = new float[N];
|
||||
for (int i = 0; i < N; i++) {
|
||||
sinlookup[i] = (float) Math.sin(-(float) Math.PI / i);
|
||||
coslookup[i] = (float) Math.cos(-(float) Math.PI / i);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,662 @@
|
||||
/*
|
||||
* Copyright (c) 2007 - 2008 by Damien Di Fede <ddf@compartmental.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Library General Public License as published
|
||||
* by the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* This Code is taken from the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/analysis/FourierTransform.java
|
||||
*/
|
||||
//########## Added Code ##########
|
||||
package org.wyrez.audio.analysis;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import org.wyrez.audio.util.Band;
|
||||
import org.wyrez.audio.util.SampleHelper;
|
||||
//#######End of Added Code #######
|
||||
|
||||
/**
|
||||
* A Fourier Transform is an algorithm that transforms a signal in the time
|
||||
* domain, such as a sample buffer, into a signal in the frequency domain, often
|
||||
* called the spectrum. The spectrum does not represent individual frequencies,
|
||||
* but actually represents frequency bands centered on particular frequencies.
|
||||
* The center frequency of each band is usually expressed as a fraction of the
|
||||
* sampling rate of the time domain signal and is equal to the index of the
|
||||
* frequency band divided by the total number of bands. The total number of
|
||||
* frequency bands is usually equal to the length of the time domain signal, but
|
||||
* access is only provided to frequency bands with indices less than half the
|
||||
* length, because they correspond to frequencies below the <a
|
||||
* href="http://en.wikipedia.org/wiki/Nyquist_frequency">Nyquist frequency</a>.
|
||||
* In other words, given a signal of length
|
||||
* <code>N</code>, there will be
|
||||
* <code>N/2</code> frequency bands in the spectrum.
|
||||
* <p>
|
||||
* As an example, if you construct a FourierTransform with a
|
||||
* <code>timeSize</code> of 1024 and and a
|
||||
* <code>sampleRate</code> of 44100 Hz, then the spectrum will contain values
|
||||
* for frequencies below 22010 Hz, which is the Nyquist frequency (half the
|
||||
* sample rate). If you ask for the value of band number 5, this will correspond
|
||||
* to a frequency band centered on
|
||||
* <code>5/1024 * 44100 = 0.0048828125 * 44100 = 215 Hz</code>. The width of
|
||||
* that frequency band is equal to
|
||||
* <code>2/1024</code>, expressed as a fraction of the total bandwidth of the
|
||||
* spectrum. The total bandwith of the spectrum is equal to the Nyquist
|
||||
* frequency, which in this case is 22100, so the bandwidth is equal to about 50
|
||||
* Hz. It is not necessary for you to remember all of these relationships,
|
||||
* though it is good to be aware of them. The function
|
||||
* <code>getFreq()</code> allows you to query the spectrum with a frequency in
|
||||
* Hz and the function
|
||||
* <code>getBandWidth()</code> will return the bandwidth in Hz of each frequency
|
||||
* band in the spectrum.
|
||||
* <p>
|
||||
* <b>Usage</b>
|
||||
* <p>
|
||||
* A typical usage of a FourierTransform is to analyze a signal so that the
|
||||
* frequency spectrum may be represented in some way, typically with vertical
|
||||
* lines. You could do this in Processing with the following code, where
|
||||
* <code>audio</code> is an AudioSource and
|
||||
* <code>fft</code> is an FFT (one of the derived classes of FourierTransform).
|
||||
*
|
||||
* <pre>
|
||||
* fft.forward(audio.left);
|
||||
* for (int i = 0; i < fft.specSize(); i++)
|
||||
* {
|
||||
* // draw the line for frequency band i, scaling it by 4 so we can see it a bit better
|
||||
* line(i, height, i, height - fft.getBand(i) * 4);
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* <b>Windowing</b>
|
||||
* <p>
|
||||
* Windowing is the process of shaping the audio samples before transforming
|
||||
* them to the frequency domain. If you call the
|
||||
* <code>window()</code> function with an appropriate constant, such as
|
||||
* FourierTransform.HAMMING, the sample buffers passed to the object for
|
||||
* analysis will be shaped by the current window before being transformed. The
|
||||
* result of using a window is to reduce the noise in the spectrum somewhat.
|
||||
* <p>
|
||||
* <b>Averages</b>
|
||||
* <p>
|
||||
* FourierTransform also has functions that allow you to request the creation of
|
||||
* an average spectrum. An average spectrum is simply a spectrum with fewer
|
||||
* bands than the full spectrum where each average band is the average of the
|
||||
* amplitudes of some number of contiguous frequency bands in the full spectrum.
|
||||
* <p>
|
||||
* <code>linAverages()</code> allows you to specify the number of averages that
|
||||
* you want and will group frequency bands into groups of equal number. So if
|
||||
* you have a spectrum with 512 frequency bands and you ask for 64 averages,
|
||||
* each average will span 8 bands of the full spectrum.
|
||||
* <p>
|
||||
* <code>logAverages()</code> will group frequency bands by octave and allows
|
||||
* you to specify the size of the smallest octave to use (in Hz) and also how
|
||||
* many bands to split each octave into. So you might ask for the smallest
|
||||
* octave to be 60 Hz and to split each octave into two bands. The result is
|
||||
* that the bandwidth of each average is different. One frequency is an octave
|
||||
* above another when it's frequency is twice that of the lower frequency. So,
|
||||
* 120 Hz is an octave above 60 Hz, 240 Hz is an octave above 120 Hz, and so on.
|
||||
* When octaves are split, they are split based on Hz, so if you split the
|
||||
* octave 60-120 Hz in half, you will get 60-90Hz and 90-120Hz. You can see how
|
||||
* these bandwidths increase as your octave sizes grow. For instance, the last
|
||||
* octave will always span
|
||||
* <code>sampleRate/4 - sampleRate/2</code>, which in the case of audio sampled
|
||||
* at 44100 Hz is 11025-22010 Hz. These logarithmically spaced averages are
|
||||
* usually much more useful than the full spectrum or the linearly spaced
|
||||
* averages because they map more directly to how humans perceive sound.
|
||||
* <p>
|
||||
* <code>calcAvg()</code> allows you to specify the frequency band you want an
|
||||
* average calculated for. You might ask for 60-500Hz and this function will
|
||||
* group together the bands from the full spectrum that fall into that range and
|
||||
* average their amplitudes for you.
|
||||
* <p>
|
||||
* If you don't want any averages calculated, then you can call
|
||||
* <code>noAverages()</code>. This will not impact your ability to use
|
||||
* <code>calcAvg()</code>, it will merely prevent the object from calculating an
|
||||
* average array every time you use
|
||||
* <code>forward()</code>.
|
||||
* <p>
|
||||
* <b>Inverse Transform</b>
|
||||
* <p>
|
||||
* FourierTransform also supports taking the inverse transform of a spectrum.
|
||||
* This means that a frequency spectrum will be transformed into a time domain
|
||||
* signal and placed in a provided sample buffer. The length of the time domain
|
||||
* signal will be
|
||||
* <code>timeSize()</code> long. The
|
||||
* <code>set</code> and
|
||||
* <code>scale</code> functions allow you the ability to shape the spectrum
|
||||
* already stored in the object before taking the inverse transform. You might
|
||||
* use these to filter frequencies in a spectrum or modify it in some other way.
|
||||
*
|
||||
* @author Damien Di Fede
|
||||
* @see <a href="http://www.dspguide.com/ch8.htm">The Discrete Fourier
|
||||
* Transform</a>
|
||||
*/
|
||||
public abstract class FourierTransform {
|
||||
|
||||
/**
|
||||
* A constant indicating no window should be used on sample buffers.
|
||||
*/
|
||||
public static final int NONE = 0;
|
||||
/**
|
||||
* A constant indicating a Hamming window should be used on sample buffers.
|
||||
*/
|
||||
public static final int HAMMING = 1;
|
||||
protected static final int LINAVG = 2;
|
||||
protected static final int LOGAVG = 3;
|
||||
protected static final int NOAVG = 4;
|
||||
protected static final float TWO_PI = (float) (2 * Math.PI);
|
||||
protected int timeSize;
|
||||
protected int sampleRate;
|
||||
protected float bandWidth;
|
||||
protected int whichWindow;
|
||||
protected float[] real;
|
||||
protected float[] imag;
|
||||
protected float[] spectrum;
|
||||
protected float[] averages;
|
||||
protected int whichAverage;
|
||||
protected int octaves;
|
||||
protected int avgPerOctave;
|
||||
|
||||
/**
|
||||
* Construct a FourierTransform that will analyze sample buffers that are
|
||||
* <code>ts</code> samples long and contain samples with a
|
||||
* <code>sr</code> sample rate.
|
||||
*
|
||||
* @param ts the length of the buffers that will be analyzed
|
||||
* @param sr the sample rate of the samples that will be analyzed
|
||||
*/
|
||||
FourierTransform(int ts, float sr) {
|
||||
timeSize = ts;
|
||||
sampleRate = (int) sr;
|
||||
bandWidth = (2f / timeSize) * ((float) sampleRate / 2f);
|
||||
noAverages();
|
||||
allocateArrays();
|
||||
whichWindow = NONE;
|
||||
}
|
||||
|
||||
// allocating real, imag, and spectrum are the responsibility of derived
|
||||
// classes
|
||||
// because the size of the arrays will depend on the implementation being used
|
||||
// this enforces that responsibility
|
||||
protected abstract void allocateArrays();
|
||||
|
||||
protected void setComplex(float[] r, float[] i) {
|
||||
if (real.length != r.length && imag.length != i.length) {
|
||||
throw new IllegalArgumentException("This won't work");
|
||||
} else {
|
||||
System.arraycopy(r, 0, real, 0, r.length);
|
||||
System.arraycopy(i, 0, imag, 0, i.length);
|
||||
}
|
||||
}
|
||||
|
||||
// fill the spectrum array with the amps of the data in real and imag
|
||||
// used so that this class can handle creating the average array
|
||||
// and also do spectrum shaping if necessary
|
||||
protected void fillSpectrum() {
|
||||
for (int i = 0; i < spectrum.length; i++) {
|
||||
spectrum[i] = (float) Math.sqrt(real[i] * real[i] + imag[i] * imag[i]);
|
||||
}
|
||||
|
||||
if (whichAverage == LINAVG) {
|
||||
int avgWidth = (int) spectrum.length / averages.length;
|
||||
for (int i = 0; i < averages.length; i++) {
|
||||
float avg = 0;
|
||||
int j;
|
||||
for (j = 0; j < avgWidth; j++) {
|
||||
int offset = j + i * avgWidth;
|
||||
if (offset < spectrum.length) {
|
||||
avg += spectrum[offset];
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
avg /= j + 1;
|
||||
averages[i] = avg;
|
||||
}
|
||||
} else if (whichAverage == LOGAVG) {
|
||||
for (int i = 0; i < octaves; i++) {
|
||||
float lowFreq, hiFreq, freqStep;
|
||||
if (i == 0) {
|
||||
lowFreq = 0;
|
||||
} else {
|
||||
lowFreq = (sampleRate / 2) / (float) Math.pow(2, octaves - i);
|
||||
}
|
||||
hiFreq = (sampleRate / 2) / (float) Math.pow(2, octaves - i - 1);
|
||||
freqStep = (hiFreq - lowFreq) / avgPerOctave;
|
||||
float f = lowFreq;
|
||||
for (int j = 0; j < avgPerOctave; j++) {
|
||||
int offset = j + i * avgPerOctave;
|
||||
averages[offset] = calcAvg(f, f + freqStep);
|
||||
f += freqStep;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the object to not compute averages.
|
||||
*
|
||||
*/
|
||||
public void noAverages() {
|
||||
averages = new float[0];
|
||||
whichAverage = NOAVG;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the number of averages used when computing the spectrum and spaces
|
||||
* the averages in a linear manner. In other words, each average band will
|
||||
* be
|
||||
* <code>specSize() / numAvg</code> bands wide.
|
||||
*
|
||||
* @param numAvg how many averages to compute
|
||||
*/
|
||||
public void linAverages(int numAvg) {
|
||||
if (numAvg > spectrum.length / 2) {
|
||||
throw new IllegalArgumentException("The number of averages for this transform can be at most " + spectrum.length / 2 + ".");
|
||||
} else {
|
||||
averages = new float[numAvg];
|
||||
}
|
||||
whichAverage = LINAVG;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the number of averages used when computing the spectrum based on the
|
||||
* minimum bandwidth for an octave and the number of bands per octave. For
|
||||
* example, with audio that has a sample rate of 44100 Hz,
|
||||
* <code>logAverages(11, 1)</code> will result in 12 averages, each
|
||||
* corresponding to an octave, the first spanning 0 to 11 Hz. To ensure that
|
||||
* each octave band is a full octave, the number of octaves is computed by
|
||||
* dividing the Nyquist frequency by two, and then the result of that by
|
||||
* two, and so on. This means that the actual bandwidth of the lowest octave
|
||||
* may not be exactly the value specified.
|
||||
*
|
||||
* @param minBandwidth the minimum bandwidth used for an octave
|
||||
* @param bandsPerOctave how many bands to split each octave into
|
||||
*/
|
||||
public void logAverages(int minBandwidth, int bandsPerOctave) {
|
||||
float nyq = (float) sampleRate / 2f;
|
||||
octaves = 1;
|
||||
while ((nyq /= 2) > minBandwidth) {
|
||||
octaves++;
|
||||
}
|
||||
avgPerOctave = bandsPerOctave;
|
||||
averages = new float[octaves * bandsPerOctave];
|
||||
whichAverage = LOGAVG;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the window to use on the samples before taking the forward
|
||||
* transform. If an invalid window is asked for, an error will be reported
|
||||
* and the current window will not be changed.
|
||||
*
|
||||
* @param which FourierTransform.HAMMING or FourierTransform.NONE
|
||||
*/
|
||||
public void window(int which) {
|
||||
if (which < 0 || which > 1) {
|
||||
throw new IllegalArgumentException("Invalid window type.");
|
||||
} else {
|
||||
whichWindow = which;
|
||||
}
|
||||
}
|
||||
|
||||
protected void doWindow(float[] samples) {
|
||||
switch (whichWindow) {
|
||||
case HAMMING:
|
||||
hamming(samples);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// windows the data in samples with a Hamming window
|
||||
protected void hamming(float[] samples) {
|
||||
for (int i = 0; i < samples.length; i++) {
|
||||
samples[i] *= (0.54f - 0.46f * Math.cos(TWO_PI * i / (samples.length - 1)));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the length of the time domain signal expected by this transform.
|
||||
*
|
||||
* @return the length of the time domain signal expected by this transform
|
||||
*/
|
||||
public int timeSize() {
|
||||
return timeSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the size of the spectrum created by this transform. In other
|
||||
* words, the number of frequency bands produced by this transform. This is
|
||||
* typically equal to
|
||||
* <code>timeSize()/2 + 1</code>, see above for an explanation.
|
||||
*
|
||||
* @return the size of the spectrum
|
||||
*/
|
||||
public int specSize() {
|
||||
return spectrum.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the amplitude of the requested frequency band.
|
||||
*
|
||||
* @param i the index of a frequency band
|
||||
* @return the amplitude of the requested frequency band
|
||||
*/
|
||||
public float getBand(int i) {
|
||||
if (i < 0) {
|
||||
i = 0;
|
||||
}
|
||||
if (i > spectrum.length - 1) {
|
||||
i = spectrum.length - 1;
|
||||
}
|
||||
return spectrum[i];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the width of each frequency band in the spectrum (in Hz). It
|
||||
* should be noted that the bandwidth of the first and last frequency bands
|
||||
* is half as large as the value returned by this function.
|
||||
*
|
||||
* @return the width of each frequency band in Hz.
|
||||
*/
|
||||
public float getBandWidth() {
|
||||
return bandWidth;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the amplitude of the
|
||||
* <code>i<sup>th</sup></code> frequency band to
|
||||
* <code>a</code>. You can use this to shape the spectrum before using
|
||||
* <code>inverse()</code>.
|
||||
*
|
||||
* @param i the frequency band to modify
|
||||
* @param a the new amplitude
|
||||
*/
|
||||
public abstract void setBand(int i, float a);
|
||||
|
||||
/**
|
||||
* Scales the amplitude of the
|
||||
* <code>i<sup>th</sup></code> frequency band by
|
||||
* <code>s</code>. You can use this to shape the spectrum before using
|
||||
* <code>inverse()</code>.
|
||||
*
|
||||
* @param i the frequency band to modify
|
||||
* @param s the scaling factor
|
||||
*/
|
||||
public abstract void scaleBand(int i, float s);
|
||||
|
||||
/**
|
||||
* Returns the index of the frequency band that contains the requested
|
||||
* frequency.
|
||||
*
|
||||
* @param freq the frequency you want the index for (in Hz)
|
||||
* @return the index of the frequency band that contains freq
|
||||
*/
|
||||
public int freqToIndex(float freq) {
|
||||
// special case: freq is lower than the bandwidth of spectrum[0]
|
||||
if (freq < getBandWidth() / 2) {
|
||||
return 0;
|
||||
}
|
||||
// special case: freq is within the bandwidth of spectrum[spectrum.length - 1]
|
||||
if (freq > sampleRate / 2 - getBandWidth() / 2) {
|
||||
return spectrum.length - 1;
|
||||
}
|
||||
// all other cases
|
||||
float fraction = freq / (float) sampleRate;
|
||||
int i = Math.round(timeSize * fraction);
|
||||
return i;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the middle frequency of the i<sup>th</sup> band.
|
||||
*
|
||||
* @param i the index of the band you want to middle frequency of
|
||||
*/
|
||||
public float indexToFreq(int i) {
|
||||
float bw = getBandWidth();
|
||||
// special case: the width of the first bin is half that of the others.
|
||||
// so the center frequency is a quarter of the way.
|
||||
if (i == 0) {
|
||||
return bw * 0.25f;
|
||||
}
|
||||
// special case: the width of the last bin is half that of the others.
|
||||
if (i == spectrum.length - 1) {
|
||||
float lastBinBeginFreq = (sampleRate / 2) - (bw / 2);
|
||||
float binHalfWidth = bw * 0.25f;
|
||||
return lastBinBeginFreq + binHalfWidth;
|
||||
}
|
||||
// the center frequency of the ith band is simply i*bw
|
||||
// because the first band is half the width of all others.
|
||||
// treating it as if it wasn't offsets us to the middle
|
||||
// of the band.
|
||||
return i * bw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the center frequency of the i<sup>th</sup> average band.
|
||||
*
|
||||
* @param i which average band you want the center frequency of.
|
||||
*/
|
||||
public float getAverageCenterFrequency(int i) {
|
||||
if (whichAverage == LINAVG) {
|
||||
// an average represents a certain number of bands in the spectrum
|
||||
int avgWidth = (int) spectrum.length / averages.length;
|
||||
// the "center" bin of the average, this is fudgy.
|
||||
int centerBinIndex = i * avgWidth + avgWidth / 2;
|
||||
return indexToFreq(centerBinIndex);
|
||||
|
||||
} else if (whichAverage == LOGAVG) {
|
||||
// which "octave" is this index in?
|
||||
int octave = i / avgPerOctave;
|
||||
// which band within that octave is this?
|
||||
int offset = i % avgPerOctave;
|
||||
float lowFreq, hiFreq, freqStep;
|
||||
// figure out the low frequency for this octave
|
||||
if (octave == 0) {
|
||||
lowFreq = 0;
|
||||
} else {
|
||||
lowFreq = (sampleRate / 2) / (float) Math.pow(2, octaves - octave);
|
||||
}
|
||||
// and the high frequency for this octave
|
||||
hiFreq = (sampleRate / 2) / (float) Math.pow(2, octaves - octave - 1);
|
||||
// each average band within the octave will be this big
|
||||
freqStep = (hiFreq - lowFreq) / avgPerOctave;
|
||||
// figure out the low frequency of the band we care about
|
||||
float f = lowFreq + offset * freqStep;
|
||||
// the center of the band will be the low plus half the width
|
||||
return f + freqStep / 2;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the amplitude of the requested frequency in the spectrum.
|
||||
*
|
||||
* @param freq the frequency in Hz
|
||||
* @return the amplitude of the frequency in the spectrum
|
||||
*/
|
||||
public float getFreq(float freq) {
|
||||
return getBand(freqToIndex(freq));
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the amplitude of the requested frequency in the spectrum to
|
||||
* <code>a</code>.
|
||||
*
|
||||
* @param freq the frequency in Hz
|
||||
* @param a the new amplitude
|
||||
*/
|
||||
public void setFreq(float freq, float a) {
|
||||
setBand(freqToIndex(freq), a);
|
||||
}
|
||||
|
||||
/**
|
||||
* Scales the amplitude of the requested frequency by
|
||||
* <code>a</code>.
|
||||
*
|
||||
* @param freq the frequency in Hz
|
||||
* @param s the scaling factor
|
||||
*/
|
||||
public void scaleFreq(float freq, float s) {
|
||||
scaleBand(freqToIndex(freq), s);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of averages currently being calculated.
|
||||
*
|
||||
* @return the length of the averages array
|
||||
*/
|
||||
public int avgSize() {
|
||||
return averages.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of the
|
||||
* <code>i<sup>th</sup></code> average.
|
||||
*
|
||||
* @param i the average you want the value of
|
||||
* @return the value of the requested average band
|
||||
*/
|
||||
public float getAvg(int i) {
|
||||
float ret;
|
||||
if (averages.length > 0) {
|
||||
ret = averages[i];
|
||||
} else {
|
||||
ret = 0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the average amplitude of the frequency band bounded by
|
||||
* <code>lowFreq</code> and
|
||||
* <code>hiFreq</code>, inclusive.
|
||||
*
|
||||
* @param lowFreq the lower bound of the band
|
||||
* @param hiFreq the upper bound of the band
|
||||
* @return the average of all spectrum values within the bounds
|
||||
*/
|
||||
public float calcAvg(float lowFreq, float hiFreq) {
|
||||
int lowBound = freqToIndex(lowFreq);
|
||||
int hiBound = freqToIndex(hiFreq);
|
||||
float avg = 0;
|
||||
for (int i = lowBound; i <= hiBound; i++) {
|
||||
avg += spectrum[i];
|
||||
}
|
||||
avg /= (hiBound - lowBound + 1);
|
||||
return avg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a forward transform on
|
||||
* <code>buffer</code>.
|
||||
*
|
||||
* @param buffer the buffer to analyze
|
||||
*/
|
||||
public abstract void forward(float[] buffer);
|
||||
|
||||
/**
|
||||
* Performs a forward transform on values in
|
||||
* <code>buffer</code>.
|
||||
*
|
||||
* @param buffer the buffer of samples
|
||||
* @param startAt the index to start at in the buffer. there must be at
|
||||
* least timeSize() samples between the starting index and the end of the
|
||||
* buffer. If there aren't, an error will be issued and the operation will
|
||||
* not be performed.
|
||||
*
|
||||
*/
|
||||
public void forward(float[] buffer, int startAt) {
|
||||
if (buffer.length - startAt < timeSize) {
|
||||
throw new IllegalArgumentException("FourierTransform.forward: not enough samples in the buffer between " + startAt + " and " + buffer.length + " to perform a transform.");
|
||||
}
|
||||
|
||||
// copy the section of samples we want to analyze
|
||||
float[] section = new float[timeSize];
|
||||
System.arraycopy(buffer, startAt, section, 0, section.length);
|
||||
forward(section);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs an inverse transform of the frequency spectrum and places the
|
||||
* result in
|
||||
* <code>buffer</code>.
|
||||
*
|
||||
* @param buffer the buffer to place the result of the inverse transform in
|
||||
*/
|
||||
public abstract void inverse(float[] buffer);
|
||||
|
||||
/**
|
||||
* Performs an inverse transform of the frequency spectrum represented by
|
||||
* freqReal and freqImag and places the result in buffer.
|
||||
*
|
||||
* @param freqReal the real part of the frequency spectrum
|
||||
* @param freqImag the imaginary part the frequency spectrum
|
||||
* @param buffer the buffer to place the inverse transform in
|
||||
*/
|
||||
public void inverse(float[] freqReal, float[] freqImag, float[] buffer) {
|
||||
setComplex(freqReal, freqImag);
|
||||
inverse(buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the spectrum of the last FourierTransform.forward() call.
|
||||
*/
|
||||
public float[] getSpectrum() {
|
||||
return spectrum;
|
||||
}
|
||||
|
||||
//########## Added Code ##########
|
||||
/**
|
||||
* @return the spectrum of the last FourierTransform.forward() call for the
|
||||
* specified range.
|
||||
*/
|
||||
public float[] getSpectrum(Band band) {
|
||||
if (band == null) {
|
||||
return spectrum;
|
||||
}
|
||||
ArrayList<Float> spec = new ArrayList<Float>();
|
||||
for (float f = band.getLowFrequenzy(); f < band.getHighFrequenzy() + getBandWidth(); f += getBandWidth()) {
|
||||
spec.add(getFreq(f));
|
||||
}
|
||||
return SampleHelper.convertToFloatArray(spec);
|
||||
}
|
||||
|
||||
public int getBandSize(Band band) {
|
||||
if (band == null) {
|
||||
return spectrum.length;
|
||||
}
|
||||
int counter = 0;
|
||||
for (float f = band.getLowFrequenzy(); f < band.getHighFrequenzy() + getBandWidth(); f += getBandWidth()) {
|
||||
counter++;
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
//#######End of Added Code #######
|
||||
|
||||
/**
|
||||
* @return the real part of the last FourierTransform.forward() call.
|
||||
*/
|
||||
public float[] getRealPart() {
|
||||
return real;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the imaginary part of the last FourierTransform.forward() call.
|
||||
*/
|
||||
public float[] getImaginaryPart() {
|
||||
return imag;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*
|
||||
* This Code is based on the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/io/Decoder.java
|
||||
*/
|
||||
package org.wyrez.audio.decoder;
|
||||
|
||||
/**
|
||||
* Interface for audio decoders that return successive amplitude frames.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public interface Decoder {
|
||||
|
||||
/**
|
||||
* Reads in samples.length stereo samples from the decoder. Returns the
|
||||
* actual number read in. If this number is smaller than samples.length then
|
||||
* the end of stream has been reached.
|
||||
*
|
||||
* @param samples The samples array to write the samples to
|
||||
* @returns The number of samples actually read
|
||||
*/
|
||||
public int readSamplesStereo(float[] samples);
|
||||
|
||||
/**
|
||||
* Reads in samples.length mono samples from the decoder. If the audio
|
||||
* source isn't mono they channels are merged. Returns the actual number
|
||||
* read in. If this number is smaller than samples.length then the end of
|
||||
* stream has been reached. All Channels are merged by calculating the
|
||||
* average.
|
||||
*
|
||||
* @param samples The samples array to write the samples to
|
||||
* @returns The number of samples actually read
|
||||
*/
|
||||
public int readSamplesMergedMono(float[] samples);
|
||||
|
||||
/**
|
||||
* Returns the number of channels in the audio source.
|
||||
*
|
||||
* @returns The channel count
|
||||
*/
|
||||
public int getChannelCount();
|
||||
|
||||
/**
|
||||
* Returns the sampling rate in Hz of the audio source.
|
||||
*
|
||||
* @returns the sampling rate as float
|
||||
*/
|
||||
public float getSamplingRate();
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package org.wyrez.audio.decoder;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* Factory used to create Audio-Decoder.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public enum DecoderFactory {
|
||||
|
||||
WAVE, MP3;
|
||||
|
||||
/**
|
||||
* Creates a decoder for the selected codec.
|
||||
*
|
||||
* @returns The new decoder
|
||||
* @throws Exception in case the Decoder could not be created
|
||||
*/
|
||||
public Decoder create(InputStream is) throws Exception {
|
||||
switch (this) {
|
||||
case WAVE:
|
||||
return new WaveDecoder(is);
|
||||
case MP3:
|
||||
return new MP3Decoder(is);
|
||||
default: //impossible
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a decoder for the given file, if there isn't one an exception is
|
||||
* thrown.
|
||||
*
|
||||
* @returns The new decoder
|
||||
* @throws Exception in case the Decoder could not be created
|
||||
* @throws IllegalArgumentException in case there is now decoder for the
|
||||
* given file
|
||||
*/
|
||||
public static Decoder create(String file) throws Exception, IllegalArgumentException {
|
||||
int i = file.lastIndexOf('.');
|
||||
if (i == 0) {
|
||||
throw new IllegalArgumentException("Can't detect a filetype");
|
||||
}
|
||||
String extension = file.substring(i + 1);
|
||||
switch (extension.toUpperCase()) {
|
||||
case "MP3":
|
||||
return MP3.create(new FileInputStream(file));
|
||||
case "WAV":
|
||||
case "WAVE":
|
||||
return WAVE.create(new FileInputStream(file));
|
||||
default:
|
||||
throw new IllegalArgumentException("Filetype \"" + extension + "\" is not supported.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,365 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*
|
||||
* This Code is based on the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/io/MP3Decoder.java
|
||||
*/
|
||||
package org.wyrez.audio.decoder;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.PushbackInputStream;
|
||||
import java.util.HashMap;
|
||||
import javax.sound.sampled.AudioFileFormat;
|
||||
import javax.sound.sampled.AudioFormat;
|
||||
import javax.sound.sampled.AudioInputStream;
|
||||
import javax.sound.sampled.AudioSystem;
|
||||
import javax.sound.sampled.UnsupportedAudioFileException;
|
||||
import javazoom.jl.decoder.Bitstream;
|
||||
import javazoom.jl.decoder.Header;
|
||||
import javazoom.spi.mpeg.sampled.file.MpegAudioFileFormat;
|
||||
import javazoom.spi.mpeg.sampled.file.MpegAudioFormat;
|
||||
import javazoom.spi.mpeg.sampled.file.MpegEncoding;
|
||||
import javazoom.spi.mpeg.sampled.file.MpegFileFormatType;
|
||||
import org.tritonus.share.TDebug;
|
||||
import org.tritonus.share.sampled.FloatSampleBuffer;
|
||||
import org.tritonus.share.sampled.file.TAudioFileReader;
|
||||
|
||||
/**
|
||||
* A decoder for MP3 files with a maximum of 2 channels.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public class MP3Decoder implements Decoder {
|
||||
|
||||
private AudioInputStream in;
|
||||
private FloatSampleBuffer buffer;
|
||||
private byte[] bytes;
|
||||
private int channels;
|
||||
private float samplingRate;
|
||||
|
||||
/**
|
||||
* Constructor, sets the input stream to read the MP3 file from. Audio files
|
||||
* with more than 2 channels aren't supported!
|
||||
*
|
||||
* @param stream The input stream.
|
||||
* @throws Exception in case the input stream couldn't be read properly
|
||||
*/
|
||||
public MP3Decoder(InputStream stream) throws Exception {
|
||||
InputStream in = new BufferedInputStream(stream, 1024 * 1024);
|
||||
this.in = new MP3AudioFileReader().getAudioInputStream(in);
|
||||
AudioFormat baseFormat = this.in.getFormat();
|
||||
this.channels = baseFormat.getChannels();
|
||||
if (channels > 2) {
|
||||
throw new IllegalArgumentException("more than 2 channels aren't supported");
|
||||
}
|
||||
this.samplingRate = baseFormat.getSampleRate();
|
||||
AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
||||
baseFormat.getSampleRate(), 16,
|
||||
baseFormat.getChannels(),
|
||||
baseFormat.getChannels() * 2,
|
||||
baseFormat.getSampleRate(), false);
|
||||
this.in = AudioSystem.getAudioInputStream(format, this.in);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to read in samples.length stereo samples. Returns the number of
|
||||
* samples actually read. Guarantees that samples.length samples are read in
|
||||
* if there was enough data in the stream.
|
||||
*
|
||||
* @param samples The samples array to write the samples to
|
||||
* @return The number of samples actually read
|
||||
*/
|
||||
@Override
|
||||
public int readSamplesStereo(float[] samples) {
|
||||
if (buffer == null || buffer.getSampleCount() < samples.length / 2) {
|
||||
buffer = new FloatSampleBuffer(in.getFormat().getChannels(), samples.length / 2, in.getFormat().getSampleRate());
|
||||
bytes = new byte[buffer.getByteArrayBufferSize(in.getFormat())];
|
||||
}
|
||||
|
||||
int read = 0;
|
||||
int readBytes = 0;
|
||||
try {
|
||||
readBytes = in.read(bytes, read, bytes.length - read);
|
||||
} catch (IOException e) {
|
||||
return 0;
|
||||
}
|
||||
if (readBytes == -1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
read += readBytes;
|
||||
while (readBytes != -1 && read != bytes.length) {
|
||||
try {
|
||||
readBytes = in.read(bytes, read, bytes.length - read);
|
||||
} catch (IOException e) {
|
||||
return 0;
|
||||
}
|
||||
read += readBytes;
|
||||
}
|
||||
|
||||
int frameCount = bytes.length / in.getFormat().getFrameSize();
|
||||
buffer.setSamplesFromBytes(bytes, 0, in.getFormat(), 0, frameCount);
|
||||
|
||||
for (int i = 0, j = 0; i < buffer.getSampleCount(); i++, j += 2) {
|
||||
samples[j] = buffer.getChannel(0)[i];
|
||||
samples[j + 1] = buffer.getChannel(buffer.getChannelCount() == 2 ? 1 : 0)[i];
|
||||
}
|
||||
return buffer.getSampleCount() * 2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to read in samples.length samples, merging stereo to a mono channel
|
||||
* by averaging. Returns the number of samples actually read. Guarantees
|
||||
* that samples.length samples are read in if there was enough data in the
|
||||
* stream.
|
||||
*
|
||||
* @param samples The samples array to write the samples to
|
||||
* @return The number of samples actually read
|
||||
*/
|
||||
@Override
|
||||
public int readSamplesMergedMono(float[] samples) {
|
||||
if (buffer == null || buffer.getSampleCount() < samples.length) {
|
||||
buffer = new FloatSampleBuffer(in.getFormat().getChannels(), samples.length, in.getFormat().getSampleRate());
|
||||
bytes = new byte[buffer.getByteArrayBufferSize(in.getFormat())];
|
||||
}
|
||||
|
||||
int read = 0;
|
||||
int readBytes = 0;
|
||||
try {
|
||||
readBytes = in.read(bytes, read, bytes.length - read);
|
||||
} catch (IOException e) {
|
||||
return 0;
|
||||
}
|
||||
if (readBytes == -1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
read += readBytes;
|
||||
while (readBytes != -1 && read != bytes.length) {
|
||||
try {
|
||||
readBytes = in.read(bytes, read, bytes.length - read);
|
||||
} catch (IOException e) {
|
||||
return 0;
|
||||
}
|
||||
read += readBytes;
|
||||
}
|
||||
|
||||
int frameCount = bytes.length / in.getFormat().getFrameSize();
|
||||
buffer.setSamplesFromBytes(bytes, 0, in.getFormat(), 0, frameCount);
|
||||
|
||||
for (int i = 0; i < buffer.getSampleCount(); i++) {
|
||||
if (buffer.getChannelCount() == 2) {
|
||||
samples[i] = (buffer.getChannel(0)[i] + buffer.getChannel(1)[i]) / 2;
|
||||
} else {
|
||||
samples[i] = buffer.getChannel(0)[i];
|
||||
}
|
||||
}
|
||||
return buffer.getSampleCount();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of channels in the audio source. (This value can't be
|
||||
* greater than 2)
|
||||
*
|
||||
* @returns The channel count
|
||||
*/
|
||||
@Override
|
||||
public int getChannelCount() {
|
||||
return channels;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the sampling rate in Hz of the audio source.
|
||||
*
|
||||
* @returns the sampling rate as float
|
||||
*/
|
||||
@Override
|
||||
public float getSamplingRate() {
|
||||
return samplingRate;
|
||||
}
|
||||
|
||||
class MP3AudioFileReader extends TAudioFileReader {
|
||||
|
||||
public static final int INITAL_READ_LENGTH = 128000;
|
||||
private static final int MARK_LIMIT = INITAL_READ_LENGTH + 1;
|
||||
private final AudioFormat.Encoding[][] sm_aEncodings = {
|
||||
{MpegEncoding.MPEG2L1, MpegEncoding.MPEG2L2, MpegEncoding.MPEG2L3},
|
||||
{MpegEncoding.MPEG1L1, MpegEncoding.MPEG1L2, MpegEncoding.MPEG1L3},
|
||||
{MpegEncoding.MPEG2DOT5L1, MpegEncoding.MPEG2DOT5L2,
|
||||
MpegEncoding.MPEG2DOT5L3},};
|
||||
|
||||
protected MP3AudioFileReader() {
|
||||
super(MARK_LIMIT, true);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected AudioFileFormat getAudioFileFormat(InputStream inputStream, long mediaLength)
|
||||
throws UnsupportedAudioFileException, IOException {
|
||||
HashMap aff_properties = new HashMap();
|
||||
HashMap af_properties = new HashMap();
|
||||
int mLength = (int) mediaLength;
|
||||
int size = inputStream.available();
|
||||
PushbackInputStream pis = new PushbackInputStream(inputStream, MARK_LIMIT);
|
||||
byte head[] = new byte[22];
|
||||
pis.read(head);
|
||||
|
||||
// Check for WAV, AU, and AIFF, Ogg Vorbis, Flac, MAC file formats.
|
||||
// Next check for Shoutcast (supported) and OGG (unsupported) streams.
|
||||
if ((head[0] == 'R') && (head[1] == 'I') && (head[2] == 'F')
|
||||
&& (head[3] == 'F') && (head[8] == 'W') && (head[9] == 'A')
|
||||
&& (head[10] == 'V') && (head[11] == 'E')) {
|
||||
int isPCM = ((head[21] << 8) & 0x0000FF00) | ((head[20]) & 0x00000FF);
|
||||
throw new UnsupportedAudioFileException("WAV PCM stream found");
|
||||
|
||||
} else if ((head[0] == '.') && (head[1] == 's') && (head[2] == 'n')
|
||||
&& (head[3] == 'd')) {
|
||||
throw new UnsupportedAudioFileException("AU stream found");
|
||||
} else if ((head[0] == 'F') && (head[1] == 'O') && (head[2] == 'R')
|
||||
&& (head[3] == 'M') && (head[8] == 'A') && (head[9] == 'I')
|
||||
&& (head[10] == 'F') && (head[11] == 'F')) {
|
||||
throw new UnsupportedAudioFileException("AIFF stream found");
|
||||
} else if (((head[0] == 'M') | (head[0] == 'm'))
|
||||
&& ((head[1] == 'A') | (head[1] == 'a'))
|
||||
&& ((head[2] == 'C') | (head[2] == 'c'))) {
|
||||
throw new UnsupportedAudioFileException("APE stream found");
|
||||
} else if (((head[0] == 'F') | (head[0] == 'f'))
|
||||
&& ((head[1] == 'L') | (head[1] == 'l'))
|
||||
&& ((head[2] == 'A') | (head[2] == 'a'))
|
||||
&& ((head[3] == 'C') | (head[3] == 'c'))) {
|
||||
throw new UnsupportedAudioFileException("FLAC stream found");
|
||||
} // Shoutcast stream ?
|
||||
else if (((head[0] == 'I') | (head[0] == 'i'))
|
||||
&& ((head[1] == 'C') | (head[1] == 'c'))
|
||||
&& ((head[2] == 'Y') | (head[2] == 'y'))) {
|
||||
pis.unread(head);
|
||||
// Load shoutcast meta data.
|
||||
} // Ogg stream ?
|
||||
else if (((head[0] == 'O') | (head[0] == 'o'))
|
||||
&& ((head[1] == 'G') | (head[1] == 'g'))
|
||||
&& ((head[2] == 'G') | (head[2] == 'g'))) {
|
||||
throw new UnsupportedAudioFileException("Ogg stream found");
|
||||
} // No, so pushback.
|
||||
else {
|
||||
pis.unread(head);
|
||||
}
|
||||
// MPEG header info.
|
||||
int nVersion = AudioSystem.NOT_SPECIFIED;
|
||||
int nLayer = AudioSystem.NOT_SPECIFIED;
|
||||
// int nSFIndex = AudioSystem.NOT_SPECIFIED;
|
||||
int nMode = AudioSystem.NOT_SPECIFIED;
|
||||
int FrameSize = AudioSystem.NOT_SPECIFIED;
|
||||
// int nFrameSize = AudioSystem.NOT_SPECIFIED;
|
||||
int nFrequency = AudioSystem.NOT_SPECIFIED;
|
||||
int nTotalFrames = AudioSystem.NOT_SPECIFIED;
|
||||
float FrameRate = AudioSystem.NOT_SPECIFIED;
|
||||
int BitRate = AudioSystem.NOT_SPECIFIED;
|
||||
int nChannels = AudioSystem.NOT_SPECIFIED;
|
||||
int nHeader = AudioSystem.NOT_SPECIFIED;
|
||||
int nTotalMS = AudioSystem.NOT_SPECIFIED;
|
||||
boolean nVBR = false;
|
||||
AudioFormat.Encoding encoding = null;
|
||||
try {
|
||||
Bitstream m_bitstream = new Bitstream(pis);
|
||||
aff_properties.put("mp3.header.pos",
|
||||
new Integer(m_bitstream.header_pos()));
|
||||
Header m_header = m_bitstream.readFrame();
|
||||
// nVersion = 0 => MPEG2-LSF (Including MPEG2.5), nVersion = 1 => MPEG1
|
||||
nVersion = m_header.version();
|
||||
if (nVersion == 2) {
|
||||
aff_properties.put("mp3.version.mpeg", Float.toString(2.5f));
|
||||
} else {
|
||||
aff_properties.put("mp3.version.mpeg",
|
||||
Integer.toString(2 - nVersion));
|
||||
}
|
||||
// nLayer = 1,2,3
|
||||
nLayer = m_header.layer();
|
||||
aff_properties.put("mp3.version.layer", Integer.toString(nLayer));
|
||||
// nSFIndex = m_header.sample_frequency();
|
||||
nMode = m_header.mode();
|
||||
aff_properties.put("mp3.mode", new Integer(nMode));
|
||||
nChannels = nMode == 3 ? 1 : 2;
|
||||
aff_properties.put("mp3.channels", new Integer(nChannels));
|
||||
nVBR = m_header.vbr();
|
||||
af_properties.put("vbr", new Boolean(nVBR));
|
||||
aff_properties.put("mp3.vbr", new Boolean(nVBR));
|
||||
aff_properties.put("mp3.vbr.scale", new Integer(m_header.vbr_scale()));
|
||||
FrameSize = m_header.calculate_framesize();
|
||||
aff_properties.put("mp3.framesize.bytes", new Integer(FrameSize));
|
||||
if (FrameSize < 0) {
|
||||
throw new UnsupportedAudioFileException("Invalid FrameSize : " + FrameSize);
|
||||
}
|
||||
nFrequency = m_header.frequency();
|
||||
aff_properties.put("mp3.frequency.hz", new Integer(nFrequency));
|
||||
FrameRate = (float) ((1.0 / (m_header.ms_per_frame())) * 1000.0);
|
||||
aff_properties.put("mp3.framerate.fps", new Float(FrameRate));
|
||||
if (FrameRate < 0) {
|
||||
throw new UnsupportedAudioFileException("Invalid FrameRate : " + FrameRate);
|
||||
}
|
||||
if (mLength != AudioSystem.NOT_SPECIFIED) {
|
||||
aff_properties.put("mp3.length.bytes", new Integer(mLength));
|
||||
nTotalFrames = m_header.max_number_of_frames(mLength);
|
||||
aff_properties.put("mp3.length.frames", new Integer(nTotalFrames));
|
||||
}
|
||||
BitRate = m_header.bitrate();
|
||||
af_properties.put("bitrate", new Integer(BitRate));
|
||||
aff_properties.put("mp3.bitrate.nominal.bps", new Integer(BitRate));
|
||||
nHeader = m_header.getSyncHeader();
|
||||
encoding = sm_aEncodings[nVersion][nLayer - 1];
|
||||
aff_properties.put("mp3.version.encoding", encoding.toString());
|
||||
if (mLength != AudioSystem.NOT_SPECIFIED) {
|
||||
nTotalMS = Math.round(m_header.total_ms(mLength));
|
||||
aff_properties.put("duration", new Long((long) nTotalMS * 1000L));
|
||||
}
|
||||
aff_properties.put("mp3.copyright", new Boolean(m_header.copyright()));
|
||||
aff_properties.put("mp3.original", new Boolean(m_header.original()));
|
||||
aff_properties.put("mp3.crc", new Boolean(m_header.checksums()));
|
||||
aff_properties.put("mp3.padding", new Boolean(m_header.padding()));
|
||||
InputStream id3v2 = m_bitstream.getRawID3v2();
|
||||
if (id3v2 != null) {
|
||||
aff_properties.put("mp3.id3tag.v2", id3v2);
|
||||
}
|
||||
if (TDebug.TraceAudioFileReader) {
|
||||
TDebug.out(m_header.toString());
|
||||
}
|
||||
} catch (Exception e) {
|
||||
throw new UnsupportedAudioFileException("not a MPEG stream:"
|
||||
+ e.getMessage());
|
||||
}
|
||||
// Deeper checks ?
|
||||
int cVersion = (nHeader >> 19) & 0x3;
|
||||
if (cVersion == 1) {
|
||||
throw new UnsupportedAudioFileException(
|
||||
"not a MPEG stream: wrong version");
|
||||
}
|
||||
int cSFIndex = (nHeader >> 10) & 0x3;
|
||||
if (cSFIndex == 3) {
|
||||
|
||||
throw new UnsupportedAudioFileException(
|
||||
"not a MPEG stream: wrong sampling rate");
|
||||
}
|
||||
|
||||
AudioFormat format = new MpegAudioFormat(encoding, (float) nFrequency,
|
||||
AudioSystem.NOT_SPECIFIED, nChannels, -1, FrameRate, true, af_properties);
|
||||
return new MpegAudioFileFormat(MpegFileFormatType.MP3, format,
|
||||
nTotalFrames, mLength, aff_properties);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*
|
||||
* This Code is based on the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/io/WaveDecoder.java
|
||||
*/
|
||||
package org.wyrez.audio.decoder;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.InputStream;
|
||||
import org.wyrez.audio.util.EndianDataInputStream;
|
||||
|
||||
/**
|
||||
* A simple converter that can read in the PCM data from a Wav file, converting
|
||||
* the data to signed 32-bit floats in the range [-1,1]. This only supports
|
||||
* 16-bit Wav files with a maximum of 2 channels.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public class WaveDecoder implements Decoder {
|
||||
|
||||
private final float MAX_VALUE = 1.0f / Short.MAX_VALUE;//inverse max short value as float
|
||||
private final EndianDataInputStream in;
|
||||
private final int channels;
|
||||
private final float samplingRate;
|
||||
|
||||
/**
|
||||
* Constructor, sets the input stream to read the Wav file from. Audio files
|
||||
* with more than 2 channels aren't supported!
|
||||
*
|
||||
* @param stream The input stream.
|
||||
* @throws Exception in case the input stream couldn't be read properly
|
||||
*/
|
||||
public WaveDecoder(InputStream stream) throws Exception {
|
||||
if (stream == null) {
|
||||
throw new IllegalArgumentException("Input stream must not be null");
|
||||
}
|
||||
|
||||
in = new EndianDataInputStream(new BufferedInputStream(stream, 1024 * 1024));
|
||||
if (!in.read4ByteString().equals("RIFF")) {
|
||||
throw new IllegalArgumentException("not a wav");
|
||||
}
|
||||
|
||||
in.readIntLittleEndian();
|
||||
|
||||
if (!in.read4ByteString().equals("WAVE")) {
|
||||
throw new IllegalArgumentException("expected WAVE tag");
|
||||
}
|
||||
|
||||
if (!in.read4ByteString().equals("fmt ")) {
|
||||
throw new IllegalArgumentException("expected fmt tag");
|
||||
}
|
||||
|
||||
if (in.readIntLittleEndian() != 16) {
|
||||
throw new IllegalArgumentException("expected wave chunk size to be 16");
|
||||
}
|
||||
|
||||
if (in.readShortLittleEndian() != 1) {
|
||||
throw new IllegalArgumentException("expected format to be 1");
|
||||
}
|
||||
|
||||
channels = in.readShortLittleEndian();
|
||||
if (channels > 2) {
|
||||
throw new IllegalArgumentException("more than 2 channels aren't supported");
|
||||
}
|
||||
samplingRate = in.readIntLittleEndian();
|
||||
|
||||
in.readIntLittleEndian();
|
||||
in.readShortLittleEndian();
|
||||
int fmt = in.readShortLittleEndian();
|
||||
|
||||
if (fmt != 16) {
|
||||
throw new IllegalArgumentException("Only 16-bit signed format supported");
|
||||
}
|
||||
|
||||
if (!in.read4ByteString().equals("data")) {
|
||||
throw new RuntimeException("expected data tag");
|
||||
}
|
||||
|
||||
in.readIntLittleEndian();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to read in samples.length stereo samples, converting non float
|
||||
* formats to float 32-bit. Returns the number of samples actually read.
|
||||
* Guarantees that samples.length samples are read in if there was enough
|
||||
* data in the stream.
|
||||
*
|
||||
* @param samples The samples array to write the samples to
|
||||
* @return The number of samples actually read
|
||||
*/
|
||||
@Override
|
||||
public int readSamplesStereo(float[] samples) {
|
||||
switch (channels) {
|
||||
case 1:
|
||||
return readMonoAsStereo(samples);
|
||||
case 2:
|
||||
return readRealStereo(samples);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
private int readRealStereo(float[] samples) {
|
||||
int readSamples = 0;
|
||||
for (int i = 0; i < samples.length - 1; i += 2) {
|
||||
try {
|
||||
samples[i] = in.readShortLittleEndian() * MAX_VALUE;
|
||||
samples[i + 1] = in.readShortLittleEndian() * MAX_VALUE;
|
||||
readSamples += 2;
|
||||
} catch (Exception ex) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return readSamples;
|
||||
}
|
||||
|
||||
private int readMonoAsStereo(float[] samples) {
|
||||
int readSamples = 0;
|
||||
for (int i = 0; i < samples.length - 1; i += 2) {
|
||||
try {
|
||||
float sample = in.readShortLittleEndian() * MAX_VALUE;
|
||||
samples[i] = sample;
|
||||
samples[i + 1] = sample;
|
||||
readSamples += 2;
|
||||
} catch (Exception ex) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return readSamples;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to read in samples.length samples, merging stereo to a mono channel
|
||||
* by averaging and converting non float formats to float 32-bit. Returns
|
||||
* the number of samples actually read. Guarantees that samples.length
|
||||
* samples are read in if there was enough data in the stream.
|
||||
*
|
||||
* @param samples The samples array to write the samples to
|
||||
* @return The number of samples actually read
|
||||
*/
|
||||
@Override
|
||||
public int readSamplesMergedMono(float[] samples) {
|
||||
int readSamples = 0;
|
||||
for (int i = 0; i < samples.length; i++) {
|
||||
float sample = 0;
|
||||
try {
|
||||
for (int j = 0; j < channels; j++) {
|
||||
int shortValue = in.readShortLittleEndian();
|
||||
sample += (shortValue * MAX_VALUE);
|
||||
}
|
||||
sample /= channels;
|
||||
samples[i] = sample;
|
||||
readSamples++;
|
||||
} catch (Exception ex) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return readSamples;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of channels in the audio source. (This value can't be
|
||||
* greater than 2)
|
||||
*
|
||||
* @returns The channel count
|
||||
*/
|
||||
@Override
|
||||
public int getChannelCount() {
|
||||
return channels;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the sampling rate in Hz of the audio source.
|
||||
*
|
||||
* @returns the sampling rate as floatF
|
||||
*/
|
||||
@Override
|
||||
public float getSamplingRate() {
|
||||
return samplingRate;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package org.wyrez.audio.util;
|
||||
|
||||
/**
|
||||
* Defines a band between of two frequencies.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public class Band {
|
||||
|
||||
private float lowFrequenzy;
|
||||
private float highFrequenzy;
|
||||
|
||||
public Band(float lowFrequenzy, float highFrequenzy) {
|
||||
if (lowFrequenzy <= highFrequenzy) {
|
||||
this.lowFrequenzy = lowFrequenzy;
|
||||
this.highFrequenzy = highFrequenzy;
|
||||
} else {
|
||||
this.lowFrequenzy = highFrequenzy;
|
||||
this.highFrequenzy = lowFrequenzy;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the lower frequency of the band.
|
||||
*
|
||||
* @return The frequency as float
|
||||
*/
|
||||
public float getLowFrequenzy() {
|
||||
return lowFrequenzy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the higher frequency of the band.
|
||||
*
|
||||
* @return The frequency as float
|
||||
*/
|
||||
public float getHighFrequenzy() {
|
||||
return highFrequenzy;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
/*
|
||||
* This Code is taken from the source provided with a tutorial by
|
||||
* http://www.badlogicgames.com (as of 16.05.2013).
|
||||
* The original source can be found here:
|
||||
* http://code.google.com/p/audio-analysis/source/browse/trunk/src/com/badlogic/audio/io/EndianDataInputStream.java
|
||||
*/
|
||||
package org.wyrez.audio.util;
|
||||
|
||||
import java.io.DataInputStream;
|
||||
import java.io.InputStream;
|
||||
|
||||
public class EndianDataInputStream extends DataInputStream {
|
||||
|
||||
public EndianDataInputStream(InputStream in) {
|
||||
super(in);
|
||||
}
|
||||
|
||||
public String read4ByteString() throws Exception {
|
||||
byte[] bytes = new byte[4];
|
||||
readFully(bytes);
|
||||
return new String(bytes, "US-ASCII");
|
||||
}
|
||||
|
||||
public short readShortLittleEndian() throws Exception {
|
||||
int result = readUnsignedByte();
|
||||
result |= readUnsignedByte() << 8;
|
||||
return (short) result;
|
||||
}
|
||||
|
||||
public int readIntLittleEndian() throws Exception {
|
||||
int result = readUnsignedByte();
|
||||
result |= readUnsignedByte() << 8;
|
||||
result |= readUnsignedByte() << 16;
|
||||
result |= readUnsignedByte() << 24;
|
||||
return result;
|
||||
}
|
||||
|
||||
public int readInt24BitLittleEndian() throws Exception {
|
||||
int result = readUnsignedByte();
|
||||
result |= readUnsignedByte() << 8;
|
||||
result |= readUnsignedByte() << 16;
|
||||
if ((result & (1 << 23)) == 8388608) {
|
||||
result |= 0xff000000;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public int readInt24Bit() throws Exception {
|
||||
int result = readUnsignedByte() << 16;
|
||||
result |= readUnsignedByte() << 8;
|
||||
result |= readUnsignedByte();
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
/*
|
||||
* Copyright (C) 2013 Darth Affe <http://wyrez.org> and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package org.wyrez.audio.util;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import org.wyrez.audio.decoder.Decoder;
|
||||
|
||||
/**
|
||||
* Helper class for sample-processing.
|
||||
*
|
||||
* @author Darth Affe
|
||||
*/
|
||||
public class SampleHelper {
|
||||
|
||||
/**
|
||||
* Converts a list of floats to an array of floats.
|
||||
*
|
||||
* @param samples The List to convert
|
||||
* @returns The new float array
|
||||
*/
|
||||
public static float[] convertToFloatArray(List<Float> samples) {
|
||||
float[] array = new float[samples.size()];
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
array[i] = samples.get(i);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an float array with the given length containing only the one
|
||||
* given value.
|
||||
*
|
||||
* @param f The value to fill the array with
|
||||
* @param length The length of the array
|
||||
* @returns The new array
|
||||
*/
|
||||
public static float[] createFloatArray(float f, int length) {
|
||||
float[] result = new float[length];
|
||||
for (int i = 0; i < length; i++) {
|
||||
result[i] = f;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Splits an array of floats.
|
||||
*
|
||||
* @param samples The source array to split
|
||||
* @param offset The offset to split from
|
||||
* @param length The length of the new array
|
||||
*
|
||||
* @retrn The new array
|
||||
*
|
||||
* @throws IllegalArgumentException Thrown if there aren't enough samples to
|
||||
* proceed
|
||||
*/
|
||||
public static float[] splitSampleArray(float[] samples, int offset, int length)
|
||||
throws IllegalArgumentException {
|
||||
if (offset + length > samples.length) {
|
||||
throw new IllegalArgumentException("There aren't enough samples in order to do that");
|
||||
}
|
||||
float[] result = new float[length];
|
||||
for (int i = 0, j = offset; i < length; i++, j++) {
|
||||
result[i] = samples[j];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads all samples mono merged from the given decoder.
|
||||
*
|
||||
* @param deocder The decoder to read from
|
||||
* @returns The float array containing the samples
|
||||
*/
|
||||
public static float[] readAllSamples(Decoder decoder) {
|
||||
List<Float> samples = new ArrayList<Float>();
|
||||
float[] buffer = new float[1024];
|
||||
while (decoder.readSamplesMergedMono(buffer) > 0) {
|
||||
for (int i = 0; i < buffer.length; i++) {
|
||||
samples.add(buffer[i]);
|
||||
}
|
||||
}
|
||||
return convertToFloatArray(samples);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user