multi track audio card accessing

Discussion in 'Java' started by vijay, Jul 3, 2003.

  1. vijay

    vijay Guest

    hallo

    I am programming in java for multi track sound card ( 4 - stereo track
    -- 8 speakers). I need to output 8 mono wav audio file in eight
    different speakers
    for this work I have suceeded by playing two mono files in first 2
    speakers ( first stereo track ) I am now searching to output other
    6 mono files in other 3 different stereo tracks

    how to get the port or details for the other 3 stereo tracks

    I have attached 3 java files which i have used

    <<<<MultiAudioStreamPlayer.java
    <<<<BaseAudioStream.java
    <<<<SimpleAudioStream.java

    for running the below java samples there is no need to have a special
    sound card but make sure to change the WAV file name in
    SimpleAudioStream.java
    program

    I am eagerly waiting for your valuable ideas

    Yours friendly
    vijay

    /*
    * MultiAudioStreamPlayer.java
    *
    * This file is part of the Java Sound Examples.
    */

    /*
    * Copyright (c) 1999 by Matthias Pfisterer
    <>
    *
    *
    * This program is free software; you can redistribute it and/or
    modify
    * it under the terms of the GNU General Public License as published
    * by the Free Software Foundation; either version 2 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 General Public License for more details.
    *
    * You should have received a copy of the GNU General Public
    * License along with this program; if not, write to the Free
    Software
    * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    *
    */


    import java.io.File;

    import java.io.IOException;

    import javax.sound.sampled.AudioFormat;
    import javax.sound.sampled.AudioInputStream;
    import javax.sound.sampled.AudioSystem;
    import javax.sound.sampled.DataLine;
    import javax.sound.sampled.LineUnavailableException;
    import javax.sound.sampled.UnsupportedAudioFileException;
    import javax.sound.sampled.SourceDataLine;

    // import AudioStream;



    /* +DocBookXML
    <title>Playing multiple audio files concurrently</title>

    <formalpara><title>Purpose</title>
    <para>This program plays multiple audio files
    concurrently.
    It opens each file given on the command line and starts it.
    The program uses the class <classname>AudioStream</classname>.</para>
    </formalpara>

    <formalpara><title>Level</title>
    <para>experienced</para></formalpara>

    <formalpara><title>Usage</title>
    <para>
    <cmdsynopsis>
    <command>java MultiAudioStreamPlayer</command>
    <arg choice="plain"
    rep="repeat"><replaceable>audiofile</replaceable></arg>
    </cmdsynopsis>
    </para></formalpara>

    <formalpara><title>Parameters</title>
    <variablelist>
    <varlistentry>
    <term><replaceable>audiofile</replaceable></term>
    <listitem><para>the name(s) of the audio file(s) to
    play</para></listitem>
    </varlistentry>
    </variablelist>
    </formalpara>

    <formalpara><title>Bugs, limitations</title>
    <para>Not well-tested</para></formalpara>

    <formalpara><title>Source code</title>
    <para>
    <ulink url="MultiAudioStreamPlayer.java.html">MultiAudioStreamPlayer.java</ulink>,
    <ulink url="SimpleAudioStream.java.html">SimpleAudioStream.java</ulink>,
    <ulink url="BaseAudioStream.java.html">BaseAudioStream.java</ulink>
    </para>
    </formalpara>

    -DocBookXML
    */
    public class MultiAudioStreamPlayer
    {
    public static void main(String[] args)
    {


    File soundFile_L = new File("77.wav");
    File soundFile_R = new File("88.wav");



    SimpleAudioStream audioStream_L = null;
    SimpleAudioStream audioStream_R = null;









    try
    {





    audioStream_L = new SimpleAudioStream(soundFile_L);
    audioStream_R = new SimpleAudioStream(soundFile_R);




    audioStream_L.setPan(1.0f);

    audioStream_R.setPan(0.0f);



    audioStream_R.start();
    audioStream_L.start();






    }
    catch (LineUnavailableException e)
    {
    /*
    * In case of an exception, we dump the
    * exception including the stack trace
    * to the console output. Then, we exit
    * the program.
    */
    e.printStackTrace();
    System.exit(1);
    }
    catch (UnsupportedAudioFileException e)
    {
    e.printStackTrace();
    System.exit(1);
    }
    catch (IllegalArgumentException e)
    {
    e.printStackTrace();
    System.exit(1);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    System.exit(1);
    }



































    /*



    if (args.length < 1)
    {
    System.out.println("MultiAudioStreamPlayer: usage:");
    System.out.println("\tjava MultiAudioStreamPlayer <soundfile1>
    <soundfile2> ...");
    System.exit(1);
    }




    for (int i = 0; i < args.length; i++)
    {
    String strFilename = args;
    File soundFile = new File(strFilename);




    SimpleAudioStream audioStream = null;
    try
    {
    audioStream = new SimpleAudioStream(soundFile);
    if(i==0)
    audioStream.setPan(1.0f);
    else
    audioStream.setPan(0.0f);
    }
    catch (LineUnavailableException e)
    {
    e.printStackTrace();
    System.exit(1);
    }
    catch (UnsupportedAudioFileException e)
    {
    e.printStackTrace();
    System.exit(1);
    }
    catch (IllegalArgumentException e)
    {
    e.printStackTrace();
    System.exit(1);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    System.exit(1);
    }
    audioStream.start();
    }


    */


    /* closing the sound file after playing */





    }


    }



    /*** MultiAudioStreamPlayer.java ***/


    //_________________________________________________________________________________________________


    /*
    * BaseAudioStream.java
    *
    * This file is part of the Java Sound Examples.
    */

    /*
    * Copyright (c) 1999, 2000 by Matthias Pfisterer
    <>
    *
    *
    * This program is free software; you can redistribute it and/or
    modify
    * it under the terms of the GNU Library General Public License as
    published
    * by the Free Software Foundation; either version 2 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 Library General Public License for more details.
    *
    * You should have received a copy of the GNU Library General Public
    * License along with this program; if not, write to the Free
    Software
    * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    *
    */


    import java.beans.PropertyChangeListener;
    import java.beans.PropertyChangeSupport;


    import java.io.File;
    import java.io.IOException;

    import java.net.URL;

    import javax.sound.sampled.AudioFormat;
    import javax.sound.sampled.AudioInputStream;
    import javax.sound.sampled.AudioSystem;
    import javax.sound.sampled.DataLine;
    import javax.sound.sampled.LineUnavailableException;
    import javax.sound.sampled.SourceDataLine;
    import javax.sound.sampled.UnsupportedAudioFileException;
    import javax.sound.sampled.FloatControl;




    public class BaseAudioStream
    implements Runnable
    {
    /** Flag for debugging messages.
    * If true, some messages are dumped to the console
    * during operation.
    */
    private static boolean DEBUG = true;

    /**
    * means that the stream has reached EOF or was not started.
    * This value is returned in property change callbacks that
    * report the current media position.
    */
    public static final long MEDIA_POSITION_EOF = -1L;
    public static final String MEDIA_POSITION_PROPERTY =
    "BaseAudioStream_media_position";

    // TODO: better size
    private static final int EXTERNAL_BUFFER_SIZE = 4000 * 4;

    private Thread m_thread = null;
    private Object m_dataSource;
    private AudioInputStream m_audioInputStream;
    private SourceDataLine m_line;
    private FloatControl m_gainControl;
    private FloatControl m_panControl;


    /**
    * This variable is used to distinguish stopped state from
    * paused state. In case of paused state, m_bRunning is still
    * true. In case of stopped state, it is set to false. Doing so
    * will terminate the thread.
    */
    private boolean m_bRunning;


    protected BaseAudioStream()
    {
    m_dataSource = null;
    m_audioInputStream = null;
    m_line = null;
    m_gainControl = null;
    m_panControl = null;
    }



    protected void setDataSource(File file)
    throws UnsupportedAudioFileException, LineUnavailableException,
    IOException
    {
    m_dataSource = file;
    initAudioInputStream();
    }



    protected void setDataSource(URL url)
    throws UnsupportedAudioFileException, LineUnavailableException,
    IOException
    {
    m_dataSource = url;
    initAudioInputStream();
    }



    private void initAudioInputStream()
    throws UnsupportedAudioFileException, LineUnavailableException,
    IOException
    {
    if (m_dataSource instanceof URL)
    {
    initAudioInputStream((URL) m_dataSource);
    }
    else if (m_dataSource instanceof File)
    {
    initAudioInputStream((File) m_dataSource);
    }
    }



    private void initAudioInputStream(File file)
    throws UnsupportedAudioFileException, IOException
    {
    /*
    try
    {
    */
    m_audioInputStream = AudioSystem.getAudioInputStream(file);
    /*
    }
    catch (IOException e)
    {
    throw new IllegalArgumentException("cannot create AudioInputStream
    for " + file);
    }
    if (m_audioInputStream == null)
    {
    throw new IllegalArgumentException("cannot create AudioInputStream
    for " + file);
    }
    */
    }



    private void initAudioInputStream(URL url)
    throws UnsupportedAudioFileException, IOException
    {
    /*
    try
    {
    */
    m_audioInputStream = AudioSystem.getAudioInputStream(url);
    /*
    }
    catch (IOException e)
    {
    throw new IllegalArgumentException("cannot create AudioInputStream
    for " + url);
    }
    if (m_audioInputStream == null)
    {
    throw new IllegalArgumentException("cannot create AudioInputStream
    for " + url);
    }
    */
    }



    // from AudioPlayer.java
    /*
    * Compressed audio data cannot be fed directely to
    * Java Sound. It has to be converted explicitely.
    * To do this, we create a new AudioFormat that
    * says to which format we want to convert to. Then,
    * we try to get a converted AudioInputStream.
    * Furthermore, we use the new format and the converted
    * stream.
    *
    * Note that the technique shown here is partly non-
    * portable. It is used here to keep the example
    * simple. A more advanced, more portable technique
    * will (hopefully) show up in BaseAudioStream.java soon.
    *
    * Thanks to Christoph Hecker for finding out that this
    * was missing.
    */
    /*
    if ((audioFormat.getEncoding() == AudioFormat.Encoding.ULAW) ||
    (audioFormat.getEncoding() == AudioFormat.Encoding.ALAW))
    {
    if (DEBUG)
    {
    System.out.println("AudioPlayer.main(): converting");
    }
    AudioFormat newFormat = new AudioFormat(
    AudioFormat.Encoding.PCM_SIGNED,
    audioFormat.getSampleRate(),
    audioFormat.getSampleSizeInBits() * 2,
    audioFormat.getChannels(),
    audioFormat.getFrameSize() * 2,
    audioFormat.getFrameRate(),
    true);
    AudioInputStream newStream =
    AudioSystem.getAudioInputStream(newFormat, audioInputStream);
    audioFormat = newFormat;
    audioInputStream = newStream;
    }
    */



    protected void initLine()
    throws LineUnavailableException
    {
    if (m_line == null)
    {
    createLine();
    openLine();
    }
    else
    {
    AudioFormat lineAudioFormat = m_line.getFormat();
    AudioFormat audioInputStreamFormat = m_audioInputStream == null ?
    null : m_audioInputStream.getFormat();
    if (!lineAudioFormat.equals(audioInputStreamFormat))
    {
    m_line.close();
    openLine();
    }
    }
    }



    private void createLine()
    throws LineUnavailableException
    {
    if (m_line != null)
    {
    return;
    }
    /*
    * From the AudioInputStream, i.e. from the sound file, we
    * fetch information about the format of the audio data. These
    * information include the sampling frequency, the number of
    * channels and the size of the samples. There information
    * are needed to ask Java Sound for a suitable output line
    * for this audio file.
    */
    AudioFormat audioFormat = m_audioInputStream.getFormat();
    if (DEBUG)
    {
    System.out.println("BaseAudioStream.initLine(): audio format: " +
    audioFormat);
    }

    /*
    * Asking for a line is a rather tricky thing.
    * ...
    * Furthermore, we have to give Java Sound a hint about how
    * big the internal buffer for the line should be. Here,
    * we say AudioSystem.NOT_SPECIFIED, signaling that we don't
    * care about the exact size. Java Sound will use some default
    * value for the buffer size.
    */
    DataLine.Info info = new DataLine.Info(SourceDataLine.class,
    audioFormat, AudioSystem.NOT_SPECIFIED);
    m_line = (SourceDataLine) AudioSystem.getLine(info);

    if (m_line.isControlSupported(FloatControl.Type.MASTER_GAIN/*VOLUME*/))
    {
    m_gainControl = (FloatControl)
    m_line.getControl(FloatControl.Type.MASTER_GAIN);
    if (DEBUG)
    {
    System.out.println("max gain: " + m_gainControl.getMaximum());
    System.out.println("min gain: " + m_gainControl.getMinimum());
    System.out.println("gain precision: " +
    m_gainControl.getPrecision());
    }
    }
    else
    {
    if (DEBUG)
    {
    System.out.println("FloatControl.Type.MASTER_GAIN is not
    supported");
    }
    }
    if (m_line.isControlSupported(FloatControl.Type.PAN/*BALANCE*/))
    {
    m_panControl = (FloatControl)
    m_line.getControl(FloatControl.Type.PAN);
    if (DEBUG)
    {
    System.out.println("max balance: " + m_panControl.getMaximum());
    System.out.println("min balance: " + m_panControl.getMinimum());
    System.out.println("balance precision: " +
    m_panControl.getPrecision());
    }
    }
    else
    {
    if (DEBUG)
    {
    System.out.println("FloatControl.Type.PAN is not supported");
    }
    }
    }



    private void openLine()
    throws LineUnavailableException
    {
    if (m_line == null)
    {
    return;
    }
    AudioFormat audioFormat = m_audioInputStream.getFormat();
    m_line.open(audioFormat, m_line.getBufferSize());
    }



    // TODO: if class can be instatiated without file or url,
    m_audioInputStream may
    // be null
    protected AudioFormat getFormat()
    {
    return m_audioInputStream.getFormat();
    }



    public void start()
    {
    if (DEBUG)
    {
    System.out.println("start() called");
    }
    if (!(m_thread == null || !m_thread.isAlive()))
    {
    if (DEBUG)
    {
    System.out.println("WARNING: old thread still running!!");
    }
    }
    if (DEBUG)
    {
    System.out.println("creating new thread");
    }
    m_thread = new Thread(this);
    m_thread.start();
    if (DEBUG)
    {
    System.out.println("additional thread started");
    }
    if (DEBUG)
    {
    System.out.println("starting line");
    }
    m_line.start();
    }



    protected void stop()
    {
    if (m_bRunning)
    {
    if (m_line != null)
    {
    m_line.stop();
    m_line.flush();
    }
    m_bRunning = false;
    /*
    * We re-initialize the AudioInputStream. Since doing
    * a stop on the stream implies that there has been
    * a successful creation of an AudioInputStream before,
    * we can almost safely ignore this exception.
    * The LineUnavailableException can be ignored because
    * in case of reinitializing the same AudioInputStream,
    * no new line is created or opened.
    */
    try
    {
    initAudioInputStream();
    }
    catch (UnsupportedAudioFileException e)
    {
    }
    catch (LineUnavailableException e)
    {
    }
    catch (IOException e)
    {
    }
    }
    }



    public void pause()
    {
    m_line.stop();
    }



    public void resume()
    {
    m_line.start();
    }



    public void run()
    {
    if (DEBUG)
    {
    System.out.println("thread start");
    }
    int nBytesRead = 0;
    m_bRunning = true;
    byte[] abData = new byte[EXTERNAL_BUFFER_SIZE];
    // int nFrameSize = m_line.getFormat().getFrameSize();
    while (nBytesRead != -1 && m_bRunning)
    {
    try
    {
    nBytesRead = m_audioInputStream.read(abData, 0, abData.length);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    }
    if (nBytesRead >= 0)
    {
    //int nFramesToWrite = nBytesRead / nFrameSize;
    if (DEBUG)
    {
    System.out.println("Trying to write: " + nBytesRead);
    }
    int nBytesWritten = m_line.write(abData, 0, nBytesRead);
    if (DEBUG)
    {
    System.out.println("Written: " + nBytesWritten);
    }
    }
    }



    /*
    * Wait until all data are played.
    * This is only necessary because of the bug noted below.
    * (If we do not wait, we would interrupt the playback by
    * prematurely closing the line and exiting the VM.)
    */
    // TODO: check how this interferes with stop()
    m_line.drain();
    if (DEBUG)
    {
    System.out.println("after drain()");
    }

    /*
    * Stop the line and reinitialize the AudioInputStream.
    * This should be done before reporting end-of-media to be
    * prepared if the EOM message triggers a new start().
    */
    stop();



    if (DEBUG)
    {
    System.out.println("after this.stop()");



    }

    }


    public boolean hasGainControl()
    {
    return m_gainControl != null;
    }

    /*
    public void setMute(boolean bMute)
    {
    if (hasGainControl())
    {
    m_gainControl.setMute(bMute);
    }
    }



    public boolean getMute()
    {
    if (hasGainControl())
    {
    return m_gainControl.getMute();
    }
    else
    {
    return false;
    }
    }
    */



    public void setGain(float fGain)
    {
    if (hasGainControl())
    {
    m_gainControl.setValue(fGain);
    }
    }



    public float getGain()
    {
    if (hasGainControl())
    {
    return m_gainControl.getValue();
    }
    else
    {
    return 0.0F;
    }
    }


    public float getMaximum()
    {
    if (hasGainControl())
    {
    return m_gainControl.getMaximum();
    }
    else
    {
    return 0.0F;
    }
    }


    public float getMinimum()
    {
    if (hasGainControl())
    {
    return m_gainControl.getMinimum();
    }
    else
    {
    return 0.0F;
    }
    }


    public boolean hasPanControl()
    {
    return m_panControl != null;
    }



    public float getPrecision()
    {
    if (hasPanControl())
    {
    return m_panControl.getPrecision();
    }
    else
    {
    return 0.0F;
    }
    }



    public float getPan()
    {
    if (hasPanControl())
    {
    return m_panControl.getValue();
    }
    else
    {
    return 0.0F;
    }
    }



    public void setPan(float fPan)
    {
    if (hasPanControl())
    {
    m_panControl.setValue(fPan);
    }
    }





    }



    /*** BaseAudioStream.java ***/


    //----------------------------------------------------------------------------------------


    /*
    * SimpleAudioStream.java
    *
    * This file is part of the Java Sound Examples.
    */

    /*
    * Copyright (c) 1999, 2000 by Matthias Pfisterer
    <>
    *
    *
    * This program is free software; you can redistribute it and/or
    modify
    * it under the terms of the GNU Library General Public License as
    published
    * by the Free Software Foundation; either version 2 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 Library General Public License for more details.
    *
    * You should have received a copy of the GNU Library General Public
    * License along with this program; if not, write to the Free
    Software
    * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    *
    */


    import java.beans.PropertyChangeListener;
    import java.beans.PropertyChangeSupport;


    import java.io.File;
    import java.io.IOException;

    import java.net.URL;

    import javax.sound.sampled.AudioFormat;
    import javax.sound.sampled.AudioInputStream;
    import javax.sound.sampled.AudioSystem;
    import javax.sound.sampled.DataLine;
    import javax.sound.sampled.LineUnavailableException;
    import javax.sound.sampled.SourceDataLine;
    import javax.sound.sampled.UnsupportedAudioFileException;
    import javax.sound.sampled.FloatControl;



    public class SimpleAudioStream
    extends BaseAudioStream
    {
    /** Flag for debugging messages.
    * If true, some messages are dumped to the console
    * during operation.
    */
    private static boolean DEBUG = true;

    // private static final int EXTERNAL_BUFFER_SIZE = 16384;



    /**
    * This variable is used to distinguish stopped state from
    * paused state. In case of paused state, m_bRunning is still
    * true. In case of stopped state, it is set to false. Doing so
    * will terminate the thread.
    */
    private boolean m_bRunning;


    public SimpleAudioStream()
    {
    super();
    // m_dataSource = null;
    }



    public SimpleAudioStream(File file)
    throws UnsupportedAudioFileException, LineUnavailableException,
    IOException
    {
    this();
    setDataSource(file);
    initLine();
    }



    public SimpleAudioStream(URL url)
    throws UnsupportedAudioFileException, LineUnavailableException,
    IOException
    {
    this();
    setDataSource(url);
    initLine();
    }




    public AudioFormat getFormat()
    {
    // TODO: have to check that AudioInputStream (or Line?) is
    initialized
    return super.getFormat();
    }


    /*
    public void start()
    {
    if (DEBUG)
    {
    System.out.println("start() called");
    }
    m_thread = new Thread(this);
    m_thread.start();
    if (DEBUG)
    {
    System.out.println("additional thread started");
    }
    m_line.start();
    if (DEBUG)
    {
    System.out.println("started line");
    }
    }



    public void stop()
    {
    m_line.stop();
    m_line.flush();
    m_bRunning = false;
    }



    public void pause()
    {
    m_line.stop();
    }



    public void resume()
    {
    m_line.start();
    }
    */


    /*
    public void run()
    {
    if (DEBUG)
    {
    System.out.println("thread start");
    }
    int nBytesRead = 0;
    m_bRunning = true;
    byte[] abData = new byte[EXTERNAL_BUFFER_SIZE];
    int nFrameSize = m_line.getFormat().getFrameSize();
    while (nBytesRead != -1 && m_bRunning)
    {
    try
    {
    nBytesRead = m_audioInputStream.read(abData, 0, abData.length);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    }
    if (nBytesRead >= 0)
    {
    int nRemainingBytes = nBytesRead;
    // while (nRemainingBytes > 0)
    //{
    if (DEBUG)
    {
    System.out.println("Line status (active): " +
    m_line.isActive());
    System.out.println("Line status (running): " +
    m_line.isRunning());
    System.out.println("Trying to write (bytes): " + nBytesRead);
    }
    int nBytesWritten = m_line.write(abData, 0, nBytesRead);
    if (DEBUG)
    {
    System.out.println("Written (bytes): " + nBytesWritten);
    }
    nRemainingBytes -= nBytesWritten;
    //}
    }
    }
    if (DEBUG)
    {
    System.out.println("after main loop");
    }
    }
    */

    }



    /*** SimpleAudioStream.java ***/
     
    vijay, Jul 3, 2003
    #1
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Dvd audio track

    , May 21, 2005, in forum: C++
    Replies:
    0
    Views:
    322
  2. aeonsun
    Replies:
    2
    Views:
    433
    Luc The Perverse
    Mar 11, 2007
  3. Alex Karpinski

    Python Multi-Channel Audio

    Alex Karpinski, Jul 8, 2010, in forum: Python
    Replies:
    0
    Views:
    196
    Alex Karpinski
    Jul 8, 2010
  4. geremy condra

    Re: Python Multi-Channel Audio

    geremy condra, Jul 8, 2010, in forum: Python
    Replies:
    0
    Views:
    597
    geremy condra
    Jul 8, 2010
  5. sick dick
    Replies:
    0
    Views:
    393
    sick dick
    Apr 3, 2006
Loading...

Share This Page