title: Live audio stream java
body: <p>I am implementing live streaming from MIC to java server at another PC. But I am only hearing a white noise.</p>
  
  <p>I have attached both client and server program</p>
  
  <pre><code>Client:
  
  import java.io.IOException;
  import java.net.DatagramPacket;
  import java.net.DatagramSocket;
  import java.net.InetAddress;
  import java.net.SocketException;
  import java.net.UnknownHostException;
  
  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;
  
  public class Mic 
  {
      public byte[] buffer;
      private int port;
      static AudioInputStream ais;
  
      public static void main(String[] args)
      {
          TargetDataLine line;
          DatagramPacket dgp; 
  
          AudioFormat.Encoding encoding = AudioFormat.Encoding.PCM_SIGNED;
          float rate = 44100.0f;
          int channels = 2;
          int sampleSize = 16;
          boolean bigEndian = true;
          InetAddress addr;
  
  
          AudioFormat format = new AudioFormat(encoding, rate, sampleSize, channels, (sampleSize / 8) * channels, rate, bigEndian);
  
          DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
          if (!AudioSystem.isLineSupported(info)) {
              System.out.println("Line matching " + info + " not supported.");
              return;
          }
  
          try
          {
              line = (TargetDataLine) AudioSystem.getLine(info);
  
              int buffsize = line.getBufferSize()/5;
              buffsize += 512; 
  
              line.open(format);
  
              line.start();   
  
              int numBytesRead;
              byte[] data = new byte[buffsize];
  
              addr = InetAddress.getByName("127.0.0.1");
              DatagramSocket socket = new DatagramSocket();
              while (true) {
                     // Read the next chunk of data from the TargetDataLine.
                     numBytesRead =  line.read(data, 0, data.length);
                     // Save this chunk of data.
                     dgp = new DatagramPacket (data,data.length,addr,50005);
  
                     socket.send(dgp);
                  }
  
          }catch (LineUnavailableException e) {
              e.printStackTrace();
          }catch (UnknownHostException e) {
              // TODO: handle exception
          } catch (SocketException e) {
              // TODO: handle exception
          } catch (IOException e2) {
              // TODO: handle exception
          }
      }
  }
  </code></pre>
  
  <p>and the server side is no issue. It is running perfectly with android client AudioRecord.</p>
  
  <pre><code>Server:
  
  import java.io.ByteArrayInputStream;
  import java.net.DatagramPacket;
  import java.net.DatagramSocket;
  
  import javax.sound.sampled.AudioFormat;
  import javax.sound.sampled.AudioInputStream;
  import javax.sound.sampled.AudioSystem;
  import javax.sound.sampled.DataLine;
  import javax.sound.sampled.SourceDataLine;
  
  public class Server {
  
      AudioInputStream audioInputStream;
      static AudioInputStream ais;
      static AudioFormat format;
      static boolean status = true;
      static int port = 50005;
      static int sampleRate = 44100;
  
      static DataLine.Info dataLineInfo;
      static SourceDataLine sourceDataLine;
  
      public static void main(String args[]) throws Exception 
      {
          System.out.println("Server started at port:"+port);
  
          DatagramSocket serverSocket = new DatagramSocket(port);
  
          /**
           * Formula for lag = (byte_size/sample_rate)*2
           * Byte size 9728 will produce ~ 0.45 seconds of lag. Voice slightly broken.
           * Byte size 1400 will produce ~ 0.06 seconds of lag. Voice extremely broken.
           * Byte size 4000 will produce ~ 0.18 seconds of lag. Voice slightly more broken then 9728.
           */
  
          byte[] receiveData = new byte[4096];
  
          format = new AudioFormat(sampleRate, 16, 1, true, false);
          dataLineInfo = new DataLine.Info(SourceDataLine.class, format);
          sourceDataLine = (SourceDataLine) AudioSystem.getLine(dataLineInfo);
          sourceDataLine.open(format);
          sourceDataLine.start();
  
          //FloatControl volumeControl = (FloatControl) sourceDataLine.getControl(FloatControl.Type.MASTER_GAIN);
          //volumeControl.setValue(1.00f);
  
          DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
  
          ByteArrayInputStream baiss = new ByteArrayInputStream(receivePacket.getData());
  
          while (status == true) 
          {
              serverSocket.receive(receivePacket);
              ais = new AudioInputStream(baiss, format, receivePacket.getLength());
              toSpeaker(receivePacket.getData());
          }
  
          sourceDataLine.drain();
          sourceDataLine.close();
      }
  
      public static void toSpeaker(byte soundbytes[]) {
          try 
          {
              System.out.println("At the speaker");
              sourceDataLine.write(soundbytes, 0, soundbytes.length);
          } catch (Exception e) {
              System.out.println("Not working in speakers...");
              e.printStackTrace();
          }
      }
  }
  </code></pre>