一、java层创建一个SuifaceView，获取其holder对象，定义一个native函数将该holder传递给jni层进行绘制。

    public class VideoView  extends SurfaceView {
        static{
            System.loadLibrary("avcodec-56");
            System.loadLibrary("avdevice-56");
            System.loadLibrary("avfilter-5");
            System.loadLibrary("avformat-56");
            System.loadLibrary("avutil-54");
            System.loadLibrary("postproc-53");
            System.loadLibrary("swresample-1");
            System.loadLibrary("swscale-3");
            System.loadLibrary("native-lib");
        }
        public VideoView(Context context) {
            super(context);
        }
    
        public VideoView(Context context, AttributeSet attrs) {
          super(context, attrs);
            init();
    
        }
    
        private void init() {
            //获取holder对象
            SurfaceHolder holder = getHolder();
            holder.setFormat(PixelFormat.RGBA_8888);//设置格式
        }
    
        public VideoView(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
        }
    
        public void player(final String input) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //将holder传递给底层进行绘制
                    render(input, VideoView.this.getHolder().getSurface());
                }
            }).start();
        }
    
        public native void render(String input, Surface surface);
    }

二、使用ffmpeg解码视频并使用native绘制在SurfaceView的holder对象上

    extern "C" {
    //编码
    #include "libavcodec/avcodec.h"
    //封装格式处理
    #include "libavformat/avformat.h"
    //像素处理
    #include "libswscale/swscale.h"
    //native_window_jni 在ndk 的libandroid.so库中，需要在CMakeLists.txt中引入android库
    #include <android/native_window_jni.h>
    #include <unistd.h>//sleep用的头文件
    }
    /**
        *将任意格式的视频在手机上进行播放，使用native进行绘制
        * env:虚拟机指针
        * inputStr：视频文件路径
        * surface: 从java层传递过来的SurfaceView的serface对象 
        */
    void ffmpegVideoPlayer(JNIEnv *env, char *inputStr, jobject surface) {
        // 1.注册各大组件，执行ffmgpe都必须调用此函数
        av_register_all();
        //2.得到一个ffmpeg的上下文（上下文里面封装了视频的比特率，分辨率等等信息...非常重要）
        AVFormatContext *pContext = avformat_alloc_context();
        //3.打开一个视频
        if (avformat_open_input(&pContext, inputStr, NULL, NULL) < 0) {
            LOGE("打开失败");
            return;
        }
        //4.获取视频信息（将视频信息封装到上下文中）
        if (avformat_find_stream_info(pContext, NULL) < 0) {
            LOGE("获取信息失败");
            return;
        }
        //5.用来记住视频流的索引
        int vedio_stream_idx = -1;
        //从上下文中寻找找到视频流
        for (int i = 0; i < pContext->nb_streams; ++i) {
            LOGE("循环  %d", i);
            //codec：每一个流 对应的解码上下文
            //codec_type：流的类型
            if (pContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
                //如果找到的流类型 == AVMEDIA_TYPE_VIDEO 即视频流，就将其索引保存下来
                vedio_stream_idx = i;
            }
        }
    
        //获取到解码器上下文
        AVCodecContext *pCodecCtx = pContext->streams[vedio_stream_idx]->codec;
        //获取解码器（加密视频就是在此处无法获取）
        AVCodec *pCodex = avcodec_find_decoder(pCodecCtx->codec_id);
        LOGE("获取视频编码 %p", pCodex);
    
        //6.打开解码器。 （ffempg版本升级名字叫做avcodec_open2）
        if (avcodec_open2(pCodecCtx, pCodex, NULL) < 0) {
            LOGE("解码失败");
            return;
        }
        //----------------------解码前准备--------------------------------------
        //准备开始解码时需要一个AVPacket存储数据（通过av_malloc分配内存）
        AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket));
        av_init_packet(packet);//初始化结构体
    
        //解封装需要AVFrame
        AVFrame *frame = av_frame_alloc();
        //声明一个rgb_Frame的缓冲区
        AVFrame *rgb_Frame = av_frame_alloc();
        //rgb_Frame  的缓冲区 初始化
        uint8_t *out_buffer = (uint8_t *) av_malloc(
                avpicture_get_size(AV_PIX_FMT_RGBA, pCodecCtx->width, pCodecCtx->height));
        //给缓冲区进行替换
        int re = avpicture_fill((AVPicture *) rgb_Frame, out_buffer, AV_PIX_FMT_RGBA, pCodecCtx->width,
                                pCodecCtx->height);
        LOGE("宽 %d  高 %d", pCodecCtx->width, pCodecCtx->height);
    
    
        //格式转码需要的转换上下文（根据封装格式的宽高和编码格式，以及需要得到的格式的宽高）
        //pCodecCtx->pix_fmt 封装格式文件的上下文
        //AV_PIX_FMT_RGBA ： 目标格式 需要跟SurfaceView设定的格式相同
        //SWS_BICUBIC ：清晰度稍微低一点的算法（转换算法，前面的算法清晰度高效率低，下面的算法清晰度低效率高） 
        //NULL,NULL,NULL ： 过滤器等
        SwsContext *swsContext = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
                                                pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGBA,
                                                SWS_BICUBIC, NULL, NULL, NULL
        );
        int frameCount = 0;
    
        //获取nativeWindow对象,准备进行绘制
        ANativeWindow *nativeWindow = ANativeWindow_fromSurface(env, surface);
        ANativeWindow_Buffer outBuffer;//申明一块缓冲区 用于绘制
    
        //------------------------一桢一帧开始解码--------------------
        int length = 0;
        int got_frame;
        while (av_read_frame(pContext, packet) >= 0) {//开始读每一帧的数据
            if (packet->stream_index == vedio_stream_idx) {//如果这是一个视频流
                //7.解封装（将packet解压给frame，即：拿到了视频数据frame）
                length = avcodec_decode_video2(pCodecCtx, frame, &got_frame, packet);//解封装函数
                LOGE(" 获得长度   %d 解码%d  ", length, frameCount++);
                if (got_frame > 0) {
    
                    //8.准备绘制
                    //配置绘制信息 宽高 格式(这个绘制的宽高直接决定了视频在屏幕上显示的情况，这样会平铺整个屏幕，可以根据特定的屏幕分辨率和视频宽高进行匹配)
                    ANativeWindow_setBuffersGeometry(nativeWindow, pCodecCtx->width, pCodecCtx->height,
                                                     WINDOW_FORMAT_RGBA_8888);
                    ANativeWindow_lock(nativeWindow, &outBuffer, NULL);//锁定画布(outBuffer中将会得到数据)
                    //9.转码（转码上下文，原数据，一行数据，开始位置，yuv的缓冲数组，yuv一行的数据）
                    sws_scale(swsContext, (const uint8_t *const *) frame->data, frame->linesize, 0,
                              frame->height, rgb_Frame->data,
                              rgb_Frame->linesize
                    );
                    //10.绘制
                    uint8_t *dst = (uint8_t *) outBuffer.bits; //实际的位数
                    int destStride = outBuffer.stride * 4; //拿到一行有多少个字节 RGBA
                    uint8_t *src = (uint8_t *) rgb_Frame->data[0];//像素数据的首地址
                    int srcStride = rgb_Frame->linesize[0]; //实际内存一行的数量
                    for (int i = 0; i < pCodecCtx->height; ++i) {
                        //将rgb_Frame缓冲区里面的数据一行一行copy到window的缓冲区里面
                        //copy到window缓冲区的时候进行一些偏移设置可以将视频播放居中
                        memcpy(dst + i * destStride, src + i * srcStride, srcStride);
                    }
    
                    ANativeWindow_unlockAndPost(nativeWindow);//解锁画布
                    usleep(1000 * 16);//可以根据帧率休眠16ms
    
                }
            }
            av_free_packet(packet);//释放
        }
        ANativeWindow_release(nativeWindow);//释放window
        av_frame_free(&frame);
        av_frame_free(&rgb_Frame);
        avcodec_close(pCodecCtx);
        avformat_free_context(pContext);
    
        free(inputStr);
    }