在java中使用socket进行语音聊天或音频通话

场景1:两个用户/客户端之间的语音聊天工作正常，如果且仅当他们都使用耳机时

场景2:如果其中任何一个不使用耳机，则语音聊天正常，但噪音会逐渐增加

它是如何工作的

客户端1的麦克风声音已录制并发送给客户端2。但是客户端1的扬声器声音也被录制下来并发送给客户端2。因此，客户2反复听到自己的声音和客户1的声音。而且噪音越来越大

目的

我需要停止录制扬声器的声音。如何通过过滤扬声器的声音来读取/录制麦克风的输入声音？请帮忙

这是我的密码：

public class Server {
ServerSocket MyService;
Socket clientSocket = null;
InputStream input;
TargetDataLine targetDataLine;
OutputStream out;
AudioFormat audioFormat;
SourceDataLine sourceDataLine;
byte tempBuffer[] = new byte[10000];
static Mixer.Info[] mixerInfo = AudioSystem.getMixerInfo();

Server() throws LineUnavailableException {
    JFrame frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.show();
    try {
        Mixer mixer_ = AudioSystem.getMixer(mixerInfo[0]);
        audioFormat = getAudioFormat();
        DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class, audioFormat);
        sourceDataLine = (SourceDataLine) AudioSystem.getLine(dataLineInfo);
        sourceDataLine.open(audioFormat);
        sourceDataLine.start();
        MyService = new ServerSocket(500);
        clientSocket = MyService.accept();
        captureAudio();
        input = new BufferedInputStream(clientSocket.getInputStream());
        out = new BufferedOutputStream(clientSocket.getOutputStream());
        while (input.read(tempBuffer) != -1) {
            sourceDataLine.write(tempBuffer, 0, 10000);

        }

    } catch (IOException e) {

        e.printStackTrace();
    }

}

private AudioFormat getAudioFormat() {
    float sampleRate = 8000.0F;
    int sampleSizeInBits = 8;
    int channels = 1;
    boolean signed = true;
    boolean bigEndian = false;
    return new AudioFormat(
            sampleRate,
            sampleSizeInBits,
            channels,
            signed,
            bigEndian);
}

public static void main(String s[]) throws LineUnavailableException {
    Server s2 = new Server();
}

private void captureAudio() {
    try {

        audioFormat = getAudioFormat();
        DataLine.Info dataLineInfo = new DataLine.Info(
                TargetDataLine.class, audioFormat);
        Mixer mixer = null;
        System.out.println("Available mixers:");
        for (int cnt = 0; cnt < mixerInfo.length; cnt++) {
            mixer = AudioSystem.getMixer(mixerInfo[3]);
            if (mixer.isLineSupported(dataLineInfo)) {
                System.out.println(mixerInfo[cnt].getName());
                targetDataLine = (TargetDataLine) mixer.getLine(dataLineInfo);
            }
        }
        targetDataLine.open(audioFormat);
        targetDataLine.start();

        Thread captureThread = new CaptureThread();
        captureThread.start();
    } catch (Exception e) {
        System.out.println(e);
        System.exit(0);
    }
}

class CaptureThread extends Thread {

    byte tempBuffer[] = new byte[10000];

    @Override
    public void run() {
        try {
            while (true) {
                int cnt = targetDataLine.read(tempBuffer, 0, tempBuffer.length);
                out.write(tempBuffer);
                out.flush();

            }

        } catch (Exception e) {
            System.out.println(e);
            System.exit(0);
        }
    }
}}

