comparison BeatRootProcessor.h @ 2:7d4e6b1ff3d1

Minor further updates

 */
 
 #ifndef _BEATROOT_PROCESSOR_H_
 #define _BEATROOT_PROCESSOR_H_
 
+#include <vector>
+
+using std::vector;
+
 class BeatRootProcessor
 {
 protected:
     /** Sample rate of audio */
     float sampleRate;

 
     /** Total number of audio frames if known, or -1 for live or compressed input. */
     int totalFrames;
 	
     /** Flag for enabling or disabling debugging output */
-    static bool debug = false;
+    static bool debug;
 	
     /** Flag for suppressing all standard output messages except results. */
-    static bool silent = true;
+    static bool silent;
 	
     /** RMS frame energy below this value results in the frame being
      *  set to zero, so that normalisation does not have undesired
      *  side-effects. */
-    static double silenceThreshold = 0.0004; //!!!??? energy of what? should not be static?
+    static double silenceThreshold; //!!!??? energy of what? should not be static?
 	
     /** For dynamic range compression, this value is added to the log
      *  magnitude in each frequency bin and any remaining negative
      *  values are then set to zero.
      */
-    static double rangeThreshold = 10; //!!! sim
+    static double rangeThreshold; //!!! sim
 	
     /** Determines method of normalisation. Values can be:<ul>
      *  <li>0: no normalisation</li>
      *  <li>1: normalisation by current frame energy</li>
      *  <li>2: normalisation by exponential average of frame energy</li>
      *  </ul>
      */
-    static int normaliseMode = 2;
+    static int normaliseMode;
 	
     /** Ratio between rate of sampling the signal energy (for the
      * amplitude envelope) and the hop size */
-    static int energyOversampleFactor = 2; //!!! not used?
+    static int energyOversampleFactor; //!!! not used?
 	
 public:
 
     /** Constructor: note that streams are not opened until the input
      *  file is set (see <code>setInputFile()</code>). */
-    AudioProcessor() {
+    BeatRootProcessor() {
         cbIndex = 0;
         frameRMS = 0;
         ltAverage = 0;
         frameCount = 0;
         hopSize = 0;
         fftSize = 0;
         hopTime = 0.010;	// DEFAULT, overridden with -h
         fftTime = 0.04644;	// DEFAULT, overridden with -f
-        progressCallback = null;
-        stdIn = new BufferedReader(new InputStreamReader(System.in));
-        if (doOnsetPlot)
-            plot = new Plot();
     } // constructor
 
-	/** For debugging, outputs information about the AudioProcessor to
-	 *  standard error.
-	 */
-	public void print() {
-		System.err.println(this);
-	} // print()
-
-	/** For interactive pause - wait for user to hit Enter */
-	public String readLine() {
-		try { return stdIn.readLine(); } catch (Exception e) { return null; }
-	} // readLine()
-	
-	/** Gives some basic information about the audio being processed. */
-	public String toString() {
-		return "AudioProcessor\n" +
-				String.format("\tFile: %s (%3.1f kHz, %1d channels)\n",
-						audioFileName, sampleRate/1000, channels) +
-				String.format("\tHop / FFT sizes: %5.3f / %5.3f",
-						hopTime, hopTime * fftSize / hopSize);
-	} // toString()
-
-	/** Adds a link to the GUI component which shows the progress of matching.
-	 *  @param c the AudioProcessor representing the other performance 
-	 */
-	public void setProgressCallback(ProgressIndicator c) {
-		progressCallback = c;
-	} // setProgressCallback()
-
-	/** Sets up the streams and buffers for live audio input (CD quality).
-	 *  If any Exception is thrown within this method, it is caught, and any
-	 *  opened streams are closed, and <code>pcmInputStream</code> is set to
-	 *  <code>null</code>, indicating that the method did not complete
-	 *  successfully.
-	 */
-	public void setLiveInput() {
-		try {
-			channels = 2;
-			sampleRate = 44100;
-			AudioFormat desiredFormat = new AudioFormat(
-						AudioFormat.Encoding.PCM_SIGNED, sampleRate, 16,
-						channels, channels * 2, sampleRate, false);
-			TargetDataLine tdl = AudioSystem.getTargetDataLine(desiredFormat);
-			tdl.open(desiredFormat, liveInputBufferSize);
-			pcmInputStream = new AudioInputStream(tdl);
-			audioFormat = pcmInputStream.getFormat();
-			init();
-			tdl.start();
-		} catch (Exception e) {
-			e.printStackTrace();
-			closeStreams();	// make sure it exits in a consistent state
-		}
-	} // setLiveInput()
-
-	/** Sets up the streams and buffers for audio file input.
-	 *  If any Exception is thrown within this method, it is caught, and any
-	 *  opened streams are closed, and <code>pcmInputStream</code> is set to
-	 *  <code>null</code>, indicating that the method did not complete
-	 *  successfully.
-	 *  @param fileName The path name of the input audio file.
-	 */
-	public void setInputFile(String fileName) {
-		closeStreams();		// release previously allocated resources
-		audioFileName = fileName;
-		try {
-			if (audioFileName == null)
-				throw new Exception("No input file specified");
-			File audioFile = new File(audioFileName);
-			if (!audioFile.isFile())
-				throw new FileNotFoundException(
-							"Requested file does not exist: " + audioFileName);
-			rawInputStream = AudioSystem.getAudioInputStream(audioFile);
-			audioFormat = rawInputStream.getFormat();
-			channels = audioFormat.getChannels();
-			sampleRate = audioFormat.getSampleRate();
-			pcmInputStream = rawInputStream;
-			if ((audioFormat.getEncoding()!=AudioFormat.Encoding.PCM_SIGNED) ||
-					(audioFormat.getFrameSize() != channels * 2) ||
-					audioFormat.isBigEndian()) {
-				AudioFormat desiredFormat = new AudioFormat(
-						AudioFormat.Encoding.PCM_SIGNED, sampleRate, 16,
-						channels, channels * 2, sampleRate, false);
-				pcmInputStream = AudioSystem.getAudioInputStream(desiredFormat,
-																rawInputStream);
-				audioFormat = desiredFormat;
-			}
-			init();
-		} catch (Exception e) {
-			e.printStackTrace();
-			closeStreams();	// make sure it exits in a consistent state
-		}
-	} // setInputFile()
-
+protected:
 	/** Allocates memory for arrays, based on parameter settings */
-	protected void init() {
+	void init() {
 		hopSize = (int) Math.round(sampleRate * hopTime);
 		fftSize = (int) Math.round(Math.pow(2,
 				Math.round( Math.log(fftTime * sampleRate) / Math.log(2))));
 		makeFreqMap(fftSize, sampleRate);
 		int buffSize = hopSize * channels * 2;

 		spectralFlux = new double[totalFrames];
 		frameCount = 0;
 		cbIndex = 0;
 		frameRMS = 0;
 		ltAverage = 0;
-		progressCallback = null;
 	} // init()
 
 	/** Closes the input stream(s) associated with this object. */
-	public void closeStreams() {
+	void closeStreams() {
 		if (pcmInputStream != null) {
 			try {
 				pcmInputStream.close();
 				if (pcmInputStream != rawInputStream)
 					rawInputStream.close();

 	 *  one to one. Where the spacing is greater than 0.5 semitones, the FFT
 	 *  energy is mapped into semitone-wide bins. No scaling is performed; that
 	 *  is the energy is summed into the comparison bins. See also
 	 *  processFrame()
 	 */
-	protected void makeFreqMap(int fftSize, float sampleRate) {
+	void makeFreqMap(int fftSize, float sampleRate) {
 		freqMap = new int[fftSize/2+1];
 		double binWidth = sampleRate / fftSize;
 		int crossoverBin = (int)(2 / (Math.pow(2, 1/12.0) - 1));
 		int crossoverMidi = (int)Math.round(Math.log(crossoverBin*binWidth/440)/
 														Math.log(2) * 12 + 69);

 	} // makeFreqMap()
 
 	/** Calculates the weighted phase deviation onset detection function.
 	 *  Not used.
 	 *  TODO: Test the change to WPD fn */
-	protected void weightedPhaseDeviation() {
+	void weightedPhaseDeviation() {
 		if (frameCount < 2)
 			phaseDeviation[frameCount] = 0;
 		else {
 			for (int i = 0; i < fftSize; i++) {
 				double pd = imBuffer[i] - 2 * prevPhase[i] + prevPrevPhase[i];

 	 *  in a circular input buffer.
 	 *  @return true if a frame (or part of a frame, if it is the final frame)
 	 *  is read. If a complete frame cannot be read, the InputStream is set
 	 *  to null.
 	 */
-	public boolean getFrame() {
+	bool getFrame() {
 		if (pcmInputStream == null)
 			return false;
 		try {
 			int bytesRead = (int) pcmInputStream.read(inputBuffer);
 			if ((audioOut != null) && (bytesRead > 0))

 	/** Processes a frame of audio data by first computing the STFT with a
 	 *  Hamming window, then mapping the frequency bins into a part-linear
 	 *  part-logarithmic array, then computing the spectral flux 
 	 *  then (optionally) normalising and calculating onsets.
 	 */
-	protected void processFrame() {
+	void processFrame() {
 		if (getFrame()) {
 			for (int i = 0; i < fftSize; i++) {
 				reBuffer[i] = window[i] * circBuffer[cbIndex];
 				if (++cbIndex == fftSize)
 					cbIndex = 0;

 			}
 		}
 	} // processFrame()
 
 	/** Processes a complete file of audio data. */
-	public void processFile() {
+	void processFile() {
 		while (pcmInputStream != null) {
 			// Profile.start(0);
 			processFrame();
 			// Profile.log(0);
 			if (Thread.currentThread().isInterrupted()) {

 	/** Reads a text file containing a list of whitespace-separated feature values.
 	 *  Created for paper submitted to ICASSP'07.
 	 *  @param fileName File containing the data
 	 *  @return An array containing the feature values
 	 */
-	public static double[] getFeatures(String fileName) {
+	static double[] getFeatures(String fileName) {
 		ArrayList<Double> l = new ArrayList<Double>();
 		try {
 			BufferedReader b = new BufferedReader(new FileReader(fileName));
 			while (true) {
 				String s = b.readLine();

 	/** Reads a file of feature values, treated as an onset detection function,
 	 *  and finds peaks, which are stored in <code>onsetList</code> and <code>onsets</code>.
 	 * @param fileName The file of feature values
 	 * @param hopTime The spacing of feature values in time
 	 */
-	public void processFeatures(String fileName, double hopTime) {
+	void processFeatures(String fileName, double hopTime) {
 		double hop = hopTime;
 		double[] features = getFeatures(fileName);
 		Peaks.normalise(features);
 		LinkedList<Integer> peaks = Peaks.findPeaks(features, (int)Math.round(0.06 / hop), 0.35, 0.84, true);
 		onsets = new double[peaks.size()];

 			onsetList.add(e);
 		}
 	} // processFeatures()
 
 	/** Copies output of audio processing to the display panel. */
-	public void setDisplay(BeatTrackDisplay btd) {
+	void setDisplay(BeatTrackDisplay btd) {
 		int energy2[] = new int[totalFrames*energyOversampleFactor];
 		double time[] = new double[totalFrames*energyOversampleFactor];
 		for (int i = 0; i < totalFrames*energyOversampleFactor; i++) {
 			energy2[i] = (int) (energy[i] * 4 * energyOversampleFactor);
 			time[i] = i * hopTime / energyOversampleFactor;