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.util.EnumSet;
  
  import net.sf.jack4j.AbstractJackTransportClient;
  import net.sf.jack4j.JackException;
  import net.sf.jack4j.JackPositionBit;
  import net.sf.jack4j.JackTransportState;
  import net.sf.jack4j.TransportPosition;
  
  /**
   * Example timebase master.
   * 
   * <p>
   * This client supplies Jack transport mechanism with additional timebase
   * information, such as bar/beat/tick numbers. Without the timebase master,
   * other Jack clients would only get frame number information from Jack
   * transport.
   * 
   * <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 TimebaseMaster extends AbstractJackTransportClient {
  
  	private boolean timeReset = true;
  	private double bpm = 120;
  	private float signatureNumerator = 4;
  	private float signatureDenominator = 4;
  	private double ticksPerBeat = 96;
  
  	/**
  	 * This callback computes the timebase information.
  	 * 
  	 * <p>
  	 * It's called on the beginning of each process cycle.
  	 * 
  	 * @see net.sf.jack4j.JackTransportClient#timebaseCallback(net.sf.jack4j.JackTransportState,
  	 *      int, net.sf.jack4j.TransportPosition, boolean)
  	 */
  	@Override
  	public void timebaseCallback(JackTransportState state, int nframes, TransportPosition pos, boolean newPos) {
  		if (newPos || timeReset) {
  			// either someone requested new transport position, or this is first call to our callback
  			// set the time signature and tempo values
  			pos.setBeatsPerBar(signatureNumerator);
  			pos.setBeatType(signatureDenominator);
  			pos.setBeatsPerMinute(bpm);
  			pos.setTicksPerBeat(ticksPerBeat);
  
  			timeReset = false;
  		}
  
  		// fill in beat, bar, tick, and barStartTick properties of "pos" object
  
  		double minute = pos.getFrame() / (pos.getFrameRate() * 60.0);
  		double ticksPerMinute = pos.getBeatsPerMinute() * pos.getTicksPerBeat();
  		double realAbsoluteTick = minute * ticksPerMinute;
  		int absoluteTick = (int) realAbsoluteTick;
  		int absoluteBeat = (int) (absoluteTick / pos.getTicksPerBeat());
  
  		int barNumber = (int) (absoluteBeat / pos.getBeatsPerBar());
  		int beatNumber = (int) (absoluteBeat - (barNumber * pos.getBeatsPerBar()));
  		int tickNumber = (int) (absoluteTick - (absoluteBeat * pos.getTicksPerBeat()));
  
  		pos.setBar(barNumber + 1);
  		pos.setBeat(beatNumber + 1);
  		pos.setTick(tickNumber);
  		pos.setBarStartTick(barNumber * pos.getBeatsPerBar() * pos.getTicksPerBeat());
 
 		double bbtOffsetTicks = realAbsoluteTick - absoluteTick;
 		double bbtOffsetSecond = (bbtOffsetTicks / ticksPerMinute) * 60.0;
 		pos.setBbtOffset((int) (bbtOffsetSecond * pos.getFrameRate()));
 
 		// inform other clients that bar/beat/tick fields are available (while others,
 		// such as audio-video synchronization fields, are not available).
 		pos.setValidBitsSet(EnumSet.of(JackPositionBit.POSITION_BBT, JackPositionBit.BBT_FRAME_OFFSET));
 
 	}
 
 	public TimebaseMaster(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();
 
 		// 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();
 
 		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);
 
 			try {
 				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) become timebase master");
 						System.out.println("(r) release timebase");
 						System.out.println("(p) start transport");
 						System.out.println("(s) stop transport");
 						System.out.println("(b) set time signature");
 						System.out.println("(t) set tempo");
 						break;
 					case 'm':
 						System.out.println("Registering as timebase master");
 						setDefaultTimebaseCallback(false);
 						break;
 					case 'r':
 						System.out.println("Releasing timebase");
 						releaseTimebase();
 						break;
 					case 'p':
 						System.out.println("Starting transport");
 						startTransport();
 						break;
 					case 's':
 						System.out.println("Stopping transport");
 						stopTransport();
 						break;
 					case 'b':
 						setTimeSignature(in);
 						break;
 					case 't':
 						setTempo(in);
 						break;
 					default:
 						System.err.println("Unknown command: " + cmd);
 				}
 			} catch (JackException e) {
 				e.printStackTrace();
 			}
 		}
 
 		// close the client (disconnect from Jack)
 		close();
 	}
 
 	private void setTempo(BufferedReader in) throws IOException {
 		System.out.print("Enter new tempo value (positive floating number): ");
 
 		String line = in.readLine();
 		double newBpm;
 		try {
 			newBpm = Double.parseDouble(line);
 		} catch (NumberFormatException e) {
 			e.printStackTrace();
 			return;
 		}
 
 		if (newBpm > 0) {
 			bpm = newBpm;
 
 			timeReset = true;
 		} else {
 			System.err.println("Invalid tempo (must be positive)");
 		}
 	}
 
 	private void setTimeSignature(BufferedReader in) throws IOException {
 		System.out.print("Enter new signature numerator: ");
 		String line = in.readLine();
 		float newSignatureNumerator;
 		try {
 			newSignatureNumerator = Float.parseFloat(line);
 		} catch (NumberFormatException e) {
 			e.printStackTrace();
 			return;
 		}
 
 		System.out.print("Enter new signature denominator: ");
 		line = in.readLine();
 		float newSignatureDenominator;
 		try {
 			newSignatureDenominator = Float.parseFloat(line);
 		} catch (NumberFormatException e) {
 			e.printStackTrace();
 			return;
 		}
 
 		signatureNumerator = newSignatureNumerator;
 		signatureDenominator = newSignatureDenominator;
 
 		timeReset = true;
 	}
 
 	public static void main(String[] args) throws Exception {
 		if (args.length != 1) {
 			throw new IllegalArgumentException("Expecting single parameter (client name)");
 		}
 		String clientName = args[0];
 
 		TimebaseMaster timebaseMaster = new TimebaseMaster(clientName, false, true, null);
 
 		timebaseMaster.run();
 	}
 }