公共类服务器{
serversocketmyservice；
套接字clientSocket=null；
输入流输入；
TargetDataLine TargetDataLine；
输出流输出；
音频格式；音频格式；
SourceDataLine SourceDataLine；
字节tempBuffer[]=新字节[10000]；
static Mixer.Info[]mixerInfo=AudioSystem.getMixerInfo（）；
服务器（）引发LineUnavailableException{
JFrame=新JFrame（）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.pack（）；
frame.show（）；
试一试{
Mixer\uux=AudioSystem.getMixer（mixerInfo[0]）；
audioFormat=getAudioFormat（）；
DataLine.Info dataLineInfo=新的DataLine.Info（SourceDataLine.class，audioFormat）；
sourceDataLine=（sourceDataLine）AudioSystem.getLine（dataLineInfo）；
sourceDataLine.open（音频格式）；
sourceDataLine.start（）；
MyService=newserversocket（500）；
clientSocket=MyService.accept（）；
captureAudio（）；
输入=新的BufferedInputStream（clientSocket.getInputStream（））；
out=new BufferedOutputStream（clientSocket.getOutputStream（））；
while（input.read（tempBuffer）！=-1）{
写入（tempBuffer，0，10000）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
私有音频格式getAudioFormat（）{
浮式取样器=8000.0F；
int sampleSizeInBits=8；
int通道=1；
布尔符号=真；
布尔bigEndian=false；
返回新的音频格式(
采样器，
抽样调查，
渠道,，
签署，
bigEndian）；
}
公共静态void main（字符串s[]）引发LineUnavailableException{
服务器s2=新服务器（）；
}
私有void captureAudio（）{
试一试{
audioFormat=getAudioFormat（）；
DataLine.Info dataLineInfo=新的DataLine.Info(
TargetDataLine.class，音频格式）；
Mixer=null；
System.out.println（“可用混合器：”）；
对于（int cnt=0；cnt

及

公共类客户端{
布尔stopCapture=false；
ByteArrayOutputStream ByteArrayOutputStream；
音频格式；音频格式；
TargetDataLine TargetDataLine；
音频输入流音频输入流；
BufferedOutputStream out=null；
BufferedInputStream in=null；
套接字sock=null；
SourceDataLine SourceDataLine；
公共静态void main（字符串[]args）{
客户端tx=新客户端（）；
tx.captureAudio（）；
}
私有void captureAudio（）{
试一试{
插座=新插座（“192.168.1.3”，500）；
out=新的BufferedOutputStream（sock.getOutputStream（））；
in=新的BufferedInputStream（sock.getInputStream（））；
Mixer.Info[]mixerInfo=AudioSystem.getMixerInfo（）；
System.out.println（“可用混合器：”）；
对于（int cnt=0；cnt0）{
byteArrayOutputStream.write（临时缓冲区，0，
public class Client {
boolean stopCapture = false;
ByteArrayOutputStream byteArrayOutputStream;
AudioFormat audioFormat;
TargetDataLine targetDataLine;
AudioInputStream audioInputStream;
BufferedOutputStream out = null;
BufferedInputStream in = null;
Socket sock = null;
SourceDataLine sourceDataLine;

public static void main(String[] args) {
    Client tx = new Client();
    tx.captureAudio();
}

private void captureAudio() {
    try {
        sock = new Socket("192.168.1.3", 500);
        out = new BufferedOutputStream(sock.getOutputStream());
        in = new BufferedInputStream(sock.getInputStream());

        Mixer.Info[] mixerInfo = AudioSystem.getMixerInfo();
        System.out.println("Available mixers:");
        for (int cnt = 0; cnt < mixerInfo.length; cnt++) {
            System.out.println(mixerInfo[cnt].getName());
        }
        audioFormat = getAudioFormat();

        DataLine.Info dataLineInfo = new DataLine.Info(
                TargetDataLine.class, audioFormat);

        Mixer mixer = AudioSystem.getMixer(mixerInfo[2]);

        targetDataLine = (TargetDataLine) mixer.getLine(dataLineInfo);

        targetDataLine.open(audioFormat);
        targetDataLine.start();

        Thread captureThread = new CaptureThread();
        captureThread.start();

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

        Thread playThread = new PlayThread();
        playThread.start();

    } catch (Exception e) {
        System.out.println(e);
        System.exit(0);
    }
}

class CaptureThread extends Thread {

    byte tempBuffer[] = new byte[10000];

    @Override
    public void run() {
        byteArrayOutputStream = new ByteArrayOutputStream();
        stopCapture = false;
        try {
            while (!stopCapture) {

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

                out.write(tempBuffer);

                if (cnt > 0) {

                    byteArrayOutputStream.write(tempBuffer, 0, cnt);

                }
            }
            byteArrayOutputStream.close();
        } catch (Exception e) {
            System.out.println(e);
            System.exit(0);
        }
    }
}

private AudioFormat getAudioFormat() {
    float sampleRate = 8000.0F;

    int sampleSizeInBits = 8;

    int channels = 1;

    boolean signed = true;

    boolean bigEndian = false;

    return new AudioFormat(sampleRate, sampleSizeInBits, channels, signed,
            bigEndian);
}

class PlayThread extends Thread {

    byte tempBuffer[] = new byte[10000];

    @Override
    public void run() {
        try {
            while (in.read(tempBuffer) != -1) {
                sourceDataLine.write(tempBuffer, 0, 10000);

            }
            sourceDataLine.drain();
            sourceDataLine.close();

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