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.IOException;
  import java.nio.ByteBuffer;
  import java.util.EnumSet;
  
  import net.sf.jack4j.AbstractJackClient;
  import net.sf.jack4j.JackException;
  import net.sf.jack4j.JackLocalMidiPort;
  import net.sf.jack4j.JackLocalPort;
  import net.sf.jack4j.JackMidiEvent;
  import net.sf.jack4j.JackMidiPortBuffer;
  import net.sf.jack4j.JackPortFlag;
  
  /**
   * Very simple MIDI synthesizer.
   * 
   * <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 MidiSine extends AbstractJackClient {
  
  	/**
  	 * Pre-computed frequencies (Hz) of MIDI notes #0-#127.
  	 */
  	private static float[] midiNoteFreq;
  	static {
  		midiNoteFreq = new float[128];
  		for (int i = 0; i < 127; i++) {
  			midiNoteFreq[i] = (float) ((440.0f / 32) * Math.pow(2, (i - 9) / 12.0f));
  		}
  	}
  
  	private JackLocalMidiPort midiIn;
  	private JackLocalPort audioOut;
  
  	private float currentPhase;
  	private int currentNote;
  	private float currentVolume;
  
  	/**
  	 * This is callback method, invoked by Jack client thread during each
  	 * process cycle.
  	 * 
  	 * <p>
  	 * This method receives MIDI events and 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>
  	 * The method also reads MIDI events from the buffer associated with the
  	 * <i>input MIDI port</i>,
  	 * 
  	 * <p>
  	 * Ports were created earlier, during client initialization.
  	 */
  	@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();
  
  		// the MIDI buffers are handled in a different way than audio buffers: 
  		JackMidiPortBuffer inBuffer = midiIn.initializeMidiBuffer(bufferSize);
  
  		// There may be any number of events in the buffer. They may be retrieved by index.
  		// Each event "happens" on a certain time during current process cycle.
  		// The "time" property of the event 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.
 		int nextEventIndex = 0;
 		JackMidiEvent nextEvent = (inBuffer.getEventCount() > 0) ? inBuffer.getEvent(0) : null;
 
 		int sampleRate = getSampleRate();
 
 		// Simultaneously process MIDI events and produce sound.
 		// Iterate through all sample points in the current process cycle.
 		for (int i = 0; i < bufferSize; i++) {
 			while ((nextEvent != null) && (nextEvent.getTime() == i)) {
 				// The MIDI event occurs now; process it.
 
 				// The returned byte array will contain the actual MIDI octets.
 				byte[] data = nextEvent.getData();
 
 				// Test the first octet (MIDI command):
 				if (data[0] == (byte) 0x80) { // NOTE OFF
 					// The second octet contains MIDI note number.
 					// If it's the note we're currently playing, stop playing it.
 					if (currentNote == data[1]) {
 						System.out.println("Switching note OFF");
 						currentNote = -1;
 					}
 				} else if (data[0] == (byte) 0x90) { // NOTE ON
 					// The second octet contains MIDI note number,
 					// and the third octet contains velocity (volume).
 					currentNote = data[1];
 					currentPhase = 0.0f;
 					currentVolume = ((float) data[2]) / 0x7f;
 					System.out.println("Playing note " + currentNote + " at volume " + currentVolume);
 				}
 
 				// fetch the following event
 				nextEventIndex++;
 				nextEvent = (nextEventIndex < inBuffer.getEventCount()) ? inBuffer.getEvent(nextEventIndex) : null;
 			}
 
 			// Now, let's calculate the next audio sample.
 			float sample;
 
 			if (currentNote < 0) {
 				// produce silence
 				sample = 0.0f;
 			} else {
 				// produce sound at correct frequency
 				sample = (float) (currentVolume * Math.sin(2 * Math.PI * currentPhase));
 
 				// increase the phase for the next sample
 				currentPhase += midiNoteFreq[currentNote] / sampleRate;
 				if (currentPhase > 1.0) {
 					currentPhase -= 1.0;
 				}
 			}
 
 			// Put the computed sample into output buffer.
 			outBuffer.putFloat(sample);
 		}
 
 		return 0;
 	}
 
 	public MidiSine(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 input MIDI port.
 		midiIn = addMidiPort("in", EnumSet.of(JackPortFlag.IS_INPUT));
 
 		// Add output audio port.
 		audioOut = addAudioPort("out", EnumSet.of(JackPortFlag.IS_OUTPUT));
 
 		currentNote = -1;
 		currentPhase = 0.0f;
 
 		// we are not activated yet, thus the callbacks won't be invoked
 	}
 
 	/**
 	 * Activation and main event loop.
 	 */
 	public void run() throws JackException {
 		// Activate the client; until now, callbacks weren't invoked
 		activate();
 
 		System.out.println("CONNECT BOTH PORTS created by the client");
 		System.out.println("You can connect the output audio port to the soundcard to hear the sound,");
 		System.out.println("and connect MIDI keyboard (vkeybd, for example) to the input MIDI port.");
 
 		// wait for user input; the Jack thread runs simultaneously
 		System.out.println("Press any key to quit.");
 		try {
 			System.in.read();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 
 		// 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];
 
 		MidiSine midiSine = new MidiSine(clientName, false, true, null);
 
 		midiSine.run();
 	}
 }