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

Question

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

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

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

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

编辑：我通过比较浮点数来检查字节序，它们在 -1 和 1 之间具有正确的值，并且与我发送的值相同。 由于我在转换为浮动时不更改字节序，我不明白为什么将 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...我只是在我拼命悬赏之后几个小时才解决了这个问题，但这是值得的。

我决定重新开始。 对于线程等的设计，我从这个很棒的项目中得到了一些帮助，它对我帮助很大。 现在我只使用一个线程。 似乎重点是铸造的东西，但我不太确定，它也可能是多线程。 我不知道 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();

Answer 2

破除一切，所有的的available()的测试。 只需让您的代码阻塞在以下read()语句中即可。 无论如何，您没有更好的事情可做，您甚至试图避免阻塞，只会消耗潜在的宝贵 CPU 周期。

编辑具体来说：

    try {
        socket.connect(address, timeout);
    } catch (IOException e2) {
        e2.printStackTrace();
    }

捕获此异常并允许以下代码继续执行的糟糕做法，就好像它没有发生一样。 应该允许异常传播给调用者。

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

同上。

    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);

这都是毫无意义的。 将其全部替换为short asInt = dis.readInt(); .

                float asFloat = 0;
                asFloat = Float.intBitsToFloat(asInt);

鉴于原始转换为short是通过floatValue * Short.MAX_VALUE ，此转换应为asFloat = (float)asInt/Short.MAX_VALUE 。

            if(i==4)

如果i之前是 3 岁，现在是 4 岁，那么这个测试也毫无意义。

                music = new byte[4]; 

您不需要重新分配music 。 消除。

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

看上面。 无意义。 应该允许异常传播给调用者。

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

所有这些都应该在finally块中。

    }
};

        while(true){
        while(!doStop)

您不需要这两个循环。

            try{
                writeSamples(fmusic);
            }catch(Exception e)
            {
                e.printStackTrace();
            }

看上面。 无意义。 在这种情况下，异常应该终止循环，因为写入套接字的任何IOException对连接都是致命的。 if( buffer.length < samples.length ) buffer = new short[samples.length];

为什么buffer已经不是合适的大小？ 或者，如果buffer.length > samples.length呢？