java UDP声音流：为什么会有干扰？

我正试图建立一个非常简单的音频流源和接收器。但当我在“接收器”中接收声音时，我会受到一些干扰。我使用的是UDP协议。有没有办法“改进”我的代码以避免这些干扰

这是我的音频服务器：

import java.io.File;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

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 AudioPlayerServer implements Runnable {

    private SourceDataLine sLine;
    private AudioFormat audioFormat;
    private AudioInputStream audioInputStream=null;
    private String host="127.0.0.1";
    private int port=8000;
    private DatagramSocket server;
    private DatagramPacket packet;
    private long startTime;
    private long endTime=System.nanoTime();;
    private long elapsed=System.nanoTime();;
    private double sleepTime;
    private long sleepTimeMillis;
    private int sleepTimeNanos, epsilon;

    AudioPlayerServer(String host, int port) {      
        this.host=host;
        this.port=port;
        init();
    }

    public void init() {
        File file = new File("test.wav");
        try {
            audioInputStream=AudioSystem.getAudioInputStream(file);

        } catch (Exception e) {
            e.printStackTrace();
        }

        audioFormat = new AudioFormat(44100, 16, 2, true, false);
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        System.out.println(info);

        try {
            server = new DatagramSocket();
            System.out.println("Server started");

        } catch (SocketException e) {
            e.printStackTrace();
        }       
    }

    public void run() {
        try {
            byte bytes[] =  new byte[4096];
            byte bytes2[] =  new byte[1024];
            int bytesRead=0;
            //The sending rythm of the data have to be compatible with an audio streaming.
            //So, I'll sleep the streaming thread for (1/SampleRate) seconds * (bytes.lenght/4) - epsilon
            //=> bytes.lenght/4 because 4 values = 1 frame => For ex, in  1024 bits, there are 1024/4 = 256 frames
            //epsilon because the instructions themselves takes time.
            //The value have to be convert in milliseconds et nanoseconds.
            sleepTime=(1024/audioFormat.getSampleRate());
            epsilon=400000;
            sleepTimeMillis=(long)(sleepTime*1000);
            sleepTimeNanos=(int)((sleepTime*1000-sleepTimeMillis)*1000000);
            System.out.println("Sleep time :"+sleepTimeMillis+" ms, "+sleepTimeNanos+" ns");

            while ((bytesRead=audioInputStream.read(bytes, 0, bytes.length))!= -1) {
                //getSignalLevel(bytes);

                try {                   
                    //startTime=System.nanoTime();
                    packet = new DatagramPacket(bytes, bytes.length, InetAddress.getByName(host), port);
                    packet.setData(bytes);
                    server.send(packet);                    
                    packet.setLength(bytes.length);                 
                    //endTime=System.nanoTime();
                    //System.out.println(endTime-startTime);
                    Thread.sleep(sleepTimeMillis,sleepTimeNanos);                   
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }   
            System.out.println("No bytes anymore !");                   
        } catch (Exception e) {
            e.printStackTrace();
        }
        sLine.close();
        System.out.println("Line closed");

    }

}

以下是客户：

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.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;

public class AudioReceiver implements Runnable{
    private String host;
    private int port;
    private SourceDataLine sLine;
    private AudioFormat audioFormat;
    byte[] buffer=new byte[4096];
    DatagramPacket packet;

    AudioReceiver (String host, int port) {
        this.host=host;
        this.port=port;
        init();
        Thread t1=new Thread(new Reader());
        t1.start();
    }

    public void init() {
        audioFormat = new AudioFormat(44100, 16, 2, true, false);
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);

        try  {
            System.out.println(info);
            sLine=(SourceDataLine) AudioSystem.getLine(info);
            System.out.println(sLine.getLineInfo() + " - sample rate : "+audioFormat.getSampleRate());
        } catch (Exception e) {
            e.printStackTrace();
        }       
    }

    public void run() {
        System.out.println("Client started");
        try {
            sLine.open(audioFormat);
        } catch (Exception e){
            e.printStackTrace();
        }
        sLine.start();
        System.out.println("Line started");

        try {

            DatagramSocket client = new DatagramSocket(port, InetAddress.getByName(host));
            while (true) {
                try {
                    packet = new DatagramPacket(buffer, buffer.length);
                    //System.out.println("Reception beggins for host "+host+" : "+port);
                    client.receive(packet);
                    //System.out.println("Reception ends");
                    buffer=packet.getData();

                    //sLine.write(packet.getData(), 0, buffer.length);
                    packet.setLength(buffer.length);
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e1) {
            e1.printStackTrace();
        }

    }

    public class Reader implements Runnable {
        public void run() {
            while (true) {
                if (packet!=null) {
                    sLine.write(packet.getData(), 0, buffer.length);
                }
            }           
        }       
    }   
}

我使用的是UDP协议。有没有办法“改进”我的代码以避免这些干扰

有两种可能性：

UDP消息正在丢失

客户端或服务器端的应用程序逻辑存在问题，导致音频流数据受损

---

假设问题是#1，最简单的选择是切换到TCP

UDP天生容易丢失数据包，丢失的数据包会导致失真。TCP是无损耗的，如果“管道”中存在一些延迟（即客户端缓冲），您应该能够避免由于偶尔的数据包丢失和重新传输（在TCP级别）引起的抖动而导致的失真

---

---

我还注意到，您当前的客户机/服务器逻辑正试图使用

sleep

控制服务器端的播放速率。您需要知道，

sleep

不能保证在您期望的时间点唤醒您的睡眠线程。语义是“至少在指定的时间内睡眠”。这以及客户端缺少任何缓冲也可能导致失真。

创建UDP流媒体系统时，通常使用RTP协议。RTP使用UDP，这是一种无连接的不可靠协议。在传输层（UDP），您需要处理丢失和无序到达。此外，网络层是突发性的，数据不会以很好的均匀速率到达。相反，数据包将以不一致的到达间隔率到达。因此，您必须在本地缓冲数据以处理此网络抖动。
关于java、UDP、RTP、网络抖动、缓冲、数据包丢失。 处理损失也有不同的策略。你可以用沉默来填充它，或者估计丢失的数据。此外，客户机播放样本的速度可能比服务器快，最终会耗尽数据。这是由于没有公共总线的两个系统之间时钟晶体的变化造成的。

---

处理数据包丢失和时钟漂移。

您知道在UDP中，数据包没有被订购，也不能保证它们会被交付。是的，我正在研究UDP上的RTP协议，但是。。。啊。。。在我的简单程序中编写这样一个协议似乎非常复杂……好吧，我将试着看看是否可以“避免”睡眠时间。对于客户端的缓冲区，您认为数据音乐“收缩”的链接或数组列表是一个好的解决方案吗？我还将尝试使用TCP。ArrayBlockingQueue会更好：这句话不正确：“您应该能够避免由于偶尔的数据包丢失和重新传输（在TCP级别）引起的抖动而导致的失真。”网络抖动是由于数据的突发到达。它发生在UDP/IP和TCP/IP上。无论是使用UDP还是TCP，这都是您需要处理的问题。它通常由一个去抖动缓冲区来处理，在播放流之前，它会积累最少的数据量。如果此问题是其中一个链接问题的副本，请将其作为副本关闭，而不是留下相应的答案。如果不是重复的，请留下完整的答案，而不是仅链接的答案。