java - 通过 Android 上的 TCP 套接字流式传输音频

Question

我正在通过套接字从 C 服务器流式传输麦克风输入。我知道该流有效，因为它适用于 C 客户端，并且我在我的 Android 客户端上获得了正确的值。

我正在流式传输 1024 个 floatarray。一个浮点数是 4 个字节。所以我得到了一个每帧 4096 字节的传入流。我从这些字节中取出浮点数，我知道这个浮点数是我发送的，所以这部分应该可以工作。

现在我想通过使用 AudioTrack 将该流直接发送到手机扬声器。我试图输入我直接收到的字节:只是噪音。我试图将它转换回一个字节数组，还是一样。我试图将浮点数转换为短(因为 AudioTrack 需要字节或短)。我可以得到一些可能是我的麦克风输入(敲击声)的东西，但非常沙哑且非常滞后。如果帧之间存在延迟，我会理解，但我什至无法获得清晰的声音。
但是，我可以清楚地输出我在本地产生并放入该短阵列中的罪恶声音。
现在我想知道我的代码中是否有一些问题，你们中的任何人都可以看到，因为我没有看到它们。

我正在做的是:我将 4 个字节放入一个字节数组中。我把它弄出来了。一旦我在我的浮点数组中得到一个 Frame(我用 bool 来控制它，不好，但它应该可以工作)我把它放在我的 shortarray 中并让音轨播放它。这种双重转换可能很慢，但我这样做是因为它是我最接近实际输入的。

编辑:
我通过比较浮点数来检查字节序，它们在 -1 和 1 之间具有正确的值，并且与我发送的值相同。由于我在转换为 float 时不更改字节序，我不明白为什么将 4096 字节数组直接转发到 AudioTrack 也不起作用。多线程可能有问题，但我不知道它可能是什么。

编辑 2:我发现了一个小问题 - 我将 j 重置为 1023。但是缺少的浮点数不应该是问题所在。除此之外，我所做的是将从套接字中获取流的方法放在另一个线程中，而不是在异步任务中调用它。这使它起作用，我现在能够理解麦克风的声音。质量仍然很差 - 代码中是否有原因？我也有大约 10 秒的延迟。只有半秒左右是由WLAN引起的，所以我想知道是否可能是代码错误。任何进一步的想法表示赞赏。

编辑 3:我玩弄了代码并在评论中实现了一些 greenapps 的想法。使用新的线程结构时，我面临着听不到任何声音的问题。就像。我不明白这怎么可能，所以我转回去了。我试图使线程更轻巧的其他事情没有任何效果。我遇到了延迟并且质量很差(我可以识别敲击声，但我无法理解声音)。我认为我的转换可能有问题，所以我将我从套接字接收到的字节直接放在 AudioTrack 中——除了丑陋的脉冲静态噪声之外别无他物。现在我更加困惑了，因为这个确切的流仍然适用于 C 客户端。如果我找到解决方案，我会回来报告，但仍然欢迎任何帮助。

编辑 4 我应该补充一点，我可以播放来自另一个 android 应用程序的麦克风输入，在那里我将该输入直接作为字节发送(我将排除浮点转换内容并将我收到的字节直接放入播放器代码中的 audioTrack)。
我还发现，这可能是一个问题，由 C 服务器流式传输的上述 floatarray 来自 64 位机器，而手机是 32 位。即使我只是将浮点数流式传输为 4 个字节，这是否会以某种方式成为问题？
或者，我的另一个想法:我收到的字节的基础数字格式是浮点数。 AudioTrack 期望什么格式？即使只放入字节 - 我是否需要将该浮点数转换为 int 并将其转换回字节或其他内容？

新代码:

public class PCMSocket {

AudioTrack audioTrack;
boolean doStop = false;
int musicLength = 4096;
byte[] music;
Socket socket;
short[] buffer = new short[4096];
float[] fmusic = new float[1024];
WriteToAudio writeThread;
ReadFromSocket readThread;


public PCMSocket()
{

}

public void start()
{
    doStop = false;
    readThread = new ReadFromSocket();
    readThread.start();
}

public class ReadFromSocket extends Thread
{       
    public void run()
    {
    doStop=true;

    InetSocketAddress address = new InetSocketAddress("xxx.xxx.xxx.x", 8000);

    socket = new Socket();
    int timeout = 6000;   
    try {
        socket.connect(address, timeout);
    } catch (IOException e2) {
        e2.printStackTrace();
    }

     musicLength = 1024;

    InputStream is = null;

    try {
        is = socket.getInputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }

    BufferedInputStream bis = new BufferedInputStream(is);
    DataInputStream dis = new DataInputStream(bis);     

    try{

    int minSize =AudioTrack.getMinBufferSize( 44100, AudioFormat.CHANNEL_CONFIGURATION_STEREO, AudioFormat.ENCODING_PCM_16BIT ); 

    audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, 44100,
            AudioFormat.CHANNEL_OUT_STEREO, 
            AudioFormat.ENCODING_PCM_16BIT, minSize,
            AudioTrack.MODE_STREAM);
        audioTrack.play();

      } catch (Throwable t)
      {
          t.printStackTrace();
        doStop = true;
      }

