Android：音轨（流模式）在写入之间切换答案

【问题标题】：Android: Audio Track (Stream-Mode) cuts between writeAndroid：音轨（流模式）在写入之间切换
【发布时间】：2019-01-16 17:39:20
【问题描述】：

我的主要目标是能够将音频从一台设备流式传输到 LAN 中的另一台设备。我计划通过将 mp3 文件读入 byte[] （我已经开始工作）并将其作为 udp-packet 发送到第二个设备并在那里播放（我告诉你这个以防这已经是错误的方法）。我目前一直在玩我的字节数组。我使用 mp3 中的 decoder(path, startMs, durationMs) 函数读取了我的文件。目前我能够听到音频，但在每次滴答声（这是我读取文件的部分）之后，我在几毫秒内都没有听到任何声音，这导致了糟糕的聆听体验。我认为这与 Buffer-Size 有关，并尝试使用它进行一些调整，但这并没有真正改变什么，还添加了AudioTrack.WRITE_NON_BLOCKING。我还考虑将每个 for() 循环放在不同的线程中，但这根本不起作用（这是有道理的）。我也已经尝试过先读取文件并将我的 byte[] 放入 Arraylist 中，因为这可能是文件读取速度慢导致的问题，但仍然是相同的体验。知道Log.e("DEBUG", "Length " + data.length); 仅在每个滴答声中显示也可能会有所帮助，这意味着写入也仅在每个滴答声中发生（这可能是问题所在）。我怎样才能摆脱歌曲中的这些空白部分？

这是我点击按钮时执行的代码：

song.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Thread thrd = new Thread(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                int tick = 1000;
                                int max = 9000;
                                int sampleRate = 44100;
                                int bufSize = AudioTrack.getMinBufferSize(sampleRate*4, AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT);
                                byte[] data = decode(path, 0, tick);
                                AudioTrack track = new AudioTrack(AudioManager.STREAM_MUSIC,
                                        44100, AudioFormat.CHANNEL_OUT_STEREO,
                                        AudioFormat.ENCODING_PCM_16BIT, bufSize,
                                        AudioTrack.MODE_STREAM, AudioTrack.WRITE_NON_BLOCKING);
                                track.play();
                                track.write(data, 0, data.length);
                                Log.e("DEBUG", "Length " + data.length);
                                for(int i = tick; i < max; i+=tick) {
                                    data = decode(path, i, tick);
                                    track.write(data, 0, data.length);
                                    Log.e("DEBUG", "Length " + data.length);
                                }
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                    thrd.start();
                }
            });

我的decode()-function（基于this tutorial）与 JLayer 1.0.1：

public static byte[] decode(String path, int startMs, int maxMs)
            throws IOException {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream(1024);

        float totalMs = 0;
        boolean seeking = true;

        File file = new File(path);
        InputStream inputStream = new BufferedInputStream(new FileInputStream(file), 8 * 1024);
        try {
            Bitstream bitstream = new Bitstream(inputStream);
            Decoder decoder = new Decoder();

            boolean done = false;
            while (! done) {
                Header frameHeader = bitstream.readFrame();
                if (frameHeader == null) {
                    done = true;
                } else {
                    totalMs += frameHeader.ms_per_frame();

                    if (totalMs >= startMs) {
                        seeking = false;
                    }

                    if (!seeking) {
                        SampleBuffer output = (SampleBuffer) decoder.decodeFrame(frameHeader, bitstream);

                        if (output.getSampleFrequency() != 44100
                                || output.getChannelCount() != 2) {
                            Log.w("ERROR", "mono or non-44100 MP3 not supported");
                        }

                        short[] pcm = output.getBuffer();
                        for (short s : pcm) {
                            outStream.write(s & 0xff);
                            outStream.write((s >> 8) & 0xff);
                        }
                    }

                    if (totalMs >= (startMs + maxMs)) {
                        done = true;
                    }
                }
                bitstream.closeFrame();
            }
        } catch (BitstreamException e) {
            throw new IOException("Bitstream error: " + e);
        } catch (DecoderException e) {
            Log.w("ERROR", "Decoder error", e);
        } finally {
            inputStream.close();
        }
        return outStream.toByteArray();
    }

我认为解码函数不是问题，因为返回的 byte[] 似乎相当不错。也许稍后可以优化读取过程，当我真正流式传输音频并始终读取大约 10 毫秒的部分时，始终打开和关闭文件可能是个问题。

【问题讨论】：

请添加你的decode()函数的实现。
@greeble31 感谢您的反馈，decode() 现已包含在内！
记下你使用的是哪个AudioTrack构造函数；您的最后一个参数实际上是不匹配的。你所有的写都被阻塞了。为了使您选择的线程方案起作用，它们必须如此。您假设 write() 准确返回请求的字节数，因此您不希望有任何“短写”。
顺便说一下，你需要你的写是阻塞的，而不是非阻塞的。这就是我第二条评论的意思。
或者，每次你从decode()得到一个结果，你可以把它变成一个方波，用这种模式替换数组的内容，端到端重复，以覆盖整个数组：[ 127, 127, 127, 127, 127, 127, 127, 127, 0, 0, 0, 0, 0, 0, 0, 0]。这应该产生一个连续的、高音调，没有任何间隙。如果将音频转换为 9 秒长的方波后，间隙仍然存在，那我肯定错了。你可以用 for 循环来做到这一点：if( ((i / 16) % 2) == 0 ) data[i] = 127; else data[i] = 0;。

标签： java android multithreading audio audiotrack

【解决方案1】：

事实证明，造成这种情况的根本原因是：您使用 decode() 函数的方式并非专门为它设计的。尽管 decode() 似乎可以让您以随机访问方式解码 .mp3 流的任何部分，但实际上返回的音频的前几毫秒是始终无声，无论您是从歌曲的开头或中间开始。这种沉默造成了“差距”。显然，decode() 函数更多地用于在随机位置重新开始播放，例如由于用户“寻找”。

decode() 之所以如此，是因为为了解码第 N 个压缩数据块，解码器需要块 N-1 和块 N。对应于块 N 的解压缩数据将很好，但是块 N-1 的数据会有这种“淡入”声音。这是 .mp3 解码器的一般特性，我知道 AAC 也会出现这种情况。同时，解码块N+1、N+2、N+3等都没有问题，因为在每种情况下，解码器都已经有了前一个块。

一种解决方案是更改decode() 函数：

private Decoder decoder;
private float totalMs;
private Bitstream bitstream;
private InputStream inputStream;

//call this once, when it is time to start a new song:
private void startNewSong(String path) throws IOException
{
    decoder = new Decoder();
    totalMs = 0;
    File file = new File(path);
    inputStream = new BufferedInputStream(new FileInputStream(file), 8 * 1024);
    bitstream = new Bitstream(inputStream);
}

private byte[] decode(String path, int startMs, int maxMs)
        throws IOException {
    ByteArrayOutputStream outStream = new ByteArrayOutputStream(1024);


    try {
        boolean done = false;
        while (! done) {
            Header frameHeader = bitstream.readFrame();
            if (frameHeader == null) {
                done = true;
                inputStream.close();   //Note this change. Now, the song is done. You can also clean up the decoder here.
            } else {
                totalMs += frameHeader.ms_per_frame();

                SampleBuffer output = (SampleBuffer) decoder.decodeFrame(frameHeader, bitstream);

                if (output.getSampleFrequency() != 44100
                        || output.getChannelCount() != 2) {
                    Log.w("ERROR", "mono or non-44100 MP3 not supported");
                }

                short[] pcm = output.getBuffer();
                for (short s : pcm) {
                    outStream.write(s & 0xff);
                    outStream.write((s >> 8) & 0xff);
                }

                if (totalMs >= (startMs + maxMs)) {
                    done = true;
                }
            }
            bitstream.closeFrame();
        }
    } catch (BitstreamException e) {
        throw new IOException("Bitstream error: " + e);
    } catch (DecoderException e) {
        Log.w("ERROR", "Decoder error", e);
    }
    return outStream.toByteArray();
}

该代码有点粗糙且已准备就绪，可以进行一些改进。但一般的方法是，decode() 每次使用FSM 来解码更多歌曲，而不是随机访问；多读一点文件，然后向解码器发送更多块。由于解码器（和bitstream）的状态在每次调用decode() 之间都会保留，因此无需寻找块N-1。

UDP 和流媒体

UDP 方法的有效性取决于很多因素。您可能想寻找其他特别解决这个问题的问题。 UDP 便于向给定子网上的多个设备广播，但它不能帮助您确保按顺序接收数据包，或者根本无法接收数据包。您可能需要 TCP。还要考虑您是要传输编码的 .mp3 块（由bitstream.readFrame() 返回的块）还是解压缩音频块。还要考虑如何处理网络延迟、断开连接和缓冲。这里有许多困难的设计决策，每个选择都有优点和缺点。祝你好运。

【讨论】：