Question

I have a problem while recording the audio. I created a servlet and I modified the java sound API demo code to some extent and finally I can record the audio. The problem is that when I play the audio I can see the total time of the audio stored as 645.45 or something like that, but I have been recording the audio only for a couple of mins. One more problem is the audio is getting saved in the Eclipse directory instead of the project directory.

This is the servlet code.

package com;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sound.sampled.AudioFileFormat;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.Clip;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.TargetDataLine;

public class SoundRecorder extends HttpServlet {

    private static final long serialVersionUID = 1L;

    static protected boolean running;
    static ByteArrayOutputStream out;
    double fileName = Math.random(); 
    //strFilename = nowLong.toString();



    public SoundRecorder() {
        System.out.println("Filename will be..." + fileName + ".wav");
    }

    public void init() {

    }

    public void destroy() {

    }


    public void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {  
        System.out.println("call received..");
        String method = request.getParameter("method");
        System.out.println(method);
        if("record".equalsIgnoreCase(method)) {
            captureAudio(true);
        }
        else if("stop".equalsIgnoreCase(method)) {
            captureAudio(false);    
        }
        else if("play".equalsIgnoreCase(method)) {
            System.out.println("yet to write");
            playAudio();
        }
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {  
        System.out.println("call received..");
        String method = request.getParameter("method");
        System.out.println(method);
        doGet(request, response);
    }

    private void captureAudio(boolean capturing) {


            File outputFile = new File(fileName + ".wav");
            AudioFormat audioFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,44100.0F, 16, 2, 4, 44100.0F, false);

            DataLine.Info   info = new DataLine.Info(TargetDataLine.class, audioFormat);
            TargetDataLine  targetDataLine = null;

            try
            {
                targetDataLine = (TargetDataLine) AudioSystem.getLine(info);
                targetDataLine.open(audioFormat);
            }
            catch (LineUnavailableException e)
            {
                System.out.println("unable to get a recording line");
                e.printStackTrace();
                System.exit(1);
            }

            AudioFileFormat.Type    targetType = AudioFileFormat.Type.WAVE;

            final Recorder recorder = new Recorder(targetDataLine,targetType,outputFile);

            System.out.println("Recording...");
            if(capturing){
            recorder.start();
            }
            else {
            recorder.stopRecording();
            }

    }



    private void playAudio() {
        try {
            File file = new File(fileName + ".wav");
            AudioInputStream stream  = AudioSystem.getAudioInputStream(file);
            AudioFormat format = stream.getFormat();
            DataLine.Info info = new DataLine.Info(Clip.class, stream.getFormat());
            Clip clip = (Clip) AudioSystem.getLine(info);
            clip.open(stream);              
            clip.start();
        } catch (Exception e) {
            System.err.println("Line unavailable: " + e);
            System.exit(-4);
        } 
    }
}

And this is the recorder class

public class Recorder extends Thread {
    private TargetDataLine  m_line;
    private AudioFileFormat.Type m_targetType;
    private AudioInputStream m_audioInputStream;
    private File m_outputFile;

    public Recorder(TargetDataLine line,
                     AudioFileFormat.Type targetType,
                     File file)
    {
        m_line = line;
        m_audioInputStream = new AudioInputStream(line);
        m_targetType = targetType;
        m_outputFile = file;
    }

    /** Starts the recording.
        To accomplish this, (i) the line is started and (ii) the
        thread is started.
    */
    public void start()
    {
        m_line.start();
        super.start();
    }

    /** Stops the recording.
    */
    public void stopRecording()
    {
        m_line.stop();
        m_line.close();
    }

    /** Main working method.
    */
    public void run()
    {
            try
            {
                AudioSystem.write(
                    m_audioInputStream,
                    m_targetType,
                    m_outputFile);
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
    }

    private static void closeProgram()
    {
        System.out.println("Program closing.....");
        System.exit(1);
    }

    private static void out(String strMessage)
    {
        System.out.println(strMessage);
    }


}

Answer 1

When developing with servlets, you need to realize that there’s only one servlet instance throughout the whole webapp’s lifetime, from startup until shutdown. So, the HTTP requests from all visitors, all sessions, all browser windows/tabs, etc will all share the same servlet instance. Also, when you make a variable static, it will be shared among all instances of the same class (which is not really relevant here since there’s only one servlet instance anyway).

In other words, those variables which you’ve declared in the servlet are not threadsafe:

static protected boolean running;
static ByteArrayOutputStream out;
double fileName = Math.random(); 

There’s only one of them and they are used by all visitors simultaneously. For the first two variables, which are continuously modified, this will lead to major threadsafety problems and for the third variable this means that all visitors record to the very same file. You need to declare them inside the doGet() block. You’d like to store the recording in the session by an unique request based token as key and then pass that key to the subsequent requests.

---

As to the problem of the file being saved at the unexpected location; when you use relative paths in java.io.File in a servlet, then it will be relative to the directory from where the webserver is started. If you start it from inside Eclipse, then it’s saved in Eclipse directory. You’d like to use absolute path in java.io.File instead. If your intent is to save it in public webcontent (there where your JSP’s and the /WEB-INF folder is located), then you need ServletContext#getRealPath() to convert a web path to an absolute disk path.

String relativeWebPath = "filename.ext";
String absoluteDiskPath = getServletContext().getRealPath(relativeWebPath);
File file = new File(absoluteDiskPath);

There’s however another problem with this: all files will get erased whenever you redeploy the webapp. If you want a bit more permanent storage, then you’d like to store it outside the web project. E.g. C:/path/to/recordings.

File file = new File("C:/path/to/recordings/filename.ext");