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.InputStreamReader;
  import java.nio.ByteBuffer;
  import java.util.EnumSet;
  
  import net.sf.jack4j.AbstractJackClient;
  import net.sf.jack4j.JackLocalPort;
  import net.sf.jack4j.JackPortFlag;
  import net.sf.jack4j.util.file.wav.WavFileWriter;
  
  /**
   * Simple WAV recorder.
   * 
   * <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 WavRecorder extends AbstractJackClient {
  
  	private JackLocalPort portL;
  	private JackLocalPort portR;
  	private WavFileWriter wavFileWriter;
  
  	/**
  	 * This is callback method, invoked by Jack client thread every now and
  	 * then.
  	 * 
  	 * <p>
  	 * This method actually works with the sound. As this client has input ports
  	 * registered, each <i>buffer</i> attached to <i>input port</i> will
  	 * contain <code>bufferSize</code> samples before this method is called.
  	 * 
  	 * <p>
  	 * Ports were created earlier, during client initialization.
  	 */
  	@Override
  	public int process(int bufferSize) throws Exception {
  		// we have valid JackLocalPort instances in portL and portR variables; obtain their buffers.
  		ByteBuffer[] buffers = new ByteBuffer[] { portL.getByteBuffer(bufferSize), portR.getByteBuffer(bufferSize) };
  
  		// ALWAYS clear these buffers before use! Otherwise, limit and position would be undefined.
  		// Remember that calling clear() method doesn't really clear the data; it just resets position and limit.
  		for (ByteBuffer buffer : buffers) {
  			buffer.clear();
  		}
  
  		// At this moment, we are ready to go: we can call getFloat method on each of the buffers
  		// exactly bufferSize times.
  		if (wavFileWriter != null) {
  			// synchronize on wavFileWriter, so it won't be closed from the run() method during writing
  			synchronized (wavFileWriter) {
  				// Let WavFileReader do the real work; it's a bit complicated class,
  				// but it ultimately calls getFloat method many times on each buffer.
  				wavFileWriter.writeSamples(buffers, bufferSize);
  			}
  		}
  
  		// indicate that we finished properly
  		return 0;
  	}
  
  	/**
  	 * Constructor.
  	 * 
  	 * <p>
  	 * Registers under given client name, sets the callbacks and adds ports.
  	 */
  	public WavRecorder(String clientName) throws Exception {
  		// Call to super constructor will register us with Jack server
 		super(clientName, false, true, null);
 
 		// 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 a pair of input audio ports
 		portL = addAudioPort("left", EnumSet.of(JackPortFlag.IS_INPUT));
 		portR = addAudioPort("right", EnumSet.of(JackPortFlag.IS_INPUT));
 
 		// we are not activated yet, thus the callbacks won't be invoked
 	}
 
 	/**
 	 * Activation and main event loop.
 	 */
 	public void run() throws Exception {
 		// Activate the client; until now, callbacks weren't invoked
 		activate();
 
 		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 
 		System.out.println("CONNECT SOMETHING TO THE INPUT PORTS, otherwise you'll be recording silence");
 		System.out.println("(you can use jack_connect or qjackctl to do this)");
 
 		while (true) {
 			System.out.print("Enter name of the file to write to, or empty line to quit:");
 			String wavFileName = in.readLine();
 
 			if ("".equals(wavFileName)) {
 				break;
 			}
 
 			System.out.print("Enter number of channels: ");
 			String channelCountStr = in.readLine();
 			int channelCount;
 			try {
 				channelCount = Integer.parseInt(channelCountStr);
 			} catch (NumberFormatException e) {
 				System.err.println("Not a number");
 				continue;
 			}
 			if (channelCount < 1) {
 				System.err.println("Wrong number of channels");
 				continue;
 			}
 
 			System.out.print("Enter number of bits per sample (1-32): ");
 			String bitsPerSampleStr = in.readLine();
 			int bitsPerSample;
 			try {
 				bitsPerSample = Integer.parseInt(bitsPerSampleStr);
 			} catch (NumberFormatException e) {
 				System.err.println("Not a number");
 				continue;
 			}
 			if ((bitsPerSample < 1) || (bitsPerSample > 32)) {
 				System.err.println("Wrong number of bits");
 				continue;
 			}
 
 			try {
 				wavFileWriter = new WavFileWriter(wavFileName, bitsPerSample, getSampleRate(), channelCount);
 			} catch (Exception e) {
 				e.printStackTrace();
 				continue;
 			}
 
 			System.out.print("Recording, press enter to stop... ");
 			in.readLine();
 			try {
 				// synchronize on the wavFileWriter so we won't close the writer during process() method
 				synchronized (wavFileWriter) {
 					wavFileWriter.close();
 					wavFileWriter = null;
 				}
 			} catch (Exception e) {
 				e.printStackTrace();
 				continue;
 			}
 		}
 
 		close();
 	}
 
 	public static void main(String[] args) throws Exception {
 		if (args.length != 1) {
 			System.err.println("Expecting parameter: clientName");
 			return;
 		}
 		WavRecorder wavRecorder = new WavRecorder(args[0]);
 
 		wavRecorder.run();
 	}
 }