Microphone Streaming over Network is Choppy

Question

Hello.
Part of a program in development allows audio to be streamed over the Internet via microphone capture. The current solution seems to be working alright... however, at times the audio gets extremely choppy on the receiving side, almost to the point of being unable to hear it at all... 15 second gaps etc...
I was wondering if you would look at this code and had any suggestions how I could improve this to make it flow better.
Any help is appreciated. First is the server code. Second is the client (receiving code)
public class MicrophoneManager implements Runnable {
private static volatile ByteArrayOutputStream byteArrayOutputStream;
private static String communicatorIP = null;
public static volatile boolean interrupt = false;
private AudioFormat getAudioFormat() {
float sampleRate = 8000.0F;
//8000,11025,16000,22050,44100
int sampleSizeInBits = 8;
//8,16
int channels = 1;
//1,2
boolean signed = true;
//true,false
boolean bigEndian = false;
//true,false
return new AudioFormat(
sampleRate,
sampleSizeInBits,
channels,
signed,
bigEndian);
}//end getAudioFormat
public static void setCommunicatorIP(String communicatorIP) {
MicrophoneManager.communicatorIP = communicatorIP;
@Override
public void run() {
try {
AudioFormat audioFormat = getAudioFormat();
DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, audioFormat);
TargetDataLine targetDataLine = (TargetDataLine) AudioSystem.getLine(dataLineInfo);
targetDataLine.open(audioFormat);
targetDataLine.start();
ArrayList<Byte> byteArrayList = new ArrayList<Byte>();
byte tempBuffer[] = new byte[10000];
byteArrayOutputStream = new ByteArrayOutputStream();
Thread mcThread = new Thread(new MicrophoneCommunicator());
mcThread.start();
//bos = new BufferedOutputStream(byteArrayOutputStream);
while (!interrupt) {
while (byteArrayList.size() < 10000) {
targetDataLine.read(tempBuffer, 0, tempBuffer.length);
for (byte b : tempBuffer) {
byteArrayList.add(b);
byte[] writerArray = new byte[byteArrayList.size()];
tempBuffer = new byte[10000];
for (int i = 0; i < byteArrayList.size(); i++) {
writerArray[i] = byteArrayList.get(i);
byteArrayList.clear();
byteArrayOutputStream.write(writerArray, 0, writerArray.length);
targetDataLine.close();
} catch (Exception e1) {
global.debug(e1);
private class MicrophoneCommunicator implements Runnable {
public void run() {
try {
Socket microphoneSocket = new Socket(communicatorIP, 5751);
BufferedOutputStream netStreamOut = new BufferedOutputStream(microphoneSocket.getOutputStream());
while (!interrupt) {
if (byteArrayOutputStream.toByteArray().length >= 10000) {
netStreamOut.write(byteArrayOutputStream.toByteArray());
byteArrayOutputStream.reset();
microphoneSocket.close();
} catch (Exception e1) {
global.debug(e1);
}Now, here is the other code.
public class Microphone implements Runnable {
public void run() {
try {
byte[] tempArray = new byte[10000];
ServerSocket micSocket = new ServerSocket(5751);
micSocket.setSoTimeout(0);
Socket microphoneSocket = micSocket.accept(); //Now connected
BufferedInputStream bis = new BufferedInputStream(microphoneSocket.getInputStream());
ByteArrayInputStream bais = new ByteArrayInputStream(tempArray);
AudioFormat audioFormat = getAudioFormat();
AudioInputStream audioInputStream =
new AudioInputStream(bais,
audioFormat,
tempArray.length / audioFormat.getFrameSize());
DataLine.Info dataLineInfo =
new DataLine.Info(
SourceDataLine.class,
audioFormat);
SourceDataLine sourceDataLine = (SourceDataLine) AudioSystem.getLine(
dataLineInfo);
sourceDataLine.open(audioFormat);
sourceDataLine.start();
ArrayList<Byte> byteArrayList = new ArrayList<Byte>();
boolean interrupted = false;
while (!interrupted) {
int nextByte = 0;
while ((nextByte = bis.read()) != -1 && (byteArrayList.size() < 10000)) {
byteArrayList.add((byte) nextByte);
for (int i = 0; i < byteArrayList.size(); i++) {
tempArray[i] = byteArrayList.get(i);
byteArrayList.clear();
sourceDataLine.write(tempArray, 0, tempArray.length);
interrupted = global.micInterrupt;
microphoneSocket.close();
micSocket.close();
sourceDataLine.close();
} catch (Exception e1) {
e1.printStackTrace();
private AudioFormat getAudioFormat() {
float sampleRate = 8000.0F;
//8000,11025,16000,22050,44100
int sampleSizeInBits = 8;
//8,16
int channels = 1;
//1,2
boolean signed = true;
//true,false
boolean bigEndian = false;
//true,false
return new AudioFormat(
sampleRate,
sampleSizeInBits,
channels,
signed,
bigEndian);
}//end getAudioFormat
}If you guys have any ideas on how to make this smoother... please feel free... Also, please feel free to use this code however you wish. I'd really appreciate this... It's hard for people to communicate when it's so choppy this way.
However, the stream is currently only one way though, it only goes from one system to another... not two-way. One talks, the other types... it's complicated, but just might be useful info.
Both sides are communicating via lan... so speed of connection isn't an issue...
Thanks in advance.
Best,
Chris

Answer 1

I'd recommend using UDP streams instead of TCP streams, and I'd recommend discarding out-of-order packets and packets that are delayed beyond a certain threshold (which you can play with)...