    writeThread = new WriteToAudio();
    readThread.start();

    int i = 0;   
    int j=0;

    try {
        if(dis.available()>0)Log.d("PCMSocket", "receiving");
        music = new byte[4];
        while (dis.available() > 0)
        {
            music[i]=0;
            music[i] = dis.readByte(); 

            if(i==3)
            {
                int asInt = 0;
                asInt = ((music[0] & 0xFF) << 0) 
                        | ((music[1] & 0xFF) << 8) 
                        | ((music[2] & 0xFF) << 16) 
                        | ((music[3] & 0xFF) << 24);
                float asFloat = 0;
                asFloat = Float.intBitsToFloat(asInt);
                fmusic[j]=asFloat;
            }

            i++;
            j++;
            if(i==4)
            {
                music = new byte[4]; 
                i=0;
            }
            if(j==1024)
            {
                j=0;
                if(doStop)doStop=false;
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    try {
        dis.close();
    } catch (IOException e) {
        e.printStackTrace();
    }  

    }
};


public class WriteToAudio extends Thread
{       
    public void run()
    {
        while(true){
        while(!doStop)
        {           
            try{
                writeSamples(fmusic);

            }catch(Exception e)
            {
                e.printStackTrace();
            }    
            doStop = true;
        }
        }
    }
};


public void writeSamples(float[] samples) 
{   
   fillBuffer( samples );
   audioTrack.write( buffer, 0, samples.length );
}

private void fillBuffer( float[] samples )
{ 
   if( buffer.length < samples.length )
      buffer = new short[samples.length];

   for( int i = 0; i < samples.length; i++ )
   {
      buffer[i] = (short)(samples[i] * Short.MAX_VALUE);
   }
}   


}

旧代码:

public class PCMSocket {
AudioTrack audioTrack;
WriteToAudio thread;
boolean doStop = false;
int musicLength = 4096;
byte[] music;
Socket socket;
short[] buffer = new short[4096];
float[] fmusic = new float[1024];


public PCMSocket()
{

}

public void start()
{
    doStop = false;
    new GetStream().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}

private class GetStream extends AsyncTask<Void, Void, Void> {

    @Override
    protected Void doInBackground(Void... values) { 
        PCMSocket.this.getSocket();
        return null;

    }

    @Override
    protected void onPreExecute() {
    }



    @Override
    protected void onPostExecute(Void result)
    {
        return;
    }

    @Override
    protected void onProgressUpdate(Void... values) {
    }
}

private void getSocket()
{
    doStop=true;

    InetSocketAddress address = new InetSocketAddress("xxx.xxx.xxx.x", 8000);

    socket = new Socket();
    int timeout = 6000;   
    try {
        socket.connect(address, timeout);
    } catch (IOException e2) {
        e2.printStackTrace();
    }

     musicLength = 1024;

    InputStream is = null;

    try {
        is = socket.getInputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }

    BufferedInputStream bis = new BufferedInputStream(is);
    DataInputStream dis = new DataInputStream(bis);     

    try{

    int minSize =AudioTrack.getMinBufferSize( 44100, AudioFormat.CHANNEL_CONFIGURATION_STEREO, AudioFormat.ENCODING_PCM_16BIT ); 

    audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, 44100,
            AudioFormat.CHANNEL_OUT_STEREO, 
            AudioFormat.ENCODING_PCM_16BIT, minSize,
            AudioTrack.MODE_STREAM);
        audioTrack.play();

      } catch (Throwable t)
      {
          t.printStackTrace();
        doStop = true;
      }

    thread = new WriteToAudio();
    thread.start();

    int i = 0;   
    int j=0;

