我在另一台 PC 上实现从 MIC 到 Java 服务器的实时流式传输。但我只听到白噪音。
我已经附上了客户端和服务器程序
Client:
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.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.TargetDataLine;
public class Mic
{
public byte[] buffer;
private int port;
static AudioInputStream ais;
public static void main(String[] args)
{
TargetDataLine line;
DatagramPacket dgp;
AudioFormat.Encoding encoding = AudioFormat.Encoding.PCM_SIGNED;
float rate = 44100.0f;
int channels = 2;
int sampleSize = 16;
boolean bigEndian = true;
InetAddress addr;
AudioFormat format = new AudioFormat(encoding, rate, sampleSize, channels, (sampleSize / 8) * channels, rate, bigEndian);
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
if (!AudioSystem.isLineSupported(info)) {
System.out.println("Line matching " + info + " not supported.");
return;
}
try
{
line = (TargetDataLine) AudioSystem.getLine(info);
int buffsize = line.getBufferSize()/5;
buffsize += 512;
line.open(format);
line.start();
int numBytesRead;
byte[] data = new byte[buffsize];
addr = InetAddress.getByName("127.0.0.1");
DatagramSocket socket = new DatagramSocket();
while (true) {
// Read the next chunk of data from the TargetDataLine.
numBytesRead = line.read(data, 0, data.length);
// Save this chunk of data.
dgp = new DatagramPacket (data,data.length,addr,50005);
socket.send(dgp);
}
}catch (LineUnavailableException e) {
e.printStackTrace();
}catch (UnknownHostException e) {
// TODO: handle exception
} catch (SocketException e) {
// TODO: handle exception
} catch (IOException e2) {
// TODO: handle exception
}
}
}
服务器端没有问题。它与安卓客户端 AudioRecord 完美运行。
Server:
import java.io.ByteArrayInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
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 Server {
AudioInputStream audioInputStream;
static AudioInputStream ais;
static AudioFormat format;
static boolean status = true;
static int port = 50005;
static int sampleRate = 44100;
static DataLine.Info dataLineInfo;
static SourceDataLine sourceDataLine;
public static void main(String args[]) throws Exception
{
System.out.println("Server started at port:"+port);
DatagramSocket serverSocket = new DatagramSocket(port);
/**
* Formula for lag = (byte_size/sample_rate)*2
* Byte size 9728 will produce ~ 0.45 seconds of lag. Voice slightly broken.
* Byte size 1400 will produce ~ 0.06 seconds of lag. Voice extremely broken.
* Byte size 4000 will produce ~ 0.18 seconds of lag. Voice slightly more broken then 9728.
*/
byte[] receiveData = new byte[4096];
format = new AudioFormat(sampleRate, 16, 1, true, false);
dataLineInfo = new DataLine.Info(SourceDataLine.class, format);
sourceDataLine = (SourceDataLine) AudioSystem.getLine(dataLineInfo);
sourceDataLine.open(format);
sourceDataLine.start();
//FloatControl volumeControl = (FloatControl) sourceDataLine.getControl(FloatControl.Type.MASTER_GAIN);
//volumeControl.setValue(1.00f);
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
ByteArrayInputStream baiss = new ByteArrayInputStream(receivePacket.getData());
while (status == true)
{
serverSocket.receive(receivePacket);
ais = new AudioInputStream(baiss, format, receivePacket.getLength());
toSpeaker(receivePacket.getData());
}
sourceDataLine.drain();
sourceDataLine.close();
}
public static void toSpeaker(byte soundbytes[]) {
try
{
System.out.println("At the speaker");
sourceDataLine.write(soundbytes, 0, soundbytes.length);
} catch (Exception e) {
System.out.println("Not working in speakers...");
e.printStackTrace();
}
}
}
最佳答案
所以,我用正弦波(或某种模糊意义上类似于正弦波的东西)填充麦克风,您的程序运行良好。
因此我的具体改动是:
package audioclient;
import java.io.*;
import java.net.*;
import java.nio.ByteBuffer;
import javax.sound.sampled.*;
public class Mic {
public byte[] buffer;
private int port;
static AudioInputStream ais;
public static void main(String[] args) {
TargetDataLine line;
DatagramPacket dgp;
AudioFormat.Encoding encoding = AudioFormat.Encoding.PCM_SIGNED;
float rate = 44100.0f;
int channels = 2;
int sampleSize = 16;
boolean bigEndian = true;
InetAddress addr;
AudioFormat format = new AudioFormat(encoding, rate, sampleSize, channels, (sampleSize / 8) * channels, rate, bigEndian);
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
if (!AudioSystem.isLineSupported(info)) {
System.out.println("Line matching " + info + " not supported.");
return;
}
try {
line = (TargetDataLine) AudioSystem.getLine(info);
//TOTALLY missed this.
int buffsize = line.getBufferSize() / 5;
buffsize += 512;
line.open(format);
line.start();
int numBytesRead;
byte[] data = new byte[buffsize];
/*
* MICK's injection: We have a buffsize of 512; it is best if the frequency
* evenly fits into this (avoid skips, bumps, and pops). Additionally, 44100 Hz,
* with two channels and two bytes per sample. That's four bytes; divide
* 512 by it, you have 128.
*
* 128 samples, 44100 per second; that's a minimum of 344 samples, or 172 Hz.
* Well within hearing range; slight skip from the uneven division. Maybe
* bump it up to 689 Hz.
*
* That's a sine wave of shorts, repeated twice for two channels, with a
* wavelength of 32 samples.
*
* Note: Changed my mind, ignore specific numbers above.
*
*/
{
final int λ = 16;
ByteBuffer buffer = ByteBuffer.allocate(λ * 2 * 8);
for(int j = 0; j < 2; j++) {
for(double i = 0.0; i < λ; i++) {
System.out.println(j + " " + i);
//once for each sample
buffer.putShort((short)(Math.sin(Math.PI * (λ/i)) * Short.MAX_VALUE));
buffer.putShort((short)(Math.sin(Math.PI * (λ/i)) * Short.MAX_VALUE));
}
}
data = buffer.array();
}
addr = InetAddress.getByName("127.0.0.1");
try(DatagramSocket socket = new DatagramSocket()) {
while (true) {
for(byte b : data) System.out.print(b + " ");
// Read the next chunk of data from the TargetDataLine.
// numBytesRead = line.read(data, 0, data.length);
for(int i = 0; i < 64; i++) {
byte b = data[i];
System.out.print(b + " ");
}
System.out.println();
// Save this chunk of data.
dgp = new DatagramPacket(data, data.length, addr, 50005);
for(int i = 0; i < 64; i++) {
byte b = dgp.getData()[i];
System.out.print(b + " ");
}
System.out.println();
socket.send(dgp);
}
}
} catch (LineUnavailableException e) {
e.printStackTrace();
} catch (UnknownHostException e) {
// TODO: handle exception
} catch (SocketException e) {
// TODO: handle exception
} catch (IOException e2) {
// TODO: handle exception
}
}
}
很明显,我将它误解为 512 字节长的片段并弄乱了正弦波,但事实是,它产生的声音正是它想要的——特定音调下令人头脑 NumPy 的嘎嘎声。
考虑到这一点,我不怀疑您的代码中存在明确的问题。我要检查的第一件事是您的系统正在为音频窃听哪条线路。您连接了多个麦克风吗?也许是网络摄像头麦克风?您可以使用 PulseAudio Volume Control 等实用程序进行检查。如果您还没有检查过麦克风的功能,您也可以这样做;它们确实有生命周期。
对音频流中的比特进行加扰并不罕见,也不难;但我看不到任何地方可以这样做。
一个想法可能是修改您的程序以尝试在本地播放声音,然后再将其发送到服务器。这样,您至少可以确定问题是在麦克风之前还是之后。
关于java - 直播音频流java,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/28122097/