Camera + opengles录制视频，录制快速，慢速视频(三)

我不是女神ヾ 2023-07-18 11:22 13阅读 0赞

视频录制可以使用android提供的api，如MediaRecorder，对视频的编码也有MediaCodec这样的api可以使用。

MediaCodec的使用，用到两个缓存队列，一个输入缓存队列，一个是输出缓存队列，只需要使用queueInputBuffer把要编码的数据byte数组提交到输入队列，就可以使用enqueueOutputbuffer从输出队列取出编码完成的数据。这个用法有一个前提，就是要拿到待编码的byte数据。

但是，在使用opengl es将摄像头数据绘制到屏幕时，数据的处理是在着色器中处理的。没有办法从着色器中直接拿到byte数组，那怎么完成视频的录制呢？

MediaCodec中有一个方法：public native final Surface createInputSurface();

这个方法会请求一个surface作为待编码数据的输入，这个Surface必须是被硬件加速层渲染的，比如Opengl es。也就是说，如果我们往Surface中绘制数据，那么MediaCodec就可以从Surface中拿数据来完成编码。

那么opengl 怎么往Surface中绘制数据呢？

在Android中Surface就是一块画布，在WindowManagerService中对应了一个窗口WindowState，在SurfaceFlinger中对应了一个Layer，在Surface内部有一块存储数据的内存空间。这些都是Android中的概念，但是Opengl它不认识Surface是什么。

我们接下来要解决的问题就是让opengl认识Surface。

怎么认识呢？Surface除了是一块画布，还有一个概念，就是它是面向应用程序的本地窗口ANativeWindow，openggl要完成绘制，一定是要和本地窗口建立关联的，也即是opengl环境的搭建，完成这个工作的是egl。

EGL是图形渲染api和本地窗口系统之间的一层接口，提供如下功能：

1，创建rendering surface，让应用程序可以在上面作图。

2，创建graphics context，因为opengl是一个状态机，是一个pipeline，所以它需要状态管理，这就是context的工作。

3，同步应用程序和本地平台渲染api。

4，提供对显示设备的访问。

参考GLSurfaceView的源码，在GLSurfaceView的GLThread运行起来后，会借助EglHelper来初始了EGL环境，这个过程中创建了EGLSurface，实现了opengl绘制数据到EGLSurface中，因为EGLSurface和Surface做了绑定，最终实现数据绘制到了Surface中。

EGLSurface是可以跟Surface产生关联的，这就可以实现使用opengl绘制的数据，通过EGLSurface，传递到Surface，进一步传给MediaCodec，完成编码。

最终实现的结构图是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjIwMDQ0MTQwNDEw_size_16_color_FFFFFF_t_70][]

首先，摄像头的数据到了GLSurfaceView中，GLSurfaceView搭建了EGL环境，在EGL环境中创建了EGLSurface，并与GLSurfaceView中的Surface做了绑定，所以opengl绘制数据到EGLSurface，实际就绘制到了Surface中。

然后，MediaCodec中也有一个surface，我们去搭建一个EGL环境，在我们搭建的EGL环境中创建一个EGLSurface与MediaCodec中的surface绑定起来，让opengl把数据也绘制一份到这个EGL环境中的EGLSurface中，这样Mediacodec就可以拿到要编码的数据了。

下面就看代码实现：

视频录制需要动态开启Camera，Storage的权限。

MediaCodec的使用，配置编码器，创建编码器，得到编码器的inputSurface，开启编码。

然后把编码后的数据通过MediaMuxer封装到一个容器中。

在编码器启动后，就要开始不断的获取输入数据了，所以在启动编码器后，会创建EGL环境，把MediaCodec中的surface绑定到EGL的eglSurface上。

public void start(float speed) throws IOException {
            mSpeed = speed;
            MediaFormat format = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC,mWidth, mHeight);
            //颜色空间，从surface当中获取
            format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
            //码率
            format.setInteger(MediaFormat.KEY_BIT_RATE, 1500_000);
            //帧率
            format.setInteger(MediaFormat.KEY_FRAME_RATE, 24);
            //关键帧间隔
            format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 10);
            //创建编码器
            mMediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
            //配置编码器
            mMediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            //这个surface显示的内容就是要编码的画面数据。
            mSurface = mMediaCodec.createInputSurface();
    
            //混合器（复用器），将编码的h264封装为mp4，
            mMuxer = new MediaMuxer(mPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
            //开始编码
            mMediaCodec.start();
    
    
            //创建opengl的环境，
            HandlerThread gl_codec = new HandlerThread("gl_codec");
            gl_codec.start();
            mHandler = new Handler(gl_codec.getLooper());
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    eglEnv = new EGLEnv(mContext, mGlContext, mSurface, mWidth, mHeight);
                    isStart = true;
                }
            });
        }

然后看下EGL环境搭建的代码，在单独的类EGLEnv.java中完成：

EGL环境的搭建流程：

1，获得显示窗口，作为opengl的绘制目标，

2，初始化显示窗口