    try {
        if(dis.available()>0)Log.d("PCMSocket", "receiving");
        music = new byte[4];
        while (dis.available() > 0)
        {
            music[i]=0;
            music[i] = dis.readByte(); 

            if(i==3)
            {
                int asInt = 0;
                asInt = ((music[0] & 0xFF) << 0) 
                        | ((music[1] & 0xFF) << 8) 
                        | ((music[2] & 0xFF) << 16) 
                        | ((music[3] & 0xFF) << 24);
                float asFloat = 0;
                asFloat = Float.intBitsToFloat(asInt);
                fmusic[j]=asFloat;
            }

            i++;
            j++;
            if(i==4)
            {
                music = new byte[4]; 
                i=0;
            }
            if(j==1023)
            {
                j=0;
                if(doStop)doStop=false;
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    try {
        dis.close();
    } catch (IOException e) {
        e.printStackTrace();
    }  

}


public class WriteToAudio extends Thread
{       
    public void run()
    {
        while(true){
        while(!doStop)
        {           
            try{
                writeSamples(fmusic);

            }catch(Exception e)
            {
                e.printStackTrace();
            }    
            doStop = true;
        }
        }
    }
};


public void writeSamples(float[] samples) 
{   
   fillBuffer( samples );
   audioTrack.write( buffer, 0, samples.length );
}

private void fillBuffer( float[] samples )
{ 
   if( buffer.length < samples.length )
      buffer = new short[samples.length*4];

   for( int i = 0; i < samples.length; i++ )
   {
      buffer[i] = (short)(samples[i] * Short.MAX_VALUE);
   }
}   


}

Answer 1

Sooo ......我只是在我拼命悬赏之后几个小时才解决了这个问题，但这是值得的。

我决定重新开始。对于线程等的设计，我从 this awesome project 那里得到了一些帮助。 ， 这对我帮助很大。现在我只使用一个线程。似乎重点是类型转换的东西，但我不太确定，它也可能是多线程。我不知道 AudioTracker 的 byte[] 构造函数期望什么样的字节，但肯定没有浮点字节。所以我知道我需要使用 short[] 构造函数。我所做的是
- 将字节放入字节[]
- 取其中的 4 个并将它们转换为循环中的浮点数
- 把每一个漂浮物都扔到短裤上

因为我之前已经这样做了，所以我不太确定问题是什么。但现在它起作用了。
我希望这可以帮助那些和我经历过同样痛苦的人。非常感谢所有参与和评论的人。

编辑:我只是考虑了这些变化，并认为我之前使用 CHANNEL_CONFIGURATION_STEREO 而不是 MONO 对口吃做出了很大贡献。因此，如果遇到此问题，您可能想先尝试一下。对我来说，这只是解决方案的一部分，改变它并没有帮助。

    static final int frequency = 44100;
    static final int channelConfiguration = AudioFormat.CHANNEL_CONFIGURATION_MONO;
    static final int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;
    boolean isPlaying;
    int playBufSize;
    Socket socket;
    AudioTrack audioTrack;

    playBufSize=AudioTrack.getMinBufferSize(frequency, channelConfiguration, audioEncoding);
    audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, frequency, channelConfiguration, audioEncoding, playBufSize, AudioTrack.MODE_STREAM);

    new Thread() {
        byte[] buffer = new byte[4096];
        public void run() {
            try { 
                socket = new Socket(ip, port); 
            }
            catch (Exception e) {
                e.printStackTrace();
            }
            audioTrack.play();
            isPlaying = true;
            while (isPlaying) {
                int readSize = 0;
                try { readSize = socket.getInputStream().read(buffer); }
                catch (Exception e) {
                    e.printStackTrace();
                }
                short[] sbuffer = new short[1024];
                for(int i = 0; i < buffer.length; i++)
                {

                    int asInt = 0;
                    asInt = ((buffer[i] & 0xFF) << 0) 
                            | ((buffer[i+1] & 0xFF) << 8) 
                            | ((buffer[i+2] & 0xFF) << 16) 
                            | ((buffer[i+3] & 0xFF) << 24);
                    float asFloat = 0;
                    asFloat = Float.intBitsToFloat(asInt);
                    int k=0;
                    try{k = i/4;}catch(Exception e){}
                    sbuffer[k] = (short)(asFloat * Short.MAX_VALUE);

                    i=i+3;
                }
                audioTrack.write(sbuffer, 0, sbuffer.length);
            }  
            audioTrack.stop();
            try { socket.close(); }
            catch (Exception e) { e.printStackTrace(); }
        }
    }.start();