Draw profile of the mic input

Question

I don't know much about sounds digitalization. I am trying to represent the instant profile of the mic input. I know how to get the bits from the mic, but I don't know how to interpret it into a profile. Can anyone help me filling the blank?

package test;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.io.IOException;
import java.io.OutputStream;
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.LineUnavailableException;
import javax.sound.sampled.TargetDataLine;
import javax.swing.AbstractAction;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

/**
 *
 * @author François Billioud
 */
public class SoundRecorder extends JFrame {

    /** JFrame for the GUI **/
    public SoundRecorder() {
        super("Sound Recorder");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container pane = getContentPane();
        pane.setLayout(new BorderLayout());
        pane.add(wavePane = new WavePane(), BorderLayout.CENTER);
        pane.add(new JButton(new AbstractAction("ok") {
            @Override
            public void actionPerformed(ActionEvent e) {
                dispose();
            }
        }), BorderLayout.SOUTH);
        setSize(300,300);
        setLocationRelativeTo(null);
    }

    /** Just displays the frame and starts listening **/
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                SoundRecorder rec = new SoundRecorder();
                rec.setVisible(true);
                rec.listenToMic();
            }
        });
    }

    /** Draws the sound read from the mic **/
    private static class WavePane extends JPanel {
        private final int[] x = new int[0];
        private int[] y = new int[0];
        private WavePane() {
            setOpaque(true);
            setBackground(Color.WHITE);
        }
        /** updates the data to be displayed **/
        public void setData(int[] y) {
            this.y = y;
            int n = y.length;
            this.x = new int[n];
            float pas = getWidth()/(float)(n-1);
            float xCurrent = 0;
            for(int i=0; i<n; i++) {
                this.x[i] = Math.round(xCurrent);
                xCurrent+=pas;
            }
            repaint();
        }
        /** Draws a line that represent the mic profile **/
        @Override
        public void paint(Graphics g) {
            super.paint(g);
            Graphics2D g2D = (Graphics2D) g;
            g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
            g2D.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            g2D.drawPolyline(x, y, x.length);
        }
    }

    /** Defines the audio format to be used.
     * I know nothing about that and am open to suggestions if needed
     */
    private static final AudioFormat format = new AudioFormat(
            16000, //Sample rate
            16, //SampleSizeInBits
            2, //Channels
            true,//Signed
            true //BigEndian
    );

    /** Creates a thread that will read data from
     * the mic and send it to the WavePane
     * in order to be painted.
     * We should be using a SwingWorker, but it will do
     * for the sake of this demo.
     **/
    private void listenToMic() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //Open the line and read
                    DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);

                    //checks if system supports the data line
                    if (!AudioSystem.isLineSupported(info)) {
                        System.err.print("Line not supported");
                    }

                    //starts listening
                    TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
                    line.open(format);
                    line.start();

                    //sends the stream to the interpreter
                    AudioInputStream ais = new AudioInputStream(line);
                    AudioSystem.write(ais, AudioFileFormat.Type.AU, new Interpreter());
                } catch (LineUnavailableException | IOException ex) {
                    System.err.println(ex.getLocalizedMessage());
                }
            }
        }).start();
    }

    private final WavePane wavePane;
    private class Interpreter extends OutputStream {
        private int[] y;

        @Override
        public void write(int b) throws IOException {
            //TBD

            //Fill y array
        }

        @Override
        public void flush() throws IOException {
            //Sends the values found to the panel for drawing
            wavePane.setData(y);
        }

    }

}

I found this link but it didn't help me...

Edit: Ok, from what I understand, each 16 bits is the amplitude for one frequency. I have 2 channels, so I have to read 16 bits every 32 to get the first channel. Now I need to know how many frequencies I am going to read for each frame. Then I think I can draw the profile. Any hint?

Answer 1

If you want to draw the spectrum (energy per frequency over time) of the signal that is coming from the microphone then you might want to read this. Maybe a bit more that you wanted to know but it has the maths you need.

If you want to draw the amplitude (the pressure over time) then check, for instance, this.

The contents of the audio stream, based on your specification of the audio format, will be a PCM stream. PCM stream means that every frame is a value of sound pressure at that moment of time. Each frame will consist of four bytes, two bytes per channel. The first two bytes will be channel 0, the other two -- channel 1. The two bytes will be in big endian format (the more significant byte will come before the less significant byte). The fact that you specified signed as True means that you should interpret the values as being in the range from -32768 to 32767.