3，配置属性选项，

4，创建EGL上下文，

5，创建EGL surface，

6，选定当前的上下文,绑定当前线程的显示设备，

public EGLEnv(Context context, EGLContext mGlContext, Surface surface, int width, int height) {
            //获得显示窗口，作为opengl的绘制目标
            mEglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
            if (mEglDisplay == EGL14.EGL_NO_DISPLAY) {
                throw new RuntimeException("eglGetDisplay,failed.");
            }
    
            //初始化显示窗口
            int[] version = new int[2];
            if (!EGL14.eglInitialize(mEglDisplay, version, 0, version, 1)) {
                throw new RuntimeException("eglInitialize,failed.");
            }
    
            //配置属性选项，
            int[] configAttribs = {
                EGL14.EGL_RED_SIZE, 8, //颜色缓冲区中红色位数，
                    EGL14.EGL_GREEN_SIZE, 8,
                    EGL14.EGL_BLUE_SIZE, 8,
                    EGL14.EGL_ALPHA_SIZE, 8,
                    EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,// opengl es 2.0
                    EGL14.EGL_NONE
            };
            int[] numConfigs = new int[1];
            EGLConfig[] eglConfig = new EGLConfig[1];
            if (!EGL14.eglChooseConfig(mEglDisplay, configAttribs, 0,
                    eglConfig, 0, eglConfig.length,
                    numConfigs, 0)) {
                throw new RuntimeException("eglChooseConfig,failed."+EGL14.eglGetError());
            }
            mEglConfig = eglConfig[0];
    
            //创建EGL上下文，
            int[] contex_attrib_list = {
              EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
                    EGL14.EGL_NONE
            };
            //与GLSurfaceView中的EGLContext共享数据，只有这样才能拿到处理完之后显示的图像纹理，
            mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, mGlContext, contex_attrib_list,0);
            if (mEglContext == EGL14.EGL_NO_CONTEXT) {
                throw new RuntimeException("eglCreateContext,failed."+EGL14.eglGetError());
            }
    
            //创建EGL surface
            int[] surface_attrib_list = {
                    EGL14.EGL_NONE
            };
            mEglSurface = EGL14.eglCreateWindowSurface(mEglDisplay, mEglConfig, surface, surface_attrib_list, 0);
            if (mEglSurface == null) {
                throw new RuntimeException("eglCreateWindowSurface,failed."+EGL14.eglGetError());
            }
    
            //选定当前的上下文,绑定当前线程的显示设备，一个进程中可能创建多个context，
            // 必须选择其中一个作为当前的处理对象。这里选择的是跟GLSurfaceView共享context，
            if (!EGL14.eglMakeCurrent(mEglDisplay,mEglSurface, mEglSurface, mEglContext)) {
                throw new RuntimeException("eglMakeCurrent,failed."+EGL14.eglGetError());
            }
    
            recordFilter = new RecordFilter(context);
    
        }

这里面那么多概念是什么样的关系呢？在理下，EGLContext会管理绘制过程，EGLDisplay是一个跟具体系统无关的显示设备，其中包含着一个EGLSurface，在EGLSurface创建时，关联了一个本地窗口Surface，这个Surface决定了绘制的数据是显示到屏幕，还是作为MediaCodec的输入。

还有一点需要 注意：

//与GLSurfaceView中的EGLContext共享数据，只有这样才能拿到处理完之后显示的图像纹理，

mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, mGlContext, contex\_attrib\_list,0);

其中的参数mGlContext来自于EGL14.eglGetCurrentContext()，并且是在GLSurfaceView的render实现类中的onSurfaceCreated中赋值的。

原本GLSurfaceView中EGLSurface和我们自己创建的EGL环境中EGLSurface是没有关联的，但是我们用同一个EGLContext上下文，这就让他们之间产生了关联。也就实现了MediaCodec环境中需要的EGLSurface，能够使用到，共享到GLSurfaceView中纹理。

准备工作完成，下面开始绘制，录像。

在有一帧新的数据时，回调GLSurfaceView.Renderer的onDrawFrame

@Override
        public void onDrawFrame(GL10 gl) {
          //绘制与摄像头绑定的纹理,实际的绘制只是把参数传给着色器,
           int id =cameraFilter.onDraw(texture[0]);
          mRecorder.fireFrame(id, mCameraTexture.getTimestamp());        
    }

这里的纹理id，是代表绘制到屏幕上的纹理，我们要拿这个纹理id，用opengl绘制到mediacodec的EGLSurface上去。

在 int id =cameraFilter.onDraw(texture\[0\]);这之前，可能会有多个filter来处理数据，都会返回一个纹理id，录像这里需要的纹理id是最后一级需要绘制到屏幕上的纹理id，也就是包含了所有处理效果的数据，当然也可以中间部分的纹理id，比如说某些特效，只想预览，不想保存下来。

在MyMediaRecorder中，新启一个线程，处理绘制，编码：

public void fireFrame(final int textureId, final long timeStamp) {
            if (!isStart) {
                return;
            }
            //录制用的opengl已经和mHandler所在线程绑定，所以需要在这个线程中使用录制的opengl
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    //绘制
                    eglEnv.draw(textureId, timeStamp);
                    //编码
                    surfaceCodec(false);
                }
            });
        }

EGLEnv的绘制，

public void draw(int textureId, long timestamp) {
            recordFilter.onDraw(textureId, mFilterChain);
            //设置绘制时间
            EGLExt.eglPresentationTimeANDROID(mEglDisplay, mEglSurface, timestamp);
            //egl surface是双缓冲模式，绘制完成后，需要交换前后台buffer，才能将绘制数据显示到屏幕上。
            EGL14.eglSwapBuffers(mEglDisplay, mEglSurface);
        }

这里的RecordFilter的绘制流程，跟普通的opengl往屏幕绘制没有区别，直接使用了父类AbstractFilter的绘制操作；

public class RecordFilter extends AbstractFilter\{\}

看到这里，你可能会有疑问，既然跟opengl往屏幕绘制没有区别，那数据怎么绘制到mediacodec中的EGLSurface中的呢？

还记得在创建EGL环境时，最后一句调用

EGL14.eglMakeCurrent(mEglDisplay,mEglSurface, mEglSurface, mEglContext)

这句话的作用就是指定当前的上下文，设定opengl当前处理的显示器，当前处理的EGLSurface，这样数据就绘制到了指定的mEGLSurface中。

绘制完后，获取编码后的数据，封装成MP4文件，这块实现是MyMediaRecorder中代码：

private void surfaceCodec(boolean endOfStream) {
            //标记结束信号
            if (endOfStream) {
                mMediaCodec.signalEndOfInputStream();
            }
    
            while (true) {
                //从输出缓冲区中，获取编码后的数据,所以先获取到输出缓冲区。
                MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
                int encoderStatus = mMediaCodec.dequeueOutputBuffer(bufferInfo, 10_000);
                //还需要更多数据才能编码，需要在等一会
                if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
                    //如果还没结束录像，就退出循环，等待下次拿到更多Camera数据完成编码。
                    if (!endOfStream) {
                        break;
                    }
                } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                    //输出格式发生改变，开启混合器，第一次总会调用，
                    MediaFormat outputFormat = mMediaCodec.getOutputFormat();
                    track = mMuxer.addTrack(outputFormat);
                    mMuxer.start();
                } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                    //忽略，不处理
                } else {
                    //调整时间戳,实现快速，慢速录像，
                    bufferInfo.presentationTimeUs = (long)(bufferInfo.presentationTimeUs / mSpeed);
                    //bufferInfo.presentationTimeUs <= mLastTimeStamp可能会有异常。
                    if (bufferInfo.presentationTimeUs <= mLastTimeStamp) {
                        bufferInfo.presentationTimeUs = (long) (mLastTimeStamp + 1_000_000 / 24/ mSpeed);
                    }
                    mLastTimeStamp = bufferInfo.presentationTimeUs;
    
                    //获取输出缓冲区编码后的数据,正常情况下，encoderStatus表示缓冲区的下标
                    ByteBuffer encodedData = mMediaCodec.getOutputBuffer(encoderStatus);
                    //如果当前的buffer是配置信息，不用写进去。
                    if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) !=0) {
                        bufferInfo.size = 0;
                    }
    
                    if (bufferInfo.size !=0) {
                        //设置从哪里开始读数据（读出来就是编码后的数据）
                        encodedData.position(bufferInfo.offset);
                        //设置可读数据的总长度
                        encodedData.limit(bufferInfo.offset + bufferInfo.size);
                        //写到mp4文件中
                        mMuxer.writeSampleData(track, encodedData, bufferInfo);
                    }
    
                    //释放缓冲区，后续可以存放新的编码后的数据
                    mMediaCodec.releaseOutputBuffer(encoderStatus, false);
    
                    //如果给了结束信号，
                    if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                        break;
                    }
                }
            }
        }

实现快速，慢速录制代码：

//调整时间戳,实现快速，慢速录像，
                    bufferInfo.presentationTimeUs = (long)(bufferInfo.presentationTimeUs / mSpeed);
                    //bufferInfo.presentationTimeUs <= mLastTimeStamp可能会有异常。
                    if (bufferInfo.presentationTimeUs <= mLastTimeStamp) {
                        bufferInfo.presentationTimeUs = (long) (mLastTimeStamp + 1_000_000 / 24/ mSpeed);
                    }
                    mLastTimeStamp = bufferInfo.presentationTimeUs;

就是通过调整mSpeed参数，大于1时表示快速，小于1表示慢速。实际调整的就是每一帧图像pts值，也就是视频显示的时间戳，这个时间戳是递增的。所以快速，慢速视频，对文件大小是没有影响的，

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjIwMDQ0MTQwNDEw_size_16_color_FFFFFF_t_70]: /images/20230528/a1f59bc1aa15494ab9f37c40fd1aeb12.png