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.ArrayList;
  import java.util.EnumSet;
  import java.util.Iterator;
  import java.util.List;
  
  import net.sf.jack4j.AbstractJackClient;
  import net.sf.jack4j.JackException;
  import net.sf.jack4j.JackLocalMidiPort;
  import net.sf.jack4j.JackMidiPortBuffer;
  import net.sf.jack4j.JackPortFlag;
  
  /**
   * Very simple MIDI sequencer.
   * 
   * <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 MidiSeq extends AbstractJackClient {
  
  	/**
  	 * Simple structure that will contain single element of our loop.
  	 */
  	private static final class LoopNote {
  
  		public int noteNumber;
  		public int durationSamples;
  		public int pauseSamples;
  	}
  
  	private JackLocalMidiPort midiOut;
  	private List<LoopNote> loop;
  
  	private boolean running;
  	private Iterator<LoopNote> loopIterator;
  	private LoopNote currentLoopNote;
  	private boolean playingNote;
  	private int remainingSamples;
  
  	/**
  	 * This is callback method, invoked by Jack client thread during each
  	 * process cycle.
  	 * 
  	 * <p>
  	 * This method produces MIDI events and stores them into <i>buffer</i>
  	 * associated with the <i>output MIDI port</i>.
  	 * 
  	 * <p>
  	 * Port was created earlier, during client initialization.
  	 */
  	@Override
  	public int process(int bufferSize) throws Exception {
  		if (!running) {
  			return 0;
  		}
  
  		// initialize the MIDI buffer into which we will store MIDI events
  		JackMidiPortBuffer outBuffer = midiOut.initializeMidiBuffer(bufferSize);
  		// Always call clearBuffer() on output MIDI ports, on the beginning of each process cycle:
  		outBuffer.clearBuffer();
  
  		int sampleIdx = 0;
  		for (;;) {
  			if (remainingSamples < (bufferSize - sampleIdx)) {
  				sampleIdx += remainingSamples;
  
  				// we finished "playing" current note or pause
 				// generate next MIDI event;
 				byte[] midiEventData;
 				if (playingNote) {
 					// note ends
 					midiEventData = new byte[3];
 					midiEventData[0] = (byte) 0x80; // NOTE OFF
 					midiEventData[1] = (byte) currentLoopNote.noteNumber;
 					midiEventData[2] = 64; // velocity
 
 					playingNote = false;
 					remainingSamples = currentLoopNote.pauseSamples;
 				} else {
 					// pause ends, play next note
 					if (!loopIterator.hasNext()) {
 						// restart the loop
 						loopIterator = loop.iterator();
 					}
 					currentLoopNote = loopIterator.next();
 
 					midiEventData = new byte[3];
 					midiEventData[0] = (byte) 0x90; // NOTE ON
 					midiEventData[1] = (byte) currentLoopNote.noteNumber;
 					midiEventData[2] = 64; // velocity
 
 					playingNote = true;
 					remainingSamples = currentLoopNote.durationSamples;
 				}
 
 				// Write event into the output buffer.
 
 				// Each event "happens" on a certain time during current process cycle.
 				// The "time" parameter has a value between 0 (happens at the beginning
 				// of the current process cycle) and bufferSize (happens at the very end of the current
 				// process cycle.
 				System.out.println("Writing MIDI event, time " + sampleIdx + ", first byte is " + midiEventData[0]);
 				outBuffer.eventWrite(sampleIdx, midiEventData);
 			} else {
 				// nothing happens until the end of current process cycle
 				remainingSamples -= (bufferSize - sampleIdx);
 				break;
 			}
 		}
 
 		// indicate that we finished properly
 		return 0;
 	}
 
 	public MidiSeq(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 MIDI port.
 		midiOut = addMidiPort("in", EnumSet.of(JackPortFlag.IS_OUTPUT));
 
 		loop = null;
 
 		running = false;
 
 		// 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("CONNECT THE OUTPUT PORT to some MIDI synthesizer.");
 		System.out.println("You can use MidiSeq example client from Jack4j package.");
 
 		// Let the user enter the loop events
 		loop = new ArrayList<LoopNote>();
 		for (;;) {
 			System.out.println("Enter MIDI note number (0-127) or enter to quit:");
 			String midiNoteStr = in.readLine();
 			if ("".equals(midiNoteStr)) {
 				break;
 			}
 			int midiNote;
 			try {
 				midiNote = Integer.parseInt(midiNoteStr);
 			} catch (NumberFormatException e) {
 				System.out.println(e.getMessage());
 				continue;
 			}
 			if ((midiNote < 0) || (midiNote > 127)) {
 				System.out.println("Invalid MIDI note");
 				continue;
 			}
 
 			System.out.println("Enter note duration in seconds (floating point number):");
 			String durationStr = in.readLine();
 			float duration;
 			try {
 				duration = Float.parseFloat(durationStr);
 			} catch (NumberFormatException e) {
 				System.out.println(e.getMessage());
 				continue;
 			}
 			if (duration <= 0) {
 				System.out.println("Duration must be positive number");
 				continue;
 			}
 
 			System.out.println("Enter pause duration in seconds (floating point number):");
 			String pauseDurationStr = in.readLine();
 			float pauseDuration;
 			try {
 				pauseDuration = Float.parseFloat(pauseDurationStr);
 			} catch (NumberFormatException e) {
 				System.out.println(e.getMessage());
 				continue;
 			}
 			if (pauseDuration < 0) {
 				System.out.println("Duration must be positive number");
 				continue;
 			}
 
 			// store the note into the loop
 			LoopNote loopNote = new LoopNote();
 			loopNote.noteNumber = midiNote;
 			loopNote.durationSamples = (int) (duration * getSampleRate());
 			loopNote.pauseSamples = (int) (pauseDuration * getSampleRate());
 
 			loop.add(loopNote);
 		}
 
 		if (!loop.isEmpty()) {
 			loopIterator = loop.iterator();
 			currentLoopNote = null;
 			playingNote = false;
 			remainingSamples = 0;
 
 			running = true;
 
 			// the client thread is playing now; let the user quit the app
 			System.out.println("Playing; press ENTER to quit");
 			in.readLine();
 		}
 
 		// close the client (disconnect from Jack)
 		close();
 	}
 
 	public static void main(String[] args) throws Exception {
 		if (args.length != 1) {
 			throw new IllegalArgumentException("Expecting single parameter (client name)");
 		}
 		String clientName = args[0];
 
 		MidiSeq midiSeq = new MidiSeq(clientName, false, true, null);
 
 		midiSeq.run();
 	}
 }