我的目标是使用 Android MediaCodec 对视频流进行解码，然后使用输出图像在 native 代码中进行进一步的图像处理。

平台:ASUS tf700t android 4.1.1。 测试码流:H.264 full HD @ 24 frm/s

在内置 Tegra-3 SoC 的情况下，我指望硬件支持视频解码。在功能上，我的应用程序按预期运行:我确实可以访问解码器图像 并妥善处理。但是，我遇到了非常高的解码器 CPU 负载。

在接下来的实验中，进程/线程负载是通过 adb shell 中的“top -m 32 -t”测量的。为了从“top”获得可靠的输出，所有 4 个 cpu 内核都通过运行几个线程以最低优先级永远循环来强制激活。这可以通过重复执行“cat/sys/devices/system/cpu/cpu[0-3]/online”来确认。为了简单起见，只有视频解码，没有音频；并且没有时间控制，因此解码器会尽可能快地运行。

第一个实验:运行应用程序，调用 JNI 处理函数，但所有进一步的处理调用都被注释掉了。结果:

• 吞吐量:25 frm/s
• 应用程序线程 VideoDecoder 的 1% 负载
• 进程/system/bin/mediaserver 的线程 Binder_3 负载为 24%

似乎解码速度受 CPU 限制(四核 CPU 的 25%)... 启用输出处理时，解码的图像是正确的并且应用程序可以运行。唯一的问题:解码的 CPU 负载太高。

经过大量实验后，我考虑为 MediaCodec 提供一个表面来绘制其结果。在所有其他方面，代码是相同的。结果:

• 吞吐量 55 frm/s(不错!!)
• 应用程序线程 VideoDecoder 的 2% 负载
• 1% 进程/system/bin/mediaserver 的线程 mediaserver 负载

确实，视频显示在提供的 Surface 上。由于几乎没有任何 cpu 负载，这必须是硬件加速...

似乎 de MediaCodec 仅在提供 Surface 时才使用硬件加速？

到目前为止，还不错。我已经倾向于使用 Surface 作为解决方法(不是必需的，但在某些情况下甚至是可有可无)。但是，如果提供了表面，我将无法访问输出图像!结果是 native 代码中的访问冲突。

这让我很困惑!我没有看到任何访问限制的概念，或文档中的任何内容 http://developer.android.com/reference/android/media/MediaCodec.html . 在谷歌 I/O 演示中也没有提到这个方向 http://www.youtube.com/watch?v=RQws6vsoav8 .

那么:如何使用硬件加速的 Android MediaCodec 解码器并以 native 代码访问图像？如何避免访问冲突？任何帮助表示赞赏!还有任何解释或提示。

我很确定 MediaExtractor 和 MediaCodec 被正确使用，因为应用程序 功能正常(只要我不提供 Surface)。 它仍然处于试验阶段，好的 API 设计在待办事项列表中；-)

请注意，两个实验之间的唯一区别是变量 mSurface: null 或实际 Surface 在“mDecoder.configure(mediaFormat, mSurface, null, 0);”

初始化代码:

mExtractor = new MediaExtractor();
mExtractor.setDataSource(mPath);

// Locate first video stream
for (int i = 0; i < mExtractor.getTrackCount(); i++) {
    mediaFormat = mExtractor.getTrackFormat(i);
    String mime = mediaFormat.getString(MediaFormat.KEY_MIME);
    Log.i(TAG, String.format("Stream %d/%d %s", i, mExtractor.getTrackCount(), mime));
    if (streamId == -1 && mime.startsWith("video/")) {
        streamId = i;
    }
}

if (streamId == -1) {
    Log.e(TAG, "Can't find video info in " + mPath);
    return;
}

mExtractor.selectTrack(streamId);
mediaFormat = mExtractor.getTrackFormat(streamId);

mDecoder = MediaCodec.createDecoderByType(mediaFormat.getString(MediaFormat.KEY_MIME));
mDecoder.configure(mediaFormat, mSurface, null, 0);

width = mediaFormat.getInteger(MediaFormat.KEY_WIDTH);
height = mediaFormat.getInteger(MediaFormat.KEY_HEIGHT);
Log.i(TAG, String.format("Image size: %dx%d format: %s", width, height, mediaFormat.toString()));
JniGlue.decoutStart(width, height);

解码器循环(在单独的线程中运行):

ByteBuffer[] inputBuffers = mDecoder.getInputBuffers();
ByteBuffer[] outputBuffers = mDecoder.getOutputBuffers();

while (!isEOS && !Thread.interrupted()) {
    int inIndex = mDecoder.dequeueInputBuffer(10000);
    if (inIndex >= 0) {
        // Valid buffer returned
        int sampleSize = mExtractor.readSampleData(inputBuffers[inIndex], 0);
        if (sampleSize < 0) {
            Log.i(TAG, "InputBuffer BUFFER_FLAG_END_OF_STREAM");
            mDecoder.queueInputBuffer(inIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
            isEOS = true;
        } else {
            mDecoder.queueInputBuffer(inIndex, 0, sampleSize, mExtractor.getSampleTime(), 0);
            mExtractor.advance();
        }
    }

    int outIndex = mDecoder.dequeueOutputBuffer(info, 10000);
    if (outIndex >= 0) {
        // Valid buffer returned
        ByteBuffer buffer = outputBuffers[outIndex];
        JniGlue.decoutFrame(buffer, info.offset, info.size);
        mDecoder.releaseOutputBuffer(outIndex, true);
    } else {
        // Some INFO_* value returned
        switch (outIndex) {
        case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
            Log.i(TAG, "RunDecoder: INFO_OUTPUT_BUFFERS_CHANGED");
            outputBuffers = mDecoder.getOutputBuffers();
            break;
        case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
            Log.i(TAG, "RunDecoder: New format " + mDecoder.getOutputFormat());
            break;
        case MediaCodec.INFO_TRY_AGAIN_LATER:
            // Timeout - simply ignore
            break;
        default:
            // Some other value, simply ignore
            break;
        }
    }

    if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
        Log.d(TAG, "RunDecoder: OutputBuffer BUFFER_FLAG_END_OF_STREAM");
        isEOS = true;
    }
}

最佳答案

如果配置输出表面，解码数据将写入可用作 OpenGL ES 纹理(通过“外部纹理”扩展)的图形缓冲区。硬件的各个部分以他们喜欢的格式传递数据，而 CPU 不必复制数据。

如果不配置 Surface，输出将进入 java.nio.ByteBuffer。至少有一个缓冲区副本用于将数据从 MediaCodec 分配的缓冲区获取到您的 ByteByffer，并且可能还有另一个副本用于将数据返回到您的 JNI 代码中。我希望您看到的是间接成本，而不是软件解码成本。

您可能可以通过将输出发送到 SurfaceTexture，渲染到 FBO 或 pbuffer，然后使用 glReadPixels 来改善问题提取数据。如果您读入“直接”ByteBuffer 或从 native 代码调用 glReadPixels，则可以减少 JNI 开销。这种方法的缺点是您的数据将采用 RGB 而不是 YCbCr。 (OTOH，如果你想要的转换可以在 GLES 2.0 fragment 着色器中表达，你可以让 GPU 代替 CPU 来完成工作。)

如另一个答案所述，不同设备上的解码器以不同格式输出 ByteBuffer 数据，因此如果可移植性对您很重要，则在软件中解释数据可能不可行。

编辑: Grafika现在有一个使用GPU做图像处理的例子。你可以看演示视频here .

关于android - 使用硬件加速 Android MediaCodec 解码器的 native 代码中的访问冲突，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15500290/