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.File;
  import java.io.FileInputStream;
  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.WavFileReader;
  
  /**
   * Simple WAV player.
   * 
   * <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 WavPlayer extends AbstractJackClient {
  
  	private JackLocalPort portL;
  	private JackLocalPort portR;
  	private WavFileReader wavFileReader;
  
  	/**
  	 * This is callback method, invoked by Jack client thread every now and
  	 * then.
  	 * 
  	 * <p>
  	 * This method actually produces the sound. As this client only outputs the
  	 * sound, the method is expected to put <code>bufferSize</code> samples
  	 * into <i>buffer</i> associated with each <i>port</i>.
  	 * 
  	 * <p>
  	 * Ports were 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 synchronzied method.
  	 */
  	@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:
  		for (ByteBuffer buffer : buffers) {
  			buffer.clear();
  		}
  
  		if (wavFileReader != null) {
  			// Let WavFileReader do the real work; it's a bit complicated class,
  			// but it ultimately calls putFloat method many times on each buffer.
  			int samplesRead = wavFileReader.readSamples(buffers, bufferSize);
  
  			if (samplesRead < bufferSize) {
  				// the WavFileReader couldn't read enough samples, which means that
  				// it reached end of file. Throw the reader away.
  				wavFileReader = null;
  			}
  		}
  
  		// Fill the rest of buffers with silence (in case there's no WAV to play,
  		// or in case when the end of file was reached
  		for (ByteBuffer buffer : buffers) {
  			// compute position in samples
  			int samplePosition = buffer.position() / (Float.SIZE / 8);
 
 			for (int i = samplePosition; i < bufferSize; i++) {
 				// put zero sample into output buffer
 				buffer.putFloat(0.0f);
 			}
 		}
 
 		// return zero, which indicates that method finished correctly
 		return 0;
 	}
 
 	/**
 	 * Constructor.
 	 * 
 	 * <p>
 	 * Registers under given client name, sets the callbacks and adds ports.
 	 */
 	public WavPlayer(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 output audio ports
 		portL = addAudioPort("left", EnumSet.of(JackPortFlag.IS_OUTPUT));
 		portR = addAudioPort("right", EnumSet.of(JackPortFlag.IS_OUTPUT));
 
 		// 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 OUTPUT PORTS to audio card, or you'll not hear any sound");
 		System.out.println("(you can use jack_connect or qjackctl to do this)");
 
 		System.out.println("Enter WAV file name to play, or empty line to quit");
 		while (true) {
 			System.out.print("file name> ");
 			String wavFileName = in.readLine();
 
 			if ("".equals(wavFileName)) {
 				break;
 			} else {
 				File wavFile = new File(wavFileName);
 				if (!wavFile.exists()) {
 					System.err.println("File not found");
 					continue;
 				}
 
 				try {
 					wavFileReader = new WavFileReader((new FileInputStream(wavFile)).getChannel());
 				} catch (Exception e) {
 					e.printStackTrace();
 					continue;
 				}
 
 				System.out.println("WAV file: " + wavFileName);
 				System.out.println("Avg bytes per second: " + wavFileReader.getAvgBytesPerSecond());
 				System.out.println("Bits per sample: " + wavFileReader.getBitsPerSample());
 				System.out.println("Block align: " + wavFileReader.getBlockAlign());
 				System.out.println("Channel count: " + wavFileReader.getChannelCount());
 				System.out.println("Samples per second: " + wavFileReader.getSamplesPerSecond());
 			}
 		}
 
 		close();
 	}
 
 	public static void main(String[] args) throws Exception {
 		if (args.length != 1) {
 			System.err.println("Expecting parameter: clientName");
 			return;
 		}
 		WavPlayer wavPlayer = new WavPlayer(args[0]);
 
 		wavPlayer.run();
 	}
 }