content: /*
   *	AudioCommon.java
   *
   *	This file is part of jsresources.org
   */
  
  /*
   * Portions Copyright (c) 2007 DFKI GmbH.
   * Portions Copyright (c) 1999 - 2001 by Matthias Pfisterer
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * - Redistributions of source code must retain the above copyright notice,
   *   this list of conditions and the following disclaimer.
   * - Redistributions in binary form must reproduce the above copyright
   *   notice, this list of conditions and the following disclaimer in the
   *   documentation and/or other materials provided with the distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  /*
  |<---            this code is formatted to fit into 80 columns             --->|
  */
  
  package org.jsresources;
  
  import lib.sound.sampled.AudioFileFormat;
  import lib.sound.sampled.AudioFormat;
  import lib.sound.sampled.AudioSystem;
  import lib.sound.sampled.DataLine;
  import lib.sound.sampled.Line;
  import lib.sound.sampled.LineUnavailableException;
  import lib.sound.sampled.Mixer;
  import lib.sound.sampled.SourceDataLine;
  import lib.sound.sampled.TargetDataLine;
  
  
  /**
   * Common methods for audio examples.
   */
  public class AudioCommon {
      private static boolean DEBUG = false;
  
  
      public static void setDebug(boolean bDebug) {
          DEBUG = bDebug;
      }
  
  
      /**
       * TODO:
       */
      public static void listSupportedTargetTypes() {
          String strMessage = "Supported target types:";
          AudioFileFormat.Type[] aTypes = AudioSystem.getAudioFileTypes();
          for (int i = 0; i < aTypes.length; i++) {
              strMessage += " " + aTypes[i].getExtension();
          }
          out(strMessage);
      }
  
  
      /**
       * Trying to get an audio file type for the passed extension.
       * This works by examining all available file types. For each
       * type, if the extension this type promisses to handle matches
       * the extension we are trying to find a type for, this type is
       * returned.
       * If no appropriate type is found, null is returned.
       */
      public static AudioFileFormat.Type findTargetType(String strExtension) {
          AudioFileFormat.Type[] aTypes = AudioSystem.getAudioFileTypes();
          for (int i = 0; i < aTypes.length; i++) {
              if (aTypes[i].getExtension().equals(strExtension)) {
                  return aTypes[i];
              }
          }
          return null;
      }
  
  
      /**
       * TODO:
       */
      public static void listMixersAndExit() {
          out("Available Mixers:");
          Mixer.Info[] aInfos = AudioSystem.getMixerInfo();
          for (int i = 0; i < aInfos.length; i++) {
              out(aInfos[i].getName());
          }
          if (aInfos.length == 0) {
              out("[No mixers available]");
          }
          System.exit(0);
      }
  
  
      /**
       * List Mixers.
       * Only Mixers that support either TargetDataLines or SourceDataLines
       * are listed, depending on the value of bPlayback.
       */
      public static void listMixersAndExit(boolean bPlayback) {
          out("Available Mixers:");
          Mixer.Info[] aInfos = AudioSystem.getMixerInfo();
          for (int i = 0; i < aInfos.length; i++) {
              Mixer mixer = AudioSystem.getMixer(aInfos[i]);
              Line.Info lineInfo = new Line.Info(bPlayback ?
                      SourceDataLine.class :
                      TargetDataLine.class);
              if (mixer.isLineSupported(lineInfo)) {
                  out(aInfos[i].getName());
              }
          }
          if (aInfos.length == 0) {
              out("[No mixers available]");
          }
          System.exit(0);
      }
  
  
      /**
       * TODO:
       * This method tries to return a Mixer.Info whose name
       * matches the passed name. If no matching Mixer.Info is
       * found, null is returned.
       */
      public static Mixer.Info getMixerInfo(String strMixerName) {
          Mixer.Info[] aInfos = AudioSystem.getMixerInfo();
          for (int i = 0; i < aInfos.length; i++) {
              if (aInfos[i].getName().equals(strMixerName)) {
                  return aInfos[i];
              }
          }
          return null;
      }
  
  
      /**
       * TODO:
       */
      public static TargetDataLine getTargetDataLine(String strMixerName,
                                                     AudioFormat audioFormat,
                                                     int nBufferSize) {
          /*
              Asking for a line is a rather tricky thing.
  			We have to construct an Info object that specifies
  			the desired properties for the line.
  			First, we have to say which kind of line we want. The
  			possibilities are: SourceDataLine (for playback), Clip
  			(for repeated playback)	and TargetDataLine (for
  			 recording).
  			Here, we want to do normal capture, so we ask for
  			a TargetDataLine.
  			Then, we have to pass an AudioFormat object, so that
  			the Line knows which format the data passed to it
  			will have.
  			Furthermore, we can give Java Sound a hint about how
  			big the internal buffer for the line should be. This
  			isn't used here, signaling that we
  			don't care about the exact size. Java Sound will use
  			some default value for the buffer size.
  		*/
          TargetDataLine targetDataLine = null;
          DataLine.Info info = new DataLine.Info(TargetDataLine.class,
                  audioFormat, nBufferSize);
          try {
              if (strMixerName != null) {
                  Mixer.Info mixerInfo = getMixerInfo(strMixerName);
                  if (mixerInfo == null) {
                      out("AudioCommon.getTargetDataLine(): mixer not found: " + strMixerName);
                      return null;
                  }
                  Mixer mixer = AudioSystem.getMixer(mixerInfo);
                  targetDataLine = (TargetDataLine) mixer.getLine(info);
              } else {
                  if (DEBUG) {
                      out("AudioCommon.getTargetDataLine(): using default mixer");
                  }
                  targetDataLine = (TargetDataLine) AudioSystem.getLine(info);
              }
  
  			/*
               *	The line is there, but it is not yet ready to
  			 *	receive audio data. We have to open the line.
  			 */
              if (DEBUG) {
                  out("AudioCommon.getTargetDataLine(): opening line...");
              }
              targetDataLine.open(audioFormat, nBufferSize);
              if (DEBUG) {
                  out("AudioCommon.getTargetDataLine(): opened line");
              }
          } catch (LineUnavailableException e) {
              if (DEBUG) {
                  e.printStackTrace();
              }
          } catch (Exception e) {
              if (DEBUG) {
                  e.printStackTrace();
              }
          }
          if (DEBUG) {
              out("AudioCommon.getTargetDataLine(): returning line: " + targetDataLine);
          }
          return targetDataLine;
      }
  
  
      /**
       * Checks if the encoding is PCM.
       */
      public static boolean isPcm(AudioFormat.Encoding encoding) {
          return encoding.equals(AudioFormat.Encoding.PCM_SIGNED)
                  || encoding.equals(AudioFormat.Encoding.PCM_UNSIGNED);
      }
  
  
      /**
       * TODO:
       */
      private static void out(String strMessage) {
          System.out.println(strMessage);
      }
  
  
  }
  
  
  /***
   * AudioCommon.java
   ***/
  