使用MediaCodec实现视频解码播放

移动开发 Android
MediaCodec解码的过程包括配置、启动、输入数据、获取解码数据和渲染等步骤,通过这些步骤可以实现高效的音视频解码。

MediaCodec是Android平台上的一个多媒体编解码器,用于对音频和视频数据进行编解码。它可以实现高效的音视频编解码,并且可以与硬件加速器结合使用,提高编解码性能。MediaCodec可以用于录制和播放音视频,以及进行实时的音视频通信等场景。

MediaCodec常用的方法:

  1. createDecoderByType(String mimeType):根据指定的MIME类型创建解码器。
  2. createEncoderByType(String mimeType):根据指定的MIME类型创建编码器。
  3. configure(MediaFormat format, Surface surface, MediaCrypto crypto, int flags):配置解码器或编码器的参数,包括媒体格式、渲染表面、加密等。
  4. start():启动解码器或编码器。
  5. flush():清空解码器或编码器的输入和输出缓冲区。
  6. release():释放解码器或编码器的资源。

MediaCodec解码过程:

  1. 创建MediaCodec对象:首先需要创建一个MediaCodec对象,并指定要进行的编解码操作(编码或解码)以及要使用的编解码器类型。
  2. 配置MediaFormat:接下来需要配置MediaFormat,即指定要解码的媒体数据的格式,包括媒体类型(音频或视频)、采样率、比特率等参数。
  3. 配置Surface(可选):如果是视频解码,可以通过设置Surface来将解码后的视频数据直接渲染到Surface上,以实现视频播放。
  4. 启动MediaCodec:配置完成后,可以调用start()方法启动MediaCodec。
  5. 输入数据:接下来需要将要解码的媒体数据传递给MediaCodec进行解码。可以通过调用queueInputBuffer()方法将媒体数据传递给MediaCodec。
  6. 获取解码数据:MediaCodec会将解码后的数据输出到指定的Surface或ByteBuffer中,可以通过调用dequeueOutputBuffer()方法获取解码后的数据。
  7. 渲染(可选):如果是视频解码并且使用了Surface,解码后的视频数据会直接渲染到Surface上,如果是音频解码或者视频解码但不使用Surface,需要将解码后的数据进行渲染或播放。
  8. 释放资源:解码完成后,需要释放MediaCodec对象及相关资源。

MediaCodec解码的过程包括配置、启动、输入数据、获取解码数据和渲染等步骤,通过这些步骤可以实现高效的音视频解码。

播放视频

使用MediaCodec解码本地h264文件并播放视频。

  1. 创建一个MediaExtractor来读取h264文件的数据流。
  2. 通过MediaFormat获取视频文件的格式信息,包括视频的宽、高、帧率等参数。
  3. 创建一个MediaCodec来进行视频解码。
  4. 将解码后的视频帧渲染到Surface上进行播放。
// 创建MediaExtractor并指定要解码的文件路径
MediaExtractor extractor = new MediaExtractor();
extractor.setDataSource(path);

// 获取视频文件的格式信息
MediaFormat format = null;
for (int i = 0; i < extractor.getTrackCount(); i++) {
    format = extractor.getTrackFormat(i);
    String mime = format.getString(MediaFormat.KEY_MIME);
    if (mime.startsWith("video/")) {
        extractor.selectTrack(i);
        break;
    }
}

// 创建MediaCodec并配置解码器
MediaCodec codec = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME));
codec.configure(format, surface, null, 0);
codec.start();

// 读取并解码视频帧
ByteBuffer[] inputBuffers = codec.getInputBuffers();
ByteBuffer[] outputBuffers = codec.getOutputBuffers();
MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
boolean isEOS = false;
while (!isEOS) {
    int inputBufferIndex = codec.dequeueInputBuffer(10000);
    if (inputBufferIndex >= 0) {
        ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
        int sampleSize = extractor.readSampleData(inputBuffer, 0);
        if (sampleSize < 0) {
            codec.queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
            isEOS = true;
        } else {
            codec.queueInputBuffer(inputBufferIndex, 0, sampleSize, extractor.getSampleTime(), 0);
            extractor.advance();
        }
    }

    int outputBufferIndex = codec.dequeueOutputBuffer(info, 10000);
    if (outputBufferIndex >= 0) {
        codec.releaseOutputBuffer(outputBufferIndex, true);
    }
}

// 释放资源
codec.stop();
codec.release();
extractor.release();

具体实现:

// 解码工具类

public class H264Player implements Runnable {

    // 本地 h264 文件路径
    private String path;
    private Surface surface;
    private MediaCodec mediaCodec;
    private Context context;

    public H264Player(Context context, String path, Surface surface) {

        this.context = context;
        this.path = path;
        this.surface = surface;
        try {
            this.mediaCodec = MediaCodec.createDecoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
            // 视频宽高暂时写死
            MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, 368, 384);
            mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 15);
            mediaCodec.configure(mediaFormat, surface, null, 0);
        } catch (IOException e) {
            // 解码芯片不支持,走软解
            e.printStackTrace();
        }
    }


    public void play() {
        mediaCodec.start();
        new Thread(this::run).start();
    }

    @Override
    public void run() {
        // 解码 h264
        decodeH264();
    }

    private void decodeH264() {
        byte[] bytes = null;
        try {
            bytes = getBytes(path);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 获取队列
        ByteBuffer[] byteBuffers = mediaCodec.getInputBuffers();
        int startIndex = 0;
        int nextFrameStart;
        int totalCount = bytes.length;

        while (true) {
            if (startIndex >= totalCount) {
                break;
            }
            MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
            nextFrameStart = findFrame(bytes, startIndex+1,totalCount);
            // 往 ByteBuffer 中塞入数据
            int index = mediaCodec.dequeueInputBuffer(10 * 1000);
            Log.e("index",index+"");
            // 获取 dsp 成功
            if (index >= 0) {
                // 拿到可用的 ByteBuffer
                ByteBuffer byteBuffer = byteBuffers[index];
                byteBuffer.clear();
                byteBuffer.put(bytes, startIndex, nextFrameStart - startIndex);
                // 识别分隔符,找到分隔符对应的索引
                mediaCodec.queueInputBuffer(index, 0, nextFrameStart - startIndex, 0, 0);
                startIndex = nextFrameStart;

            }else {
                continue;
            }


            // 从 ByteBuffer 中获取解码好的数据
            int outIndex = mediaCodec.dequeueOutputBuffer(info,10 * 1000);
            if (outIndex > 0){
                try {
                    Thread.sleep(33);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mediaCodec.releaseOutputBuffer(outIndex, true);
            }

        }
    }

    private int findFrame(byte[] bytes, int startIndex, int totalSize) {
        for (int i = startIndex; i < totalSize - 4; i++) {
            if (bytes[i] == 0x00 && bytes[i + 1] == 0x00 && bytes[i + 2] == 0x00 && bytes[i + 3] == 0x01) {
                return i;
            }

        }
        return -1;
    }


    /**
     * 一次性读取文件
     *
     * @param path
     * @return
     * @throws IOException
     */
    public byte[] getBytes(String path) throws IOException {
        InputStream is = new DataInputStream(new FileInputStream(new File(path)));
        int len;
        int size = 1024;
        byte[] buf;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        buf = new byte[size];
        while ((len = is.read(buf, 0, size)) != -1)
            bos.write(buf, 0, len);
        buf = bos.toByteArray();
        return buf;
    }
    
    public void destroy(){
        if (mediaCodec != null) {
            mediaCodec.stop();
            mediaCodec.release();
        }
    }
}

播放视频:

public class MainActivity extends AppCompatActivity {

    private H264Player h264Player;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        checkPermission();
        initSurface();
    }

    private void initSurface() {
        SurfaceView surfaceView = findViewById(R.id.surface);
        SurfaceHolder surfaceHolder = surfaceView.getHolder();
        surfaceHolder.addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder surfaceHolder) {
                h264Player = new H264Player(MainActivity.this, new File(Environment.getExternalStorageDirectory(), "test.h264").getAbsolutePath(), surfaceHolder.getSurface());
                h264Player.play();
            }

            @Override
            public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {
            }

            @Override
            public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
            }
        });
    }

    private boolean checkPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                && checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(new String[]{
                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
                    Manifest.permission.READ_EXTERNAL_STORAGE
            }, 1);
        }
        return false;
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 停止解码器
        h264Player.destroy();
    }
}

上述代码使用MediaCodec来解码视频流,并将解码后的视频渲染到SurfaceView上,在Activity销毁时释放MediaCodec资源。

责任编辑:武晓燕 来源: 沐雨花飞蝶
相关推荐

2024-02-28 08:22:07

2013-07-01 10:53:05

2022-08-26 12:13:08

APIjavascript视频

2022-03-06 20:02:21

监听视频播放

2011-07-20 16:21:20

iPhone 视频 播放器

2011-08-17 14:57:31

iPhone应用视频播放

2022-03-24 15:00:09

Harmony编解码鸿蒙

2021-08-30 07:49:32

Javascript西瓜视频

2021-03-17 15:49:03

鸿蒙HarmonyOS应用

2023-08-26 19:07:40

VLC旋转视频

2021-10-29 07:49:23

Python弹幕播放

2022-04-26 14:33:21

鸿蒙操作系统

2014-10-20 09:55:02

2011-08-10 15:58:58

iPhone视频

2022-08-16 17:37:06

视频播放器鸿蒙

2021-07-13 09:27:20

AI 解码视频

2022-04-15 11:30:59

代码,Python保存视频

2023-07-26 17:16:43

微软Windows

2022-05-12 10:26:57

解码器Linux

2009-12-15 15:00:00

Fedora Linu
点赞
收藏

51CTO技术栈公众号