使用 MediaCodec 流解码原始 h264 会导致黑色表面

Question

你好堆栈溢出，

我目前正在编写一个框架来实现智能手机的虚拟现实体验。因此，图形内容在服务器（立体镜）上呈现、编码并发送到智能手机。我使用的是 LG 的 Nexus 5x。我正在编写的应用程序最初包含两个纹理视图以及解码和显示帧的逻辑。但是，Android 的 MediaCodec class 在每次尝试时都会崩溃，因此我尝试根据我之前编写的工作代码创建一个只有一个表面的最小工作示例。但是尽管 MediaCodec 不再抛出 CodecException，表面仍然是黑色。

public class MainActivity extends Activity implements SurfaceHolder.Callback
{
private DisplayThread displayThread = null;

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    SurfaceView sv = new SurfaceView(this);
    sv.getHolder().addCallback(this);
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
    setContentView(sv);
}

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)
{
    if (displayThread == null)
    {
        displayThread = new DisplayThread(holder.getSurface());
        displayThread.start();
    }
}

private class DisplayThread extends Thread
{
    private MediaCodec codec;
    private Surface surface;
    private UdpReceiver m_renderSock;


    public DisplayThread(Surface surface)
    {
        this.surface = surface;
    }

    @Override
    public void run()
    {
        m_renderSock = new UdpReceiver(9091);

        //Configuring Media Decoder
        try {
            codec = MediaCodec.createDecoderByType("video/avc");
        } catch (IOException e) {
            throw new RuntimeException(e.getMessage());
        }

        MediaFormat format = MediaFormat.createVideoFormat("video/avc", 1280,720);

        codec.configure(format, surface, null, 0);
        codec.start();


        while(!Thread.interrupted())
        {
            int frameSize = 0;
            byte[] frameData = m_renderSock.receive();

            if(frameData.length == 1) // Just for the moment, to cope with the first pakets get lost because of missing ARP, see 
                continue;

            /*Edit: This part may be left out*/
            int NAL_START = 1;
            //103, 104 -> SPS, PPS  | 101 -> Data
            int id = 0;
            int dataOffset = 0;

            //Later on this will be serversided, but for now... 
            //Separate the SPSPPS from the Data
            for(int i = 0; i < frameData.length - 4; i++)
            {
                id = frameData[i] << 24 |frameData[i+1] << 16 | frameData[i+2] << 8
                        | frameData[i+3];

                if(id == NAL_START) {
                    if(frameData[i+4] == 101)
                    {
                        dataOffset = i;
                    }
                }
            }


            byte[] SPSPPS = Arrays.copyOfRange(frameData, 0, dataOffset);
            byte[] data = Arrays.copyOfRange(frameData, dataOffset, frameData.length);

            if(SPSPPS.length != 0) {
                int inIndex = codec.dequeueInputBuffer(100000);

                if(inIndex >= 0)
                {
                    ByteBuffer input = codec.getInputBuffer(inIndex);
                    input.clear();
                    input.put(SPSPPS);
                    codec.queueInputBuffer(inIndex, 0, SPSPPS.length, 16, MediaCodec.BUFFER_FLAG_CODEC_CONFIG);
                }
            }
            /*Edit end*/

            int inIndex = codec.dequeueInputBuffer(10000);
            if(inIndex >= 0)
            {
                ByteBuffer inputBuffer = codec.getInputBuffer(inIndex);
                inputBuffer.clear();
                //inputBuffer.put(data);
                inputBuffer.put(frameData);
                //codec.queueInputBuffer(inIndex, 0, data.length, 16, 0);
                codec.queueInputBuffer(inIndex, 0, frameData.length, 16, 0);
            }

            BufferInfo buffInfo = new MediaCodec.BufferInfo();
            int outIndex = codec.dequeueOutputBuffer(buffInfo, 10000);

            switch(outIndex)
            {
                case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
                    break;
                case MediaCodec.INFO_TRY_AGAIN_LATER:
                    break;
                case -3: //This solves it
                    break;
                default:
                    ByteBuffer buffer = codec.getOutputBuffer(outIndex);
                    codec.releaseOutputBuffer(outIndex, true);
            }


        }
    }
}

基本上这段代码在过去是有效的。但当时媒体编解码器 API 帽子 ByteBuffer[] 用于输入和输出缓冲区。也没有必要将 SPSPPS 数据与帧数据分开（至少我没有这样做并且它起作用了，也可能是因为 Nvcuvenc 将每个 NALU 分开了）。

我检查了两个缓冲区的内容，结果如下：

SPSPPS: 
0 0 0 1 103 100 0 32 -84 43 64 40 2 -35 -128 -120 0 0 31 64 0 14 -90 4 120 -31 -107 
0 0 1 104 -18 60 -80

Data:
0 0 0 1 101 -72 4 95 ...

对我来说，这看起来是正确的。 h264 流是使用 Nvidias NVenc API 创建的，如果保存到光盘，则可以毫无问题地使用 VLC 播放。

对于大代码块，我深表歉意。感谢您的帮助！

Answer 1

所以唯一的问题是，dequeueOutputBuffers 仍然可能 return -3，又名 MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED，它被标记为已弃用。非常好。通过不处理此 return 值，或者更具体地说，使用常量值作为 getOutputBuffer() 的输入，编解码器会抛出错误 -> 黑屏。

编辑： 哦，显然也不需要整个 NAL 的东西。即使 API 指出，必须在开始之前提供 SPS 和 PPS NALU。我在我的问题中标记了可以省略的部分。

Answer 2

我在新的 Samsung 设备上看到了类似的行为，我怀疑编解码器可能有同样的问题。将尝试您的修复，谢谢。

此外，SPS/PPS 内容仅对于像 mp4 这样的拳击容器是必需的。原始播放器在带内。

使用 MediaCodec 流解码原始 h264 会导致黑色表面

Decoding raw h264 with MediaCodec stream results in black surface

java

android

decode

h.264