package net.sf.jack4j.examples;
   
   /*
   Copyright (C) 2008 Ondrej Par
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  
  */
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.nio.ByteBuffer;
  import java.util.EnumSet;
  
  import net.sf.jack4j.AbstractJackTransportClient;
  import net.sf.jack4j.JackException;
  import net.sf.jack4j.JackLocalPort;
  import net.sf.jack4j.JackPortFlag;
  import net.sf.jack4j.JackPositionBit;
  import net.sf.jack4j.JackTransportState;
  import net.sf.jack4j.TransportPosition;
  
  /**
   * Metronome that can cooperate with Jack transport infrastructure.
   * 
   * <p>
   * The metronome can run in one of three modes:
   * <ul>
   * <li>standalone - can be started or stopped manually, clicks at manually
   * specified tempo; first click occurs just after the metronome is started.</li>
   * <li>transport aware - clicks at manually specified tempo, starts and stops
   * with Jack transport; first click occurs at zero time of Jack transport.</li>
   * <li>transport BBT aware - clicks at tempo contolled by Timebase master,
   * click occurs on each beat. Also, higher click occurs on the first beat within
   * bar.</li>
   * </ul>
   * 
   * For transport-aware and transport-BBT-aware mode, you need a tool that can
   * control Jack transport (qjackctl, for example). For transport-BBT-aware mode,
   * you also need a Timebase master that controls bar/beat/tick and BBT-offset
   * information (you can use {@link TimebaseMaster} example from Jack4j package).
   * 
   * <p>
   * See comments in the code that describe the usage of Jack4j library.
   * 
   * <p>
   * To run the examples, you need to have the native Jack4j library in your
   * system load path (LD_LIBRARY_PATH under Linux).
   * 
   * <p>
   * This example client expects single command line parameter - client name.
   * 
   * @author repa
   */
  public class Metronome extends AbstractJackTransportClient {
  
  	private enum Mode {
  		STANDALONE,
  		TRANSPORT_AWARE,
  		TRANSPORT_BBT_AWARE
  	};
  
  	private JackLocalPort audioOut;
  
  	private Mode currentMode;
  	private boolean reset;
  	private boolean started = false;
  	private int standaloneSampleCounter;
  	private double bpmTempo = 120.0;
  
  	private float soundFrequency = 880.0f;
  	private int clickDurationMillis = 10;
  	private float attackLength = 0.01f;
  	private float decayLength = 0.1f;
  
  	private boolean runningClick = false;
  	private int runningClickSampleIdx;
  	private float runningClickFrequency;
  
  	/**
  	 * This is callback method, invoked by Jack client thread during each
  	 * process cycle.
  	 * 
  	 * <p>
  	 * This method produces the sound.
  	 * 
 	 * <p>
 	 * The method is expected to put <code>bufferSize</code> samples into
 	 * <i>buffer</i> associated with the <i>output audio port</i>.
 	 * 
 	 * <p>
 	 * Port was created earlier, during client initialization.
 	 * 
 	 * <p>
 	 * Note that this method is not synchronized, but the native code that
 	 * invokes this method always obtains a lock on this JackClient instance, so
 	 * it actually behaves as a synchronized method.
 	 */
 	@Override
 	public int process(int bufferSize) throws Exception {
 		// obtain ByteBuffer associated with the output audio port
 		ByteBuffer outBuffer = audioOut.getByteBuffer(bufferSize);
 		// ALWAYS clear the buffer before use! Otherwise, limit and position would be undefined:
 		outBuffer.clear();
 
 		TransportPosition transportPosition;
 
 		// compute following information first:
 		boolean produceClicks = false; // should clicks be produced at all?
 		int samplesSinceLastClick = 0; // how many samples passed since the beginning of the last click?
 		int clickPeriodInSamples = 0; // how many samples are between two clicks?
 		int beatsPerBar = 0; // how many beats are within bar (only in TRANSPORT_BBT_AWARE mode)
 		int lastClickBeat = 0; // in which beat occured the last click (only in TRANSPORT_BBT_AWARE mode)
 
 		// in different modes, these information is computed differently:
 		switch (currentMode) {
 			case STANDALONE: // produce clicks only when started manually
 				if (started) {
 					produceClicks = true;
 
 					// in STANDALONE mode, the standaloneSampleCounter counts samples since last click
 
 					if (reset) {
 						// if the mode was just set, or we were just started, count from zero
 						standaloneSampleCounter = 0;
 					}
 
 					clickPeriodInSamples = (int) (getSampleRate() / (bpmTempo / 60.0));
 					samplesSinceLastClick = standaloneSampleCounter;
 
 					// update standaloneSampleCounter for the next invocation of process() method
 					standaloneSampleCounter = (standaloneSampleCounter + bufferSize) % clickPeriodInSamples;
 				}
 				break;
 			case TRANSPORT_AWARE: // produce clicks only when transport is rolling
 				transportPosition = new TransportPosition();
 				if (queryTransport(transportPosition) == JackTransportState.ROLLING) {
 					produceClicks = true;
 					clickPeriodInSamples = (int) (getSampleRate() / (bpmTempo / 60.0));
 					// use transport position to compute click positions
 					samplesSinceLastClick = transportPosition.getFrame() % clickPeriodInSamples;
 				}
 				break;
 			case TRANSPORT_BBT_AWARE: // produce clicks only when transport is rolling and timebase master is available
 				transportPosition = new TransportPosition();
 				if (queryTransport(transportPosition) == JackTransportState.ROLLING) {
 					if (transportPosition.getValidBitsSet().contains(JackPositionBit.POSITION_BBT)
 					        && transportPosition.getValidBitsSet().contains(JackPositionBit.BBT_FRAME_OFFSET)) {
 						produceClicks = true;
 
 						double transportBPM = transportPosition.getBeatsPerMinute();
 
 						clickPeriodInSamples = (int) (getSampleRate() / (transportBPM / 60.0));
 
 						// compute length (in seconds) of a single BBT "tick"
 						double tickLength = 60.0 / (transportBPM * transportPosition.getTicksPerBeat());
 						// compute time (in samples) between start of current beat and current tick
 						int bbtSamplesSinceBeatStart = (int) (transportPosition.getTick() * tickLength * getSampleRate());
 						// add BBT offset, because the tick might begin before the current process phase started
 						samplesSinceLastClick = bbtSamplesSinceBeatStart + transportPosition.getBbtOffset();
 
 						beatsPerBar = (int) transportPosition.getBeatsPerBar();
 						lastClickBeat = transportPosition.getBeat();
 					}
 				}
 				break;
 		}
 
 		reset = false;
 
 		// pre-fill the buffer with zero samples
 		for (int i = 0; i < bufferSize; i++) {
 			// remember to multiply start position in float size in bytes
 			outBuffer.putFloat(i * (Float.SIZE / 8), 0.0f);
 		}
 
 		// in case that the click begun in the previous process cycle and is still playing,
 		// generate samples into outBuffer.
 		continueClickSound(outBuffer, bufferSize, 0);
 
 		if (produceClicks) {
 			// start new clicks
 			int nextClickAt;
 			int nextClickBeat;
 			if (samplesSinceLastClick == 0) {
 				nextClickAt = 0;
 				nextClickBeat = lastClickBeat;
 			} else {
 				nextClickAt = clickPeriodInSamples - samplesSinceLastClick;
 				nextClickBeat = lastClickBeat + 1;
 			}
 
 			while (nextClickAt < bufferSize) {
 				if (nextClickAt >= 0) {
 					startClickSound(outBuffer, bufferSize, nextClickAt, nextClickBeat, beatsPerBar);
 				}
 				nextClickAt += clickPeriodInSamples;
 				nextClickBeat++;
 			}
 		}
 
 		// return zero to indicate that we're finished successfully
 		return 0;
 	}
 
 	/**
 	 * Computes the sound and stores it into given buffer.
 	 */
 	private void continueClickSound(ByteBuffer outBuffer, int bufferSize, int startAtSample) throws JackException {
 		if (!runningClick) {
 			return;
 		}
 
 		int sampleRate = getSampleRate();
 
 		// compute durations of the whole click, the attack, and decay
 		int clickDurationSamples = clickDurationMillis * sampleRate / 1000;
 		int attackLengthSamples = (int) (attackLength * clickDurationSamples);
 		int decayLengthSamples = (int) (decayLength * clickDurationSamples);
 		int decayStartSample = clickDurationSamples - decayLengthSamples;
 
 		// compute how many samples will be generated
 		int remainingClickSamples = clickDurationSamples - runningClickSampleIdx;
 		int remainingBufferSize = bufferSize - startAtSample;
 		int generateSamples = Math.min(remainingClickSamples, remainingBufferSize);
 
 		double phasePerSample = 2 * Math.PI * runningClickFrequency / sampleRate;
 
 		for (int sampleIdx = 0; sampleIdx < generateSamples; sampleIdx++) {
 			int clickSampleIdx = sampleIdx + runningClickSampleIdx;
 
 			float volume;
 			if (clickSampleIdx < attackLengthSamples) {
 				volume = (((float) clickSampleIdx) / attackLengthSamples);
 			} else if (clickSampleIdx >= decayStartSample) {
 				volume = (((float) (clickDurationSamples - clickSampleIdx)) / decayLengthSamples);
 			} else {
 				volume = 1.0f;
 			}
 
 			float sample = (float) (volume * Math.sin(clickSampleIdx * phasePerSample));
 
 			// remember to multiply start position in float size in bytes
 			outBuffer.putFloat((startAtSample + sampleIdx) * (Float.SIZE / 8), sample);
 		}
 
 		runningClickSampleIdx += generateSamples;
 		if (runningClickSampleIdx >= clickDurationSamples) {
 			runningClick = false;
 		}
 	}
 
 	private void startClickSound(ByteBuffer outBuffer, int bufferSize, int startAtSample, int clickBeat, int beatsPerBar)
 	        throws JackException {
 		runningClick = true;
 		runningClickSampleIdx = 0;
 
 		boolean highPitch = (beatsPerBar != 0) && (clickBeat % beatsPerBar == 1);
 		runningClickFrequency = highPitch ? 2 * soundFrequency : soundFrequency;
 
 		continueClickSound(outBuffer, bufferSize, startAtSample);
 	}
 
 	public Metronome(String clientName, boolean useExactName, boolean canStartServer, String serverName)
 	        throws JackException {
 		// Call to super constructor will register us with Jack server
 		super(clientName, useExactName, canStartServer, serverName);
 
 		// Setting default ThreadInit callback is necessary, 
 		// otherwise other callbacks won't work properly (the Jack client thread
 		// must be registered with JVM first)
 		setDefaultThreadInitCallback();
 
 		// Set the native callback that will invoke our process(int) method.
 		setDefaultProcessCallback();
 
 		// Add output audio port.
 		audioOut = addAudioPort("out", EnumSet.of(JackPortFlag.IS_OUTPUT));
 
 		currentMode = Mode.STANDALONE;
 		started = false;
 		reset = true;
 
 		// we are not activated yet, thus the callbacks won't be invoked
 	}
 
 	/**
 	 * Activation and main event loop.
 	 */
 	public void run() throws JackException, IOException {
 		// Activate the client; until now, callbacks weren't invoked
 		activate();
 
 		System.out.println("CONNECT THE OUTPUT PORT to the soundcard or other client to hear the sound.");
 
 		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 
 		System.out.println("Issue commands (\"h\" for help)");
 		boolean cont = true;
 		while (cont) {
 			System.out.print("cmd> ");
 
 			String cmd = in.readLine();
 			cmd = cmd.trim();
 			if (cmd.isEmpty()) {
 				continue;
 			}
 			char cmdChar = cmd.charAt(0);
 
 			switch (cmdChar) {
 				case 'q':
 					cont = false;
 					break;
 				case 'h':
 					System.out.println("(h) print this help");
 					System.out.println("(q) quit");
 					System.out.println("(m) set mode");
 					System.out.println("(s) start/stop (in standalone mode)");
 					System.out.println("(t) set tempo (for standalone and transport-aware mode)");
 					break;
 				case 'm':
 					updateMode(in);
 					break;
 				case 's':
 					startOrStop();
 					break;
 				case 't':
 					updateTempo(in);
 					break;
 				default:
 					System.err.println("Unknown command: " + cmd);
 			}
 		}
 
 		// close the client (disconnect from Jack)
 		close();
 	}
 
 	private void startOrStop() {
 		if (currentMode != Mode.STANDALONE) {
 			System.out.println("Available only in standalone mode");
 			return;
 		}
 
 		started = !started;
 		reset = true;
 		System.out.println(started ? "Started" : "Stopped");
 	}
 
 	private void updateMode(BufferedReader in) throws IOException {
 		System.out.print("Enter mode (s=standalone, t=transport aware, b=transport BBT aware): ");
 		String line = in.readLine();
 
 		line = line.trim();
 		if (line.isEmpty()) {
 			return;
 		}
 		char modeChar = line.charAt(0);
 
 		Mode newMode;
 		switch (modeChar) {
 			case 's':
 				newMode = Mode.STANDALONE;
 				break;
 			case 't':
 				newMode = Mode.TRANSPORT_AWARE;
 				break;
 			case 'b':
 				newMode = Mode.TRANSPORT_BBT_AWARE;
 				break;
 			default:
 				System.err.println("Unknown mode");
 				return;
 		}
 
 		System.out.println("Setting mode to " + newMode);
 		currentMode = newMode;
 		reset = true;
 	}
 
 	private void updateTempo(BufferedReader in) throws IOException {
 		System.out.print("Enter tempo: ");
 		try {
 			bpmTempo = Double.parseDouble(in.readLine());
 		} catch (NumberFormatException e) {
 			System.err.println("Can't parse value:");
 			e.printStackTrace();
 		}
 	}
 
 	public static void main(String[] args) throws Exception {
 		if (args.length != 1) {
 			throw new IllegalArgumentException("Expecting single parameter (client name)");
 		}
 		String clientName = args[0];
 
 		Metronome metronome = new Metronome(clientName, false, true, null);
 
 		metronome.run();
 	}
 }