通过 Android 上的 TCP 套接字进行音频流式传输答案

【问题标题】：Audio streaming via TCP socket on Android通过 Android 上的 TCP 套接字进行音频流式传输
【发布时间】：2014-07-23 10:24:28
【问题描述】：

我正在通过套接字从 C 服务器流式传输麦克风输入。我知道流可以工作，因为它与 C 客户端一起工作，并且我在我的 Android 客户端上获得了正确的值。

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

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

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

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

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

编辑 3： 我玩弄了代码并在 cmets 中实现了一些 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);
   }
}   


}

【问题讨论】：

乍一看，这看起来应该可以工作（它的设计不是很好，但没有明显的功能问题），除了为每个样本读取分配一个新的字节数组效率低下。一些可能需要检查的事情：服务器是否使用相同的字节顺序（对于每个浮点数），浮点数是否都在 -1 和 1 之间？
是的，他们是。我测试了正确的字节序，并将它们放入 floatarray 后得到的浮点数与我发送的浮点数进行了比较，它们都应该在 -1 和 1 之间。我知道设计的东西，那是因为我用那个代码做了很多实验。当然在我使用它之前它会被清理干净。
+1 只是为了知道你在做什么并首先检查明显的事情。如果不运行它，我不知道你的问题是什么，只是一些显而易见的事情的想法。不过，这种多线程看起来也很可疑。
多线程也是我对错误源的想法，但是根据我的日志，双 while 应该可以工作。一旦一个数组准备好使用，它就会被调用。由于它是立即调用的，因此在将数组发送到 writeSamples 方法之前不应覆盖该数组。
有趣。您可以声明 doStop volatile，因为它在两个线程中使用。也许还有一些其他变量也被两者使用。

标签： java android sockets audio-streaming audiotrack

【解决方案1】：

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

我决定重新开始。对于线程等的设计，我从this awesome project 那里得到了一些帮助，这对我帮助很大。现在我只使用一个线程。似乎重点是铸造的东西，但我不太确定，它也可能是多线程。我不知道 AudioTracker 的 byte[] 构造函数期望什么样的字节，但肯定没有浮点字节。所以我知道我需要使用 short[] 构造函数。我所做的是
- 将字节放入 byte[]
- 取其中 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();

【讨论】：

【解决方案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 对连接都是致命的。如果（缓冲区.长度

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

【讨论】：