[移动开发]Android音视频-MediaCodec硬解码获取所有帧数据

还是废了蛮多劲头，查了很多资料，终于能获取所有视频帧的数据了
依赖一些简单工具类，可以注释掉
还有一些不完善之处，比如如何指定解码宽高的，希望大神能指教
见代码

package a.baozouptu.editvideo.track;

import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible;

import android.annotation.SuppressLint;
import android.graphics.ImageFormat;
import android.media.ImageReader;
import android.media.MediaCodec;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;

import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;

import com.baozou.ptu.baselibrary.utils.LogUtil;
import com.baozou.ptu.baselibrary.utils.SegmentedProgressCallback;

import org.jetbrains.annotations.NotNull;

import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.util.Locale;

/**
 * 使用Android提的mediaCodec硬解码解码视频获取所有帧，回调返回解码的到的视频帧数据，硬解码特点是速度更快
 * <p>
 * 视频帧数据就是Android提供的ImageReader，然后再通过ImageReader获取数据做相应的处理
 * <p>
 * 关于解码到的ImageReader里面数据的格式，指定的是YUV格式的一类，ImageFormat.YUV_420_888 == COLOR_FormatYUV420Flexible
 * 但是这个格式里面又分了很多的子格式，由于厂商实现不同等原因，处理是需要进行判断，然后处理
 * <p>
 * 如果想要yuv转bitmap的rgb，
 * 具体可以通过libyuv库提供的接口，或者Android自带的几种方法，RenderScript，YuvImage等
 * <p>
 * 解码过程 包括获取视频信息 是异步的
 * <p>
 * 应该是可以指定解码宽高的，但是目前没成功
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class VideoFrameDecoder extends HandlerThread {
    public static final String TAG = "VideoFrameDecoder";


    // 控制选项
    /**
     * 控制取帧的间隔，为0表示所有帧
     */
    private long intervalMs = 0;//ms
    private boolean requestStop = false;

    private boolean initSuccess = false;

    @Nullable
    private final SegmentedProgressCallback progressCallback;
    @NotNull
    private final DecoderCallBack decoderCallBack;

    // 提取器->信息->解码器->读取器
    private MediaExtractor extractor;
    private MediaCodec mediaCodec;
    private ImageReader imageReader;

    private long lastPresentationTimeUs;
    // 单帧解码
    private FrameDecoder frameDecoder;

    /**
     * 解码器解码运行在这个handle所在的线程
     */
    private final Handler handler;
    /**
     * 处理解码器解码器来的数据运行在此线程
     */
    private ImageReaderHandlerThread imageReaderHandlerThread;

    // 视频信息
    private long durationUs;
    private int rotation;
    private int videoW;
    private int videoH;
    private int fps;
    private String colorFormatName = "no data";
    private int colorRange = -1;

    public VideoFrameDecoder(@NotNull DecoderCallBack decoderCallBack,
                             @Nullable SegmentedProgressCallback progressCallback) {
        super(TAG);

        start();
        Looper looper = getLooper();
        handler = new Handler(looper);
        this.progressCallback = progressCallback;
        this.decoderCallBack = decoderCallBack;

        extractor = new MediaExtractor();
        this.frameDecoder = new FrameDecoder();

        LogUtil.logTrack(TAG + " 创建完成");
    }

    /**
     * 注意是异步的
     */
    public void setVideoAndInitAsync(final String fileName) {
        initSuccess = false;
        handler.post(() -> {
            LogUtil.logTrack("开始获取视频信息 \n 当前线程是: " + Thread.currentThread().getName());
            if (progressCallback != null)
                progressCallback.onProgress(progressCallback.seg + 1, "正在获取视频信息");
            try {
                // 设置fileName
                extractor.setDataSource(fileName);

                MediaFormat videoFormat = extractVideoInfo();
                if (videoFormat == null) {
                    decoderCallBack.onError(new Exception("无法获取视频信息"));
                    return;
                }
//todo
      /*   **上面提到了 MediaCodecList，这里简单说一下，使用 MediaCodecList 可以方便的列出当前设备支持的所有的编解码器
      ，创建 MediaCodec 的时候要选择当前格式支持的编解码器，也就是选择的编解码器需支持对应的 MediaFormat，
      每个编解码器都被包装成一个 MediaCodecInfo 对象，据此可以查看该编码器的一些特性，
      比如是否支持硬件加速、是软解还是硬解编解码器等，常用的简单如下**：
```java
                1// 是否软解
                2public boolean isSoftwareOnly ()
                3// 是Android平台提供(false)还是厂商提供(true)的编解码器
                4public boolean isVendor ()
                5// 是否支持硬件加速
                6public boolean isHardwareAccelerated ()
                7// 是编码器还是解码器
                8public boolean isEncoder ()
                9// 获取当前编解码器支持的合适
                10public String[] getSupportedTypes ()
                11// ...
```*/
                // 设置解码器需要的视频的参数
                // 实测发现这个宽高设置无效，网上找了一些资料没找到缩放相关的，似乎不支持缩放
                int dstW = videoW, dstH = videoH;
                videoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, COLOR_FormatYUV420Flexible);
                videoFormat.setInteger(MediaFormat.KEY_WIDTH, dstW);
                videoFormat.setInteger(MediaFormat.KEY_HEIGHT, dstH);
                mediaCodec = MediaCodec.createDecoderByType(videoFormat.getString(MediaFormat.KEY_MIME));

                // 设置解码输出位置 surface 的参数
                int imageFormat = ImageFormat.YUV_420_888;
                imageReader = ImageReader.newInstance(
                        dstW, dstH, // 实测发现这个宽高设置无效，网上找了一些资料没找到缩放相关的，似乎不支持缩放
                        imageFormat,
                        1 // 解码到的surface缓存的帧数
                );

                // 配置好解码器，准备开始
                mediaCodec.configure(videoFormat, imageReader.getSurface(), null, 0);
                mediaCodec.start();


                LogUtil.logTrack("获取视频信息和初始化完成  当前线程是: " + Thread.currentThread().getName());
                LogUtil.logTrack(String.format(Locale.CHINA,
                        "视频信息：width = %d height = %d, 时长 = %ds fps = %d 旋转 = %d" +
                                "颜色格式 = %s 颜色范围 = %d",
                        videoW, videoH, durationUs, fps, rotation,
                        colorFormatName, colorRange));
                initSuccess = true;
                decoderCallBack.onInitVideoSuccess();
            } catch (Exception e) {
                initSuccess = false;
                e.printStackTrace();
                LogUtil.logTrack("init 视频解码器出错 \n 当前线程是: " + Thread.currentThread().getName());
                decoderCallBack.onError(new Exception("初始化视频解码器失败" + e.getMessage()));
            }
        });
    }

    private MediaFormat extractVideoInfo() {
        // 遍历轨道，选中视频,并获取视频信息
        MediaFormat videoFormat = null;
        int trackCount = extractor.getTrackCount();
        for (int i = 0; i < trackCount; i++) {
            MediaFormat trackFormat = extractor.getTrackFormat(i);
            if (trackFormat.getString(MediaFormat.KEY_MIME).contains("video")) {
                videoFormat = trackFormat;
                extractor.selectTrack(i);
                break;
            }
        }
        if (videoFormat == null) {
            LogUtil.logTrack("无法获取视频信息 \n 当前线程是: " + Thread.currentThread().getName());
            return null;
        } else {
            LogUtil.logTrack("init MediaExtractor finish \n 当前线程是: " + Thread.currentThread().getName());
        }

        videoW = videoFormat.getInteger(MediaFormat.KEY_WIDTH);
        videoH = videoFormat.getInteger(MediaFormat.KEY_HEIGHT);
        if (videoFormat.containsKey(MediaFormat.KEY_ROTATION) && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            rotation = videoFormat.getInteger(MediaFormat.KEY_ROTATION);
        }

        durationUs = videoFormat.getLong(MediaFormat.KEY_DURATION);
        if (videoFormat.containsKey(MediaFormat.KEY_FRAME_RATE))
            fps = videoFormat.getInteger(MediaFormat.KEY_FRAME_RATE);

        if (videoFormat.containsKey(MediaFormat.KEY_COLOR_RANGE) && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            colorRange = videoFormat.getInteger(MediaFormat.KEY_COLOR_RANGE);
        }
        if (videoFormat.containsKey(MediaFormat.KEY_ROTATION)) {
            colorFormatName = getColorFormatName(videoFormat.getInteger(MediaFormat.KEY_COLOR_FORMAT));
        }
        return videoFormat;
    }

    public void startDecode() {
        if (!initSuccess) {
            decoderCallBack.onError(new Exception("初始化失败，无法解码，请检查"));
            return;
        }

        imageReaderHandlerThread = new ImageReaderHandlerThread();
        handler.post(() -> {
            LogUtil.logTrack("开始解码 当前线程是: \" + Thread.currentThread().getName()");
            if (progressCallback != null) {
                progressCallback.addSeg("正在解码...");
            }
            imageReader.setOnImageAvailableListener(new MyOnImageAvailableListener(),
                    imageReaderHandlerThread.getHandler());
            extractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC);

            frameDecoder.decodeOneFrame();
            // processByExtractor(scale, decoderCallBack);
        });
    }

    /**
     * 每次解码一帧 然后等待消费位置消费完解码的那一帧之后， 回调解码器进行解码这样才不会丢帧
     */
    private class FrameDecoder {
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        long timeOutUs = 5 * 1000; // 微秒，不是毫秒
        /**
         * 整个文件输入完成
         */
        boolean inputFinish = false;
        /**
         * 整个文件输出完成
         */
        boolean outputDone = false;

        //开始进行解码。
        int count = 1;

        /**
         *
         */
        public void decodeOneFrame() {
            LogUtil.logTrack("开始解码一帧，当前线程是: " + Thread.currentThread().getName());
            try {
                // 这个循环会不断的解码数据往输出位置送，比如imageReader的surface，
                // 但是要注意的一定是，如果surface那边没有消费处理掉的帧，就会被新的解码数据覆盖，也就是说这一帧就丢失了
                if (outputDone) return;

                // 注意解码器一次输入的不一定是一帧的数据，且不会立即解码出来，所以要死循环等待一个完整的帧被解码出来
                boolean hasDecodeFrameFinish = false;
                while (!hasDecodeFrameFinish) {
                    if (requestStop) {
                        return;
                    }
                    if (!inputFinish) {
                        // 获取可用的输入缓冲区的索引
                        int inputBufferIndex = mediaCodec.dequeueInputBuffer(timeOutUs);
                        if (inputBufferIndex >= 0) {
                            ByteBuffer inputBuffer;
                            // if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                            // 获取输入缓冲区
                            inputBuffer = mediaCodec.getInputBuffer(inputBufferIndex);
                            // } else {
                            //     inputBuffer = inputBuffers[inputBufferIndex];
                            // }
                            // 填充数据
                            // simpleData the sample size (or -1 if no more samples are available).
                            // 读取数据的size，<=0表示读完了
                            int sampleData = extractor.readSampleData(inputBuffer, 0);
                            if (sampleData > 0) {
                                long sampleTime = extractor.getSampleTime();
                                LogUtil.logTrack(String.format(Locale.CHINA, "解码到的时间 = %.4fs",
                                        sampleTime / 1000000f));
                                // 将填满数据的inputBuffer提交到编码队列
                                mediaCodec.queueInputBuffer(inputBufferIndex, 0, sampleData, sampleTime, 0);
                                //继续
                                if (intervalMs == 0) {
                                    extractor.advance();
                                } else {
                                    if (count * intervalMs * 1000 > durationUs) {
                                        extractor.advance();
                                    } else {
                                        extractor.seekTo(count * intervalMs * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
                                        count++;
                                    }
//                                        extractor.advance();
                                }
                            } else {
                                // 读完了，给解码器设置结束标志
                                mediaCodec.queueInputBuffer(inputBufferIndex, 0, 0, 0L,
                                        MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                                inputFinish = true;
                                LogUtil.logTrack("解码输入数据完成 \n 当前线程是: " + Thread.currentThread().getName());
                                if (progressCallback != null) {
                                    progressCallback.onProgress(progressCallback.progress + 1 / 1000f);
                                }
                            }
                        }
                    }
                    if (!outputDone) {
                        //get data
                        // 获取已成功编解码的输出缓冲区的索引
                        // status就是当前解码的状态，可能正在解码中，可能解码完成了
                        int status = mediaCodec.dequeueOutputBuffer(bufferInfo, timeOutUs);
                        if (status ==
                                MediaCodec.INFO_TRY_AGAIN_LATER) {
                            //继续
                        } else if (status == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                            //开始进行解码
                        } else if (status == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                            //同样啥都不做
                        } else {
                            //在这里判断，当前编码器的状态
                            // bufferInfo.flags 标记关键帧或者结束帧
                            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                                LogUtil.logTrack("解码结束 output EOS");
                                outputDone = true;
                            }
                            boolean doRender = (bufferInfo.size != 0);
                            long presentationTimeUs = bufferInfo.presentationTimeUs;
                            if (lastPresentationTimeUs == 0) {
                                lastPresentationTimeUs = presentationTimeUs;
                            } else {
                                long diff = presentationTimeUs - lastPresentationTimeUs;
                                if (intervalMs != 0) {
                                    if (diff / 1000 < (intervalMs - 10)) {
                                        long lastDiff = durationUs - presentationTimeUs;
                                        LogUtil.logTrack("duration=" + durationUs + ", lastDiff=" + lastDiff);
                                        if (lastDiff < 50 * 1000 && diff > 0) {//离最后50ms的
                                            //输出最后一帧.强制输出最后一帧附近的帧的话，会比用metaRetiriever多一帧
                                            lastPresentationTimeUs = durationUs;
                                        } else {
                                            doRender = false;
                                        }
                                    } else {
                                        lastPresentationTimeUs = presentationTimeUs;
                                    }
                                    LogUtil.logTrack(
                                            "diff time in ms =" + diff / 1000);
                                }
                            }
                            //有数据了.因为会直接传递给Surface，所以说明都不做好了
                            if (progressCallback != null) {
                                progressCallback.onProgress(progressCallback.progress + 1 / 1000f);
                            }
                            // 释放输出缓冲区，给到客户端调用者，直接送显就可以了
                            mediaCodec.releaseOutputBuffer(status, doRender);
                            hasDecodeFrameFinish = true;
                            LogUtil.logTrack("解码一帧完成，等待消费获取");
                        }
                    }
                }

            } catch (Exception e) {
                String message = "解码过程出错，已停止解码 " + e.getMessage();
                decoderCallBack.onError(new Exception(message));
                LogUtil.logTrack(message);
                e.printStackTrace();
            }
        }

        public boolean isFinish() {
            return outputDone;
        }

        /**
         * 必须在最后一帧消费处理完之后调用，不然丢帧
         */
        public void release() {
            // 暂时不做处理时不做处理，如果还在处理数据的过程中，
            // 释放或关闭会导致回调丢失
            if (mediaCodec != null) {
                mediaCodec.stop();
                mediaCodec.release();
            }
            if (extractor != null) {
                extractor.release();
            }
        }
    }

    // 原始代码，保留，一次性解码所有帧，如果解码出来的帧的处理的位置的速度跟不上解码器，就会丢帧
 /*   private void processByExtractor(int scale, DecoderCallBack callBack) {
        try {
            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
            long timeOutUs = 5 * 1000; // 微秒，不是毫秒
            boolean inputDone = false;
            boolean outputDone = false;
            ByteBuffer[] inputBuffers = null;
            // if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            //     inputBuffers = mediaCodec.getInputBuffers();
            // }
            //开始进行解码。
            int count = 1;
            LogUtil.logTrack("开始解码 \n 当前线程是: " + Thread.currentThread().getName());
            if (progressCallback != null) {
                progressCallback.addSeg("正在解码...");
            }
            // 这个循环会不断的解码数据往输出位置送，比如imageReader的surface，
            // 但是要注意的一定是，如果surface那边没有消费处理掉的帧，就会被新的解码数据覆盖，也就是说这一帧就丢失了
            while (!outputDone) {
                if (requestStop) {
                    return;
                }
                if (!inputDone) {
                    //feed data
                    // 获取可用的输入缓冲区的索引
                    int inputBufferIndex = mediaCodec.dequeueInputBuffer(timeOutUs);
                    if (inputBufferIndex >= 0) {
                        ByteBuffer inputBuffer;
                        // if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                        // 获取输入缓冲区
                        inputBuffer = mediaCodec.getInputBuffer(inputBufferIndex);
                        // } else {
                        //     inputBuffer = inputBuffers[inputBufferIndex];
                        // }
                        // 填充数据
                        // simpleData the sample size (or -1 if no more samples are available).
                        // 读取数据的size，<=0表示读完了
                        int sampleData = extractor.readSampleData(inputBuffer, 0);
                        if (sampleData > 0) {
                            long sampleTime = extractor.getSampleTime();
                            LogUtil.logTrack(String.format(Locale.CHINA, "解码到的时间 = %.4fs",
                                    sampleTime / 1000000f));
                            // 将填满数据的inputBuffer提交到编码队列
                            mediaCodec.queueInputBuffer(inputBufferIndex, 0, sampleData, sampleTime, 0);
                            //继续
                            if (intervalMs == 0) {
                                extractor.advance();
                            } else {
                                if (count * intervalMs * 1000 > durationUs) {
                                    extractor.advance();
                                } else {
                                    extractor.seekTo(count * intervalMs * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
                                    count++;
                                }
//                                        extractor.advance();
                            }
                        } else {
                            // 读完了，给解码器设置结束标志
                            mediaCodec.queueInputBuffer(inputBufferIndex, 0, 0, 0L,
                                    MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                            inputDone = true;
                            LogUtil.logTrack("解码输入数据完成 \n 当前线程是: " + Thread.currentThread().getName());
                            if (progressCallback != null) {
                                progressCallback.onProgress(progressCallback.progress + 1 / 1000f);
                            }
                        }
                    }
                }
                if (!outputDone) {
                    //get data
                    // 获取已成功编解码的输出缓冲区的索引
                    // status就是当前解码的状态，可能正在解码中，可能解码完成了
                    int status = mediaCodec.dequeueOutputBuffer(bufferInfo, timeOutUs);
                    if (status ==
                            MediaCodec.INFO_TRY_AGAIN_LATER) {
                        //继续
                    } else if (status == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                        //开始进行解码
                    } else if (status == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                        //同样啥都不做
                    } else {
                        //在这里判断，当前编码器的状态
                        // bufferInfo.flags 标记关键帧或者结束帧
                        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                            LogUtil.logTrack("解码结束 output EOS");
                            outputDone = true;
                        }
                        boolean doRender = (bufferInfo.size != 0);
                        long presentationTimeUs = bufferInfo.presentationTimeUs;
                        if (lastPresentationTimeUs == 0) {
                            lastPresentationTimeUs = presentationTimeUs;
                        } else {
                            long diff = presentationTimeUs - lastPresentationTimeUs;
                            if (intervalMs != 0) {
                                if (diff / 1000 < (intervalMs - 10)) {
                                    long lastDiff = durationUs - presentationTimeUs;
                                    LogUtil.logTrack("duration=" + durationUs + ", lastDiff=" + lastDiff);
                                    if (lastDiff < 50 * 1000 && diff > 0) {//离最后50ms的
                                        //输出最后一帧.强制输出最后一帧附近的帧的话，会比用metaRetiriever多一帧
                                        lastPresentationTimeUs = durationUs;
                                    } else {
                                        doRender = false;
                                    }
                                } else {
                                    lastPresentationTimeUs = presentationTimeUs;
                                }
                                LogUtil.logTrack(
                                        "diff time in ms =" + diff / 1000);
                            }
                        }
                        //有数据了.因为会直接传递给Surface，所以说明都不做好了
                        if (progressCallback != null) {
                            progressCallback.onProgress(progressCallback.progress + 1 / 1000f);
                        }
                        // 释放输出缓冲区，给到客户端调用者，直接送显就可以了
                        mediaCodec.releaseOutputBuffer(status, doRender);
                    }
                }
            }
        } catch (Exception e) {
            String message = "解码过程出错，已停止解码 " + e.getMessage();
            if (decoderCallBack != null) {
                decoderCallBack.onError(new Exception(message));
            }
            LogUtil.logTrack(message);
            e.printStackTrace();
        } finally {
            // 暂时不做处理，如果还在处理数据的过程中，
            // 释放或关闭会导致回调丢失
            // if (mediaCodec != null) {
            //     mediaCodec.stop();
            //     mediaCodec.release();
            // }
            // if (extractor != null) {
            //     extractor.release();
            // }
        }
    }*/

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    private class MyOnImageAvailableListener implements ImageReader.OnImageAvailableListener {
        private int frameNumber = 0;

        @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
        @Override
        public void onImageAvailable(ImageReader reader) {
            // 中端机器测试得，720 * 1280大小的视频，不加上其它处理，3-4ms解码出一帧yuv
            // maxImages–用户希望同时访问的最大图像数。这应该尽可能小，以限制内存使用。一旦用户获得maxImages图像，必须先发布其中一个图像，然后才能通过acquireLatestImage（）或acquireNextImage（）访问新图像。必须大于0。
            frameNumber++;
            LogUtil.logTrack("");
            LogUtil.logTrack("---------------------------------------------------------------------------------");
            LogUtil.logTrack("收到视频帧解码第 " + frameNumber +
                    " 帧回调" + Thread.currentThread().getName());
            LogUtil.logTrack("---------------------------------------------------------------------------------");
            LogUtil.logTrack("");
            /*  测试不处理是获
              Image img = null;
                try {
                    img = reader.acquireLatestImage();
                } catch (Exception e) {
                    LogUtil.logTrack("测试获取视频帧的image出错");
                } finally {
                    if (img != null) {
                        img.close();
                    }
                }*/
            decoderCallBack.syncProcessFrame(reader, frameNumber, rotation);

            if (!frameDecoder.isFinish()) {
                handler.post(() -> frameDecoder.decodeOneFrame());
            } else {
                frameDecoder.release();
                decoderCallBack.onDecodeFinish();
            }
        }
    }

    @SuppressLint("PrivateApi")
    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    String getColorFormatName(int formatValue) {
        // TODO Auto-generated method stub
        //获取所有变量的值
        Class clazz = null;
        try {
            clazz = Class.forName("android.media.ScoreTable.CodecCapabilities");
            Field[] fields = clazz.getFields();

            for (Field field : fields) {
                if (field.getInt(clazz) == formatValue)
                    return field.getName();
            }
        } catch (ClassNotFoundException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return "error on get colorformat name";
    }

    private static class ImageReaderHandlerThread extends HandlerThread {

        private final Handler handler;

        public ImageReaderHandlerThread() {
            super("ImageReader");
            start();
            Looper looper = getLooper();
            handler = new Handler(looper);
        }

        public Handler getHandler() {
            return handler;
        }
    }

    private void _release() {
        LogUtil.logTrack("销毁解码器对象");
        requestStop = true;
        if (imageReader != null) {
            imageReader.close();
            imageReader = null;
        }

        if (mediaCodec != null) {
            mediaCodec.stop();
            mediaCodec.release();
            mediaCodec = null;
        }

        if (extractor != null) {
            extractor.release();
            extractor = null;
        }
    }

    public interface DecoderCallBack {

        /**
         * 注意！！！
         * 必须在调用线程完成处理，因为共享帧数据，需要一步一步走，
         * 如果切换线程顺序乱了会导致数据混乱
         * <p>
         * 也不能拷贝数据到其它线程，因为帧很多，数据量很大
         */
        void syncProcessFrame(ImageReader frame, int frameId, int rotation);

        void onFrameError(int frameId, Exception e);

        void onError(Exception e);

        void onInitVideoSuccess();

        void onDecodeFinish();
    }
}

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