VoiceChat Hilfe - Empfangene Pakete abspielen

[Johnny00]

Hallo Leute,

ich möchte gerne eine kleine voice chat applikation schreiben,in der sich leute
in einem chatraum einlinken und kommunizieren können.

Wenn man auf einen button klickst, dann soll man etwas sagen können, was die anderen teilnehmer hören können.

Die Frage ist nun wie stell ich das an?

Wie ich sound vom mikrofon (standard)eingabe aufnehmen kann weiß ich

....
BufferedOutputStream out = new BufferedOutputStream(socket.getOutputStream());
AudioFormat audioFormat = new AudioFormat(44100, .., );

DataLine.Info dataLineInfoRecv = new DataLine.Info(SourceDataLine.class, audioFormat);
SourceDataLine sourceDataLine = (SourceDataLine)AudioSystem.getLine(dataLineInfoRecv);
sourceDataLine.open(audioFormat);
sourceDataLine.start();

// Hier beginnt die aufnahme
// Nun schicken wir das ganze

int n = 0;
byte tmpBuffer[] = new byte[10000];
while(n != -1) {
n = targetDataLine.read(tmpBuffer, 0, tmpBuffer.length);
if(n > 0)
outStream.write(tmpBuffer, 0, n);
}

// Stoppen
//
sourceDataLine.drain();
sourceDataLine.close();
out.close();

Ich hoffe mal das ist richtig, ausprobiert hab ichs noch nicht wirklich weil ich mir erstmal die theorie aneignen wollte

Also der Client hat etwas aufgenommen und schickt es nun über den Stream.
Auf der Gegensteite bekommt der Server das ganze.

Nun muss der Server die ganzen pakete sofort an die anderen Teilnehmer weiterleiten, oder?

Beim Server siehts dann so aus:

...
n = inS.read(tmpBuffer, 0, tmpBuffer.length);
if(n > 0)
client[i].write(tmpBuffer, 0, n);
...

Nun muss der Client diese Pakete empfangen und sie abspielen.
Also auch hier wieder

n = in.read(....);

Ist das bis hierhin alles korrekt?
Wie kann ich nun, alle pakete die beim client ankommen direkt abspielen?
Ist das irgendwie möglich?

Mit freundlichen Grüßen
Johnny

 

[Johnny00]

Ich hab nun auch folgendes gefunden.
Kann ich das beim Client so einsetzen?

        try{
            AudioInputStream audioInputStream = AudioSystem.getAudioInputStream( myAudioStream );
            AudioFormat af     = audioInputStream.getFormat();
            int size      = (int) (af.getFrameSize() * audioInputStream.getFrameLength());
            byte[] audio       = new byte[size];
            DataLine.Info info      = new DataLine.Info(Clip.class, af, size);
            audioInputStream.read(audio, 0, size);
            
           // for(int i=0; i < 32; i++) {
                Clip clip = (Clip) AudioSystem.getLine(info);
                clip.open(af, audio, 0, size);
                clip.start();
           // }
        }catch(Exception e){ e.printStackTrace(); }

wenn ja.. wie kann ich dann das machen, dass der client die ganze zeit nach paketen horcht und diese dann sofort abspielt?

 

[tuxedo]

Du willst also ein eigenes Teamspeak basteln?

Das hab ich auch schon probiert. Geht, aber ist sehr viel Aufwand.

Vor allem brauchst du nen Codec. Denn die Qualität die du da aufnimmst braucht zuviel Bandbreite.
Damit das ganze benutzbar bleibt, muss die Latenz stimmen. Alles über 150ms Zeitversatz ist mehr als störend.

Aber das Prinzip hast du richtig erkannt: Aufnehmen, auf Socket geben. Auf der anderen Seite vom Socket lesen und wiedergeben.

Wie man einen Audiostrom aufnimmt und abspielt findest du hier: Java Sound Resources

Als Codec kann ich dir Speex (wie bei TS) ans Herz legen. Es gibt eine reine Java Implementierung hierfür: JSpeex (google hilft). Allerdings wird die Lib nicht großartig weiter gepflegt und aktualisiert. Die Doku ist auch etwas spärlich. Aber es funktioniert.

- Alex

 

[Johnny00]

Hey,

super danke dir für deine hilfe erstmal
ich hab mich mal durchgelesen und nun hab ich das wiefolgt gemacht.

Client ist meine hauptroutine, von dort aus starte ich 2 Threade AudioIn und AudioOut.
Sobald man auf einen button klickt, soll sound aus dem mikrofon in den outputstream geschickt werden.
Das mache ich wiefolgt:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package voicechatclient;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sound.sampled.*;

/**
 *
 * @author Johnny
 */
public class AudioRecord implements Runnable {
    public Client client     = null;
    public boolean capturing = false;
    public ObjectOutputStream out = null;
    public AudioFormat audioFormat = null;
    public TargetDataLine targetDataLine = null;
    public AudioInputStream audioInputStream = null;
    public SourceDataLine sourceDataLine = null;
    public DataLine.Info dataLineInfo;
    public byte tempBuffer[] = new byte[1024];

    public ServerSocket socket = null;
    public Socket server = null;
    
    public AudioRecord (Client cl) {
        this.client = cl;
        this.capturing = false;
        this.audioFormat = getAudioFormat();
        
        try {
        this.dataLineInfo = new DataLine.Info(TargetDataLine.class,audioFormat);
        this.targetDataLine = (TargetDataLine) AudioSystem.getLine(dataLineInfo);
        this.targetDataLine.open(audioFormat);
        } catch (Exception e) {
            this.client.opt.showMessageDialog (client, "Es konnte kein Standard Input Gerät ermittelt werden.", "Fehler:", this.client.opt.ERROR_MESSAGE);
            System.exit (1);
        }
        
        try {
            this.socket = new ServerSocket (client.AUDIOIN);
            this.server = socket.accept ();
            this.out = new ObjectOutputStream ( server.getOutputStream() );
        } catch (Exception e) {
            this.client.opt.showMessageDialog (client, "Es konnte kein Voice Server ermittelt werden.", "Fehler:", this.client.opt.ERROR_MESSAGE);
            System.exit (1);            
        }
    }
    
    public void run () {
    }
    
    public void start () {
        this.capturing = true;
        this.targetDataLine.start();
        
        int cnt = -1;
        try {
             while (this.capturing) {
                 // Read data from internal buffer
                 cnt = targetDataLine.read(tempBuffer,0,tempBuffer.length);
                 if (cnt > 0)
                     out.write(tempBuffer, 0, cnt);
             }
        } catch (Exception e) {
            this.capturing = false;
        }
    }
    
    public void stop () {
        this.targetDataLine.close();
        this.targetDataLine.drain();
        this.capturing = false;
    }
    
    public AudioFormat getAudioFormat () {
        return getAudioFormat (44100.0F);
    }
    
    public AudioFormat getAudioFormat(float sampleRate){
        //sampleRate = 8000.0F;
        //8000,11025,16000,22050,44100
        int sampleSizeInBits = 16;
        //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
}

Sobald auf den Button geklickt wird, wird start () ausgeführt und sobald der button released wird, soll stop ausgeführt werden. Das ganze geht an meinen Server.

Der Server wiederum schickt alle Pakete an die anderen Clienten.
Auf der Clientseite hab ich nun folgenden Thread laufen, der alle pakete in sound umwandelt bzw. abspielt:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package voicechatclient;

import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;

/**
 *
 * @author Johnny
 */
public class AudioOutput implements Runnable {
    public Client client;
    public ServerSocket socket;
    public Socket server;
    
    public SourceDataLine line = null;
    public AudioInputStream in = null;
    public DataLine info = null;
    
    public AudioOutput (Client cl) {
        this.client = cl;
        
        try {
            this.socket = new ServerSocket ( cl.AUDIOIN );
            this.server = socket.accept ();
            this.in = AudioSystem.getAudioInputStream(server.getInputStream());
        } catch (Exception e) {
            this.client.opt.showMessageDialog (client, "Es konnte kein Voice Server ermittelt werden.", "Fehler:", this.client.opt.ERROR_MESSAGE);
            System.exit (1);  
        }
    }
    
    public void run() {
       int nBytesRead = 0;
       byte[] abData = new byte [ 1024 ];
       
       while (!socket.isClosed()) {
           try {
               nBytesRead = in.read(abData, 0, abData.length);
           } catch (Exception e) {
               nBytesRead = -1;
           }
           
           if ( nBytesRead >= 0) {
               line.write (abData, 0, nBytesRead);
           }
       }
       
       line.drain();
       line.close();
    }
}

die konstanten AUDIOIN und AUDIOOUT sind wie du dir denken kannst zwei verschiedene ports um die ströme zu empfangen.

Kann man das so machen wie ich es beschrieben habe?
Ich kann es im moment nicht testen, da ich kein kleines netzwerk habe.
Ich will es erstmal simpel aufbauen und dann nach und nach ausbauen mit encoding etc.

Gibt es Fehler in meinem Code? Wenn ja, welche?
Einige beispiele hab ich dazu im netz gefunden und auf der seite, die du mir gezeigt hast..
Ich hab alles kombiniert und hoffe das klappt so.. was sagst du denn dazu?

grüße
Johnny

 

[Johnny00]

So da bin ich nochmal, ich hab nun alles alleine gelöst.
Ich hab allerdings ein riesen Problem:

Also meine Clients verbinden sich mit dem Server, sobald jemand auf den Sprechbutton klickt, werden die Soundpakete an den Server geschickt. Bis hierhin klappt alles. Das Abspielen der Sprachpakete auf Clientseite funktioniert auch einwandfrei. Das Problem liegt beim Verteilen der Pakete.

Mein Server bekommt die Pakete und sobald ich nen Thread mache um die Pakete zu verteilen,
kommt immer so ein stocken, so als ob einige Soundpakete verloren oder erst gar nicht gesendet worden sind. Wenn ich das Verteilen der Pakete weglasse, also direkt an den Client zurück schicke von dem die soundpakete gekommen sind hört der client das wunderbar!

Hier ist mein kleiner Code:


Client: Client schickt Audiodaten an Server

int cnt = this.targetDataLine.read(tempBuffer, 0, tempBuffer.length);
out.write(tempBuffer);

Server: Server bekommt die Daten und soll an andere Clients schicken:

while ( client.userData.loggedIn ) {
            try {
                nBytesRead = in.read(tempBuffer, 0, tempBuffer.length);

                new Thread ( new Runnable () {
                    public void run () {
                        for ( int i = 0; i < channel.users.size(); i++) {
                            Client client = channel.users.get (i);
                            client.audioBufferedOutputStream.write ( tempBuffer, 0, nBytesRead );
                        }
                    }
                }).start();
....

Sobald ich das so habe, dass ich das alles parallel laufen habe, kommt ein stocken bei client an.
Wenn ich wie gesagt das ganze weglasse und nur

try {
                nBytesRead = in.read(tempBuffer, 0, tempBuffer.length);
                client.audioBufferedOutputStream.write ( tempBuffer, 0, nBytesRead );
...

mache, dann wird alles schön gesendet und abgespielt...

Wisst ihr vielleicht wo das Problem liegt??

 

[Johnny00]

Weiß echt niemand rat??

 

[Ein Keks]

client.userData.loggedIn

auf welchen client überprüfst du hier eigentlich?
is irgendwie seltsam wenn du dann wieder über alle drüberiterierst
vorallem da dus beim anderen ja scheinbar nicht tust

aber zeig am besten mal den ganzen server-code