Envoyer le flux audio sur le protocole TCP, UnsupportedAudioFileException

J'ai réussi avec l'envoi et la lecture de texte et de données d'images sur les sockets TCP. Mais je ne suis pas en mesure d'envoyer et de lire des flux audio.

exemple de code sur le serveur:

public class ServerAudio {
    /**
     * @param args
     */
    public static void main(String[] args) {
        //TODO Auto-generated method stub

        try {
            ServerSocket serverSocker = new ServerSocket();
            Socket client = null;
            serverSocker.bind(new InetSocketAddress(6666));
            if (serverSocker.isBound()) {
                client = serverSocker.accept();
                OutputStream out = client.getOutputStream();
                while (true) {
                    AudioInputStream ain = testPlay("C:/Users/Public/Music/Sample Music/adios.wav");
                    if (ain != null) {
                        AudioSystem.write(ain, AudioFileFormat.Type.WAVE, out);
                    }
                }
            }
            serverSocker.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public static AudioInputStream testPlay(String filename) {
        AudioInputStream din = null;
        try {
            File file = new File(filename);
            AudioInputStream in = AudioSystem.getAudioInputStream(file);
            System.out.println("Before :: " + in.available());

            AudioFormat baseFormat = in.getFormat();
            AudioFormat decodedFormat =
                    new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED, baseFormat.getSampleRate(),
                            8, baseFormat.getChannels(), baseFormat.getChannels(),
                            baseFormat.getSampleRate(), false);
            din = AudioSystem.getAudioInputStream(decodedFormat, in);
            System.out.println("After :: " + din.available());
            return din;
        } catch (Exception e) {
            //Handle exception.
            e.printStackTrace();
        }
        return din;
    }
}

exemple de code au client:

public class RDPPlayAudioBytes {
    private static Socket socket;
    /**
     * @param args
     */
    public static void main(String[] args) {
        //TODO Auto-generated method stub
        //SocketAddress socketAddress = new InetSocketAddress("172.19.1.50", 4444);
        try {
            Socket socket = new Socket("172.19.0.109", 6666);
            //socket.connect(socketAddress, 10000);
            if (socket != null && socket.isConnected()) {
                InputStream inputStream = socket.getInputStream();
                //DataInputStream din=new DataInputStream(inputStream);
                while (inputStream != null) {
                    if (inputStream.available() > 0) {
                        System.out.println(inputStream.available());
                        InputStream bufferedIn = new BufferedInputStream(inputStream);
                        System.out.println("********** Buffred *********" + bufferedIn.available());
                        AudioInputStream ais = AudioSystem.getAudioInputStream(bufferedIn);
                    }
                }
            }


        } catch (IOException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        } /*
           * catch (LineUnavailableException e) { //TODO Auto-generated catch block
           * e.printStackTrace(); }
           */catch (UnsupportedAudioFileException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Où j'obtiens une Exception, comme le

javax.sound.sampled.UnsupportedAudioFileException: could not get audio input stream from input stream
    at javax.sound.sampled.AudioSystem.getAudioInputStream(Unknown Source)

Où j'ai observé que le serveur envoie 35394bytes de données pour le client, Mais à côté client, nous recevons 8192 octets de données. Je suis incapable de comprendre pourquoi les octets sont manquants à côté client.

S'il vous plaît aider moi comment faire pour envoyer le flux audio sur les Sockets TCP.

Juste un conseil: ne pas utiliser available(). Dans la plupart des cas, il n'est pas ce que vous attendez.
essayez avec cette AudioInputStream ain = testPlay("C:\\Users\\Public\\Music\\Sample la Musique\\adios.wav");
regardez ce qu'une fois stackoverflow.com/questions/11174813/...
Couple de choses à vérifier. Dans testplay, après la création de file, d'imprimer les valeurs de file.exists(), file.canRead(), et file.getCanonicalPath(). Si tout semble bon, essayez d'imprimer la valeur de AudioSystem.getAudioFileFormat(file). Si cela échoue, prendre un bon coup d'oeil à votre fichier et assurez-vous qu'il est vraiment un fichier WAV.

OriginalL'auteur mini | 2013-06-11

Le Serveur: Le serveur vient de flux les octets d'un fichier audio. Pas de AudioSytem impliqués. Passer le son de fichier comme argument:

java AudioServer "C:/Users/Public/Music/Sample Music/adios.wav"

De Code pour la classe AudioServer:

import java.io.*;
import java.net.*;

public class AudioServer {
    public static void main(String[] args) throws IOException {
        if (args.length == 0)
            throw new IllegalArgumentException("expected sound file arg");
        File soundFile = AudioUtil.getSoundFile(args[0]);

        System.out.println("server: " + soundFile);

        try (ServerSocket serverSocker = new ServerSocket(6666); 
            FileInputStream in = new FileInputStream(soundFile)) {
            if (serverSocker.isBound()) {
                Socket client = serverSocker.accept();
                OutputStream out = client.getOutputStream();

                byte buffer[] = new byte[2048];
                int count;
                while ((count = in.read(buffer)) != -1)
                    out.write(buffer, 0, count);
            }
        }

        System.out.println("server: shutdown");
    }
}

Le client: Le client peut jouer un fichier son passé via la ligne de commande pour tester si cela fonctionne:

java AudioClient "C:/Users/Public/Music/Sample Music/adios.wav"

Appelé sans argument, il se connecte au serveur et joue le fichier reçu via un Socket:

java AudioClient

Code:

import java.io.*;
import java.net.*;
import javax.sound.sampled.*;


public class AudioClient {
    public static void main(String[] args) throws Exception {
        if (args.length > 0) {
            //play a file passed via the command line
            File soundFile = AudioUtil.getSoundFile(args[0]);
            System.out.println("Client: " + soundFile);
            try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(soundFile))) {
                play(in);
            }
        }
        else {
            //play soundfile from server
            System.out.println("Client: reading from 127.0.0.1:6666");
            try (Socket socket = new Socket("127.0.0.1", 6666)) {
                if (socket.isConnected()) {
                    InputStream in = new BufferedInputStream(socket.getInputStream());
                    play(in);
                }
            }
        }

        System.out.println("Client: end");
    }


    private static synchronized void play(final InputStream in) throws Exception {
        AudioInputStream ais = AudioSystem.getAudioInputStream(in);
        try (Clip clip = AudioSystem.getClip()) {
            clip.open(ais);
            clip.start();
            Thread.sleep(100); //given clip.drain a chance to start
            clip.drain();
        }
    }
}

Une classe utilitaire utilisé par AudioServer et AudioClient:

import java.io.File;

public class AudioUtil {
    public static File getSoundFile(String fileName) {
        File soundFile = new File(fileName);
        if (!soundFile.exists() || !soundFile.isFile())
            throw new IllegalArgumentException("not a file: " + soundFile);
        return soundFile;
    }
}

OriginalL'auteur wero

5

Les octets seront reçues complètement que TCP est fiable. Il y a une autre petite question. Vous avez besoin de jouer l'audio reçu du flux audio, seulement à la création d'une entrée audio stream va pas jouer.
Il peut y avoir différentes techniques possibles pour la lecture de l'audio reçu. Vous pouvez utiliser un Clip ou SourceDataLine de la Java API Sound. Aussi, ne pas créer la AudioInputStream plusieurs fois. Il suffit de créer une fois et l'utiliser.

Voici l'une des solutions possibles que vous pouvez utiliser pour jouer de l'audio reçu.
```
public class RDPPlayAudioBytes {

private static Socket socket;
private static BufferedInputStream inputStream;

/**
 * @param args
 * @throws javax.sound.sampled.LineUnavailableException
 */
public static void main(String[] args) throws LineUnavailableException {
    //TODO Auto-generated method stub
    //SocketAddress socketAddress = new InetSocketAddress("172.19.1.50", 4444);
    try {
        socket = new Socket("127.0.0.1", 6666);

        if (socket.isConnected()) {

            inputStream = new BufferedInputStream(socket.getInputStream());

            Clip clip = AudioSystem.getClip();
            AudioInputStream ais = AudioSystem.getAudioInputStream(inputStream);
            clip.open(ais);
            clip.start();

            while (inputStream != null) {
                if (clip.isActive()) {

                    System.out.println("********** Buffred *********" + inputStream.available());

                }
            }

        }

    } catch (IOException | UnsupportedAudioFileException e) {
        System.err.println(e);
    }
}
}
```
Vous pouvez avoir besoin d'une mise en œuvre différente en fonction de votre exigence. C'est juste une démonstration sur comment vous pouvez utiliser la AudioInputStream pour lire de l'audio à l'aide de Clip. Vous remarquerez quelques changements dans le code que j'ai posté. J'espère que vous comprenez ce bien.

Vous pouvez consulter la Java Sound API docs de plonger dans les bases de la lecture audio.

NOTE:
1. Juste pour votre connaissance, vous devrez peut-être mettre en œuvre un auditeur de sorte que le programme n'obtenez pas fermé avant que le clip audio de la fin de la lecture. Dans l'implémentation actuelle, il ne se produira pas en raison de la boucle utilisée. Mais il est préférable d'utiliser un écouteur. Vous pouvez vous référer ce post.
2. Vous pouvez également lire les données audio en byte[] et puis le lire dès qu'il est reçu. La mise en œuvre permettrait de changer un peu.
Ce ne sera jamais la fin: inputStream ne sera jamais nulle. Aussi cette boucle et la clip.isActive() vérification de manger tous vos cycles de PROCESSEUR.
Je suis d'accord, mais mon but était juste de montrer l'utilisation d'un moyen pour lire le son avec le code affiché dans la question. Je suis d'accord que le code peut être amélioré.

OriginalL'auteur Kunjan Thadani

Vous devez vous connecter pour publier un commentaire.