plectrum

AudioEvent.java (6135B)

---

 /*
 *      _______                       _____   _____ _____  
 *     |__   __|                     |  __ \ / ____|  __ \ 
 *        | | __ _ _ __ ___  ___  ___| |  | | (___ | |__) |
 *        | |/ _` | '__/ __|/ _ \/ __| |  | |\___ \|  ___/ 
 *        | | (_| | |  \__ \ (_) \__ \ |__| |____) | |     
 *        |_|\__,_|_|  |___/\___/|___/_____/|_____/|_|     
 *                                                         
 * -------------------------------------------------------------
 *
 * TarsosDSP is developed by Joren Six at IPEM, University Ghent
 *  
 * -------------------------------------------------------------
 *
 *  Info: http://0110.be/tag/TarsosDSP
 *  Github: https://github.com/JorenSix/TarsosDSP
 *  Releases: http://0110.be/releases/TarsosDSP/
 *  
 *  TarsosDSP includes modified source code by various authors,
 *  for credits and info, see README.
 * 
 */
 
 
 package be.tarsos.dsp;
 
 import java.util.Arrays;
 
 import be.tarsos.dsp.io.TarsosDSPAudioFloatConverter;
 import be.tarsos.dsp.io.TarsosDSPAudioFormat;
 
 /**
  * An audio event flows through the processing pipeline. The object is reused for performance reasons.
  * The arrays with audio information are also reused, so watch out when using the buffer getter and setters. 
  * 
  * @author Joren Six
  */
 public class AudioEvent {
 	/**
 	 * The format specifies a particular arrangement of data in a sound stream. 
 	 */
 	private final TarsosDSPAudioFormat format;
 	
 	private final TarsosDSPAudioFloatConverter converter;
 	
 	/**
 	 * The audio data encoded in floats from -1.0 to 1.0.
 	 */
 	private float[] floatBuffer;
 	
 	/**
 	 * The audio data encoded in bytes according to format.
 	 */
 	private byte[] byteBuffer;
 	
 	/**
 	 * The overlap in samples. 
 	 */
 	private int overlap;
 	
 	/**
 	 * The length of the stream, expressed in sample frames rather than bytes
 	 */
 	private long frameLength;
 	
 	/**
 	 * The number of bytes processed before this event. It can be used to calculate the time stamp for when this event started.
 	 */
 	private long bytesProcessed;
 
 	private int bytesProcessing;
 	
 	
 	public AudioEvent(TarsosDSPAudioFormat format){
 		this.format = format;
 		this.converter = TarsosDSPAudioFloatConverter.getConverter(format);
 		this.overlap = 0;
 	}
 	
 	public float getSampleRate(){
 		return format.getSampleRate();
 	}
 	
 	public int getBufferSize(){
 		return getFloatBuffer().length;
 	}
 	
 	/**
 	 * @return  The length of the stream, expressed in sample frames rather than bytes
 	 */
 	public long getFrameLength(){
 		return frameLength;
 	}
 	
 	public int getOverlap(){
 		return overlap;
 	}
 	
 	public void setOverlap(int newOverlap){
 		overlap = newOverlap;
 	}
 	
 	public void setBytesProcessed(long bytesProcessed){
 		this.bytesProcessed = bytesProcessed;		
 	}
 	
 	/**
 	 * Calculates and returns the time stamp at the beginning of this audio event.
 	 * @return The time stamp at the beginning of the event in seconds.
 	 */
 	public double getTimeStamp(){
 		return bytesProcessed / format.getFrameSize() / format.getSampleRate();
 	}
 	
 	public double getEndTimeStamp(){
 		return(bytesProcessed + bytesProcessing) / format.getFrameSize() / format.getSampleRate();
 	}
 	
 	public long getSamplesProcessed(){
 		return bytesProcessed / format.getFrameSize();
 	}
 
 	/**
 	 * Calculate the progress in percentage of the total number of frames.
 	 * 
 	 * @return a percentage of processed frames or a negative number if the
 	 *         number of frames is not known beforehand.
 	 */
 	public double getProgress(){
 		return bytesProcessed / format.getFrameSize() / (double) frameLength;
 	}
 	
 	/**
 	 * Return a byte array with the audio data in bytes.
 	 *  A conversion is done from float, cache accordingly on the other side...
 	 * 
 	 * @return a byte array with the audio data in bytes.
 	 */
 	public byte[] getByteBuffer(){
 		int length = getFloatBuffer().length * format.getFrameSize();
 		if(byteBuffer == null || byteBuffer.length != length){
 			byteBuffer = new byte[length];
 		}
 		converter.toByteArray(getFloatBuffer(), byteBuffer);
 		return byteBuffer;
 	}
 	
 	public void setFloatBuffer(float[] floatBuffer) {
 		this.floatBuffer = floatBuffer;
 	}
 	
 	public float[] getFloatBuffer(){
 		return floatBuffer;
 	}
 	
 	/**
 	 * Calculates and returns the root mean square of the signal. Please
 	 * cache the result since it is calculated every time.
 	 * @return The <a
 	 *         href="http://en.wikipedia.org/wiki/Root_mean_square">RMS</a> of
 	 *         the signal present in the current buffer.
 	 */
 	public double getRMS() {
 		return calculateRMS(floatBuffer);
 	}
 	
 	
 	/**
 	 * Returns the dBSPL for a buffer.
 	 * 
 	 * @return The dBSPL level for the buffer.
 	 */
 	public double getdBSPL() {
 		return soundPressureLevel(floatBuffer);
 	}
 	
 	/**
 	 * Calculates and returns the root mean square of the signal. Please
 	 * cache the result since it is calculated every time.
 	 * @param floatBuffer The audio buffer to calculate the RMS for.
 	 * @return The <a
 	 *         href="http://en.wikipedia.org/wiki/Root_mean_square">RMS</a> of
 	 *         the signal present in the current buffer.
 	 */
 	public static double calculateRMS(float[] floatBuffer){
 		double rms = 0.0;
 		for (int i = 0; i < floatBuffer.length; i++) {
 			rms += floatBuffer[i] * floatBuffer[i];
 		}
 		rms = rms / Double.valueOf(floatBuffer.length);
 		rms = Math.sqrt(rms);
 		return rms;
 	}
 
 	public void clearFloatBuffer() {
 		Arrays.fill(floatBuffer, 0);
 	}
 
 		/**
 	 * Returns the dBSPL for a buffer.
 	 * 
 	 * @param buffer
 	 *            The buffer with audio information.
 	 * @return The dBSPL level for the buffer.
 	 */
 	private static double soundPressureLevel(final float[] buffer) {
 		double rms = calculateRMS(buffer);
 		return linearToDecibel(rms);
 	}
 	
 	/**
 	 * Converts a linear to a dB value.
 	 * 
 	 * @param value
 	 *            The value to convert.
 	 * @return The converted value.
 	 */
 	private static double linearToDecibel(final double value) {
 		return 20.0 * Math.log10(value);
 	}
 
 	public boolean isSilence(double silenceThreshold) {
 		return soundPressureLevel(floatBuffer) < silenceThreshold;
 	}
 
 	public void setBytesProcessing(int bytesProcessing) {
 		this.bytesProcessing = bytesProcessing;
 		
 	}
 	
 }