如果你有学Android 音视频，相机开发的想法，那么这篇文章可以作为一篇不错的参考文章。当然本文为付费文章，收费10元，如果对你有用，文末赞赏缴费即可。如果没有学习音视频，相机的欲望，赶快走，赶快走，不要有一丝停留，因为这篇文章确实枯燥无味且毫无快感可言。如果不知道我讲的是啥，先到Github项目：AndroidCamera去看下效果就知道了。

请考虑3s赶快决定去留。

3……

2……

1……

不走，我再扯两句：

这篇是在学习相机音视频开发的时候写的一篇总结。由于涉及的知识点比较多，所以其中部分知识点仅起引导作用。

ok,枯燥无味正式开始：

这篇文章计划写的内容覆盖面是很广泛的，涵盖相机开发的大部分知识，而且我对自己写作要求：内容尽量精炼，不能泛泛而谈。所以时间上来说很紧凑了。当然，如果文章各方面大家有看不顺眼的地方，希望大家帮忙指出批评，一定虚心接受，积极改正。如果今后有机会见面，请您喝茶。

- 1. 从打开一个摄像头说起
- 2. 使用OpenGl ES预览相机数据
  - 1. 使用OpenGl ES绘制相机数据必备的基本知识
- 3. 一起了解下使用MediaCodec实现相机录制
- 4. 了解下音频录制
  - 1. AudioRecord的工作流程
- 5. 了解下音视频混合
  - 1. 了解下MediaMuxer
  - 2. MediaMuxer的工作流程
- 6. 了解下多段视频拼接合成
  - 1. 讲下如何使用Android原生实现视频合成。
  - 2. 讲下如何使用mp4parser合成多个视频
- 7. 了解下如何获取视频帧？
  - 1. 如何拿出视频帧？
  - 2. 如何分解Gif图？
- 7. 了解下FFmpeg
  - 1. 了解下什么是FFmpeg
  - 2. 如何在Android下使用FFmpeg
    - 1. 视频加减速命令：
    - 2. 视频剪切命令：
    - 3. 视频压缩命令：
    - 4.给视频添加背景音乐
    - 5. 加字幕
    - 6. 加水印
    - 7. 旋转
- 8. 参考链接及项目
- 9. 结束语
- 10. 广告

1. 从打开一个摄像头说起

当然，这个对大部分人来说都是没什么问题的，但是该篇文章还得照顾大部分初次接触Camera开发的小伙伴，所以请容许我在此多啰嗦一下，如果你有接触过Camera的开发，此部分可以跳过，直接看下一部分。

a. 使用Camera的步骤：

说下Camera的操作步骤，后面给出实例，请结合代码理解分析:

获取一个Camera实例，通过open方法，Camera.open(0),0是后置摄像头，1表示前置摄像头。
设置Camera的参数，比如聚焦，是否开闪光灯，预览高宽，修改Camera的默认参数：mCamera.getParameters() 通过初始化SurfaceHolder去setPreviewDisplay(SurfaceHolder),没有surface,Camera不能开始预览。
调用startPreview方法开始更新预览到surface,在拍照之前，startPreview必须调用，预览必须开启。
当你想开始拍照时，使用takePicture(Camera.ShutterCallback, Camera.PictureCallback, Camera.PictureCallback, Camera.PictureCallback), 等待回调提供真实的图像数据当拍完一张照片时，预览（preview）将会停止，当你想要拍更多的照片时，须要再一次调用startPreview方法
当调用stopPreview方法时，将停止更新预览的surface
当调用release方法时，将马上释放camera

b.使用SurfaceView预览显示Camera数据

如果你初次开发相机，请按照上面的步骤观看下面代码，如果你已经知道了，请直接过滤掉此基础部分。如果想了解更多预览方式，你可以看我的另一篇文章通过SurfaceView，TextureView，GlSurfaceView显示相机预览。

public class CameraSurfaceViewShowActivity extends AppCompatActivity implements SurfaceHolder.Callback {
    @BindView(R.id.mSurface)
    SurfaceView mSurfaceView;

    public SurfaceHolder mHolder;
    private Camera mCamera;
    private Camera.Parameters mParameters;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_base_camera);
        ButterKnife.bind(this);
        mHolder = mSurfaceView.getHolder();
        mHolder.addCallback(this);
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        try {
            // Open the Camera in preview mode
            mCamera = Camera.open(0);
            mCamera.setDisplayOrientation(90);
            mCamera.setPreviewDisplay(holder);
            mCamera.startPreview();
        } catch (IOException e) {
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        mCamera.autoFocus(new Camera.AutoFocusCallback() {
            @Override
            public void onAutoFocus(boolean success, Camera camera) {
                if (success) {
                    mParameters = mCamera.getParameters();
                    mParameters.setPictureFormat(PixelFormat.JPEG); //图片输出格式
//                    mParameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);//预览持续发光
                    mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);//持续对焦模式
                    mCamera.setParameters(mParameters);
                    mCamera.startPreview();
                    mCamera.cancelAutoFocus();
                }
            }
        });
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        if (mCamera != null) {
            mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
        }
    }

    @OnClick(R.id.btn_change)
    public void onViewClicked() {
//        PropertyValuesHolder valuesHolder2 = PropertyValuesHolder.ofFloat("rotationX", 0.0f, 360.0f, 0.0F);
        PropertyValuesHolder valuesHolder = PropertyValuesHolder.ofFloat("rotationY", 0.0f, 360.0f, 0.0F);
        PropertyValuesHolder valuesHolder1 = PropertyValuesHolder.ofFloat("scaleX", 1.0f, 0.5f,1.0f);
        PropertyValuesHolder valuesHolder3 = PropertyValuesHolder.ofFloat("scaleY", 1.0f, 0.5f,1.0f);
        ObjectAnimator objectAnimator = ObjectAnimator.ofPropertyValuesHolder(mSurfaceView,  valuesHolder,valuesHolder1,valuesHolder3);
        objectAnimator.setDuration(5000).start();
    }
}

c. 效果展示

当然，为了使效果好看一点点，我添加了一丢丢效果，效果如下：

这里写图片描述

好了，到这里为止，我们的简单Camera预览结束。

2. 使用OpenGl ES预览相机数据

OpenGL ES (OpenGL for Embedded Systems) 是OpenGl的子集，针对手机、PDA和游戏主机等嵌入式设备而设计。（我不会偷偷告诉你我是百度滴）

关于OpenGl ES如何绘制一个简单基本图形，下面会做一个简单的讲解，如果你想对OpenGL ES有更深层次的了解，可以看下我写的关于一篇OpenGL绘制简单三角形的文章Android openGl开发详解(一)——简单图形的基本绘制，

1. 使用OpenGl ES绘制相机数据必备的基本知识

1. 关于OpenGl ES渲染流程了解下：

首先我们必须明确我们要做的是将相机数据显示到设备屏幕上，所有的操作都是为此目的服务的。所以我们必须要了解OpenGl ES是如何进行渲染的。(如果下面提到的术语你没有概念，或者模棱两可，请看再看一遍Android openGl开发详解(一)——简单图形的基本绘制) 下面是基本步骤：

布局文件中添加GlSurfaceView,并为其指定渲染器Renderer。
设置画布大小，清除画布内容，创建纹理对象，并指定OpenGl ES操作纹理ID。(下面会讲到)
加载顶点着色器(vertex shader)和片元着色器(fragment shader)。
创建OpenGl ES程序，创建program对象，连接顶点和片元着色器，链接program对象。
打开相机，设置预览布局，开启预览，并通过glUseProgram()方法将程序添加到OpenGl ES环境中，获取着色器句柄，通过glVertexAttribPointer()传入绘制数据并启用顶点位置句柄。
在onDrawFrame方法中更新缓冲区帧数据并通过glDrawArrays绘制到GlSurfaceView上。
操作完成后资源释放，需要注意的是使用GlsurfaceView的时候需要注意onResume()和onPause()的调用。

上面步骤基本可以将Camera的预览数据通过OpenGl ES的方式显示到了GlSurfaceView上。当然，我们先来看下效果图，再给出源码部分。让大家看一下效果(因为时间原因，请原谅我拿了之前的图)

这里写图片描述

这部分源码会在项目中给出，同时在通过SurfaceView，TextureView，GlSurfaceView显示相机预览也有给出，所以，在这里就不贴源码了。

2. 了解下EGL

What?EGL？什么东西？可能很多初学的还不是特别了解EGL是什么？如果你使用过OpenGL ES进行渲染，不知道你有没有想过谁为OpenGl ES提供渲染界面？换个方式问？你们知道OpenGL ES渲染的数据到底去哪了么？(请原谅我问得这么生硬) 当然，到GLSurfaceView,GlSurfaceView为其提供了渲染界面，这还用说!

这里写图片描述

其实OpenGL ES的渲染是在独立线程中，他是通过EGL接口来实现和硬件设备的连接。EGL为OpenGl EG 提供上下文及窗口管理，注意：OpenGl ES所有的命令必须在上下文中进行。所以EGL是OpenGL ES开发必不可少需要了解的知识。但是为什么我们上面的开发中都没有用到EGL呢？这里说明下：因为在Android开发环境中，GlSurfaceView中已经帮我们配置好了EGL了。当然，EGL的作用及流程图从官方偷来给大家看一波：

这里写图片描述

关于EGL的知识内容很多，不想增加本文篇幅，重新写一篇博客专门介绍EGL，有兴趣点这里Android 自定义相机开发（三) —— 了解下EGL。

3. 了解下OpenGl ES中的纹理

OpenGl 中的纹理可以用来表示图像，照片，视频画面等数据，在视频渲染中，我们只需要处理二维的纹理，每个二维的纹理都由许多小的纹理元素组成，我们可以将其看成小块的数据。我们可以简单将纹理理解成电视墙瓷砖，我们要做一面电视墙，需要由多个小瓷砖磡成，最终成型的才是完美的电视墙。我暂时是这么理解滴。使用纹理，最直接的方式是直接从给一个图像文件加载数据。这里我们得稍微注意下，OpenGl的二维纹理坐标和我们的手机屏幕坐标还是有一定的区别。这里写图片描述

OpenGl的纹理坐标的原点是在左下角，而计算机的纹理坐标在左上角。尤其是我们在添加贴纸的时候需要注意下y值的转换。这里顺便说下OpenGl ES绘制相机数据的时候纹理坐标的变换问题，下次如果使用OpenGl 处理相机数据遇到镜像或者上下颠倒可以对照下图片上所说的规则：这里写图片描述

下面我们来讲解下OpenGl纹理使用的步骤：

首先我们需要创建一个纹理对象，通过glGenTextures()方法获取到纹理对象ID，接下来我们就可以操作纹理了对象，但是我们需要告诉OpenGl 我们操作的是哪个纹理，所以我们需要通过glBindTexture()告诉OpenGl操作纹理的ID,当纹理绑定之后，我们还需要为这个纹理对象设置一些参数（纹理的过滤方式），当我们需要将纹理对象渲染到物体表面时，我们需要通过纹理对象的纹理过滤器通过glTexParameterf()方法来指明,最后当我们操作当前纹理完成之后，我们可以通过调用一次GLES20.glBindTexture(GLES20.GL_TEXTURE_2D,0)对纹理进行解绑。

private int createTextureID() {
          int[] tex = new int[1];
        //第一个参数表示创建几个纹理对象，并将创建好的纹理对象放置到第二个参数中去，第二个参数里面存放的是纹理ID(纹理索引)，第三个偏移值，通常填0即可。
        GLES20.glGenTextures(1, tex, 0);
        //纹理绑定
        GLES20.glBindTexture(GL_TEXTURE_2D, tex[0]);
        //设置缩小过滤方式为GL_LINEAR（双线性过滤，目前最主要的过滤方式)，当然还有GL_NEAREST(容易出现锯齿效果)和MIP贴图(占用更多内存)
        GLES20.glTexParameterf(GL_TEXTURE_2D,
                GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
        //设置放大过滤为GL_LINEAR，同上
        GLES20.glTexParameterf(GL_TEXTURE_2D,
                GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
        //设置纹理的S方向范围，控制纹理贴纸的范围在（0,1）之内，大于1的设置为1，小于0的设置为0。
        GLES20.glTexParameterf(GL_TEXTURE_2D,
                GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
        //设置纹理的T方向范围，同上
        GLES20.glTexParameterf(GL_TEXTURE_2D,
                GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
        //解除纹理绑定
        GLES20.glBindTexture(GL_TEXTURE_2D, 0);
        return tex[0];
    }

这里我们稍微提一下，如果是相机数据处理，我们使用GLES11Ext.GL_TEXTURE_EXTERNAL_OES，如果是处理贴纸图片，我们使用GLES20.GL_TEXTURE_2D。因为相机输出的数据类型是YUV420P格式的，使用GLES11Ext.GL_TEXTURE_EXTERNAL_OES扩展纹理可以实现自动将YUV420P转RGB，我们就不需要在存储成MP4的时候再进行数据转换了。

如果我们要给当前纹理添加PNG素材，我们需要对PNG这种图片压缩格式进行解码操作。最终传递RGBA数据格式数据到OpenGl 中纹理中，当然，OpenGL还提供了三个指定函数来指定纹理glTexImage1D(), glTexImage2D(), glTexImage3D().。我们运用到的主要2D版本，glTexImage2D();

void glTexImage2D( int target,
        int level,
        int internalformat,
        int width,
        int height,
        int border,
        int format,
        int type,
        java.nio.Buffer pixels);

简单参数说明： target：常数GL_TEXTURE_2D。 level：表示多级分辨率的纹理图像的级数，若只有一种分辨率，则level设为0。 internalformat：表示用哪些颜色用于调整和混合，通常用GLES20.GL_RGBA。 border:字面意思理解应该是边界，边框的意思，通常写0. width/height:纹理的宽/高。 format/type :一个是纹理映射格式（通常填写GLES20.GL_RGBA），一个是数据类型（通常填写GLES20.GL_UNSIGNED_BYTE）。 pixels:纹理图像数据。

当然，Android中最常用是使用方式是直接通过texImage2D()方法可以直接将Bitmap数据作为参数传入,方法如下：

 GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, mBitmap, 0);

接来下就如上面OpenGl ES渲染流程所提到的，将纹理绘制到屏幕上。

3. 一起了解下使用MediaCodec实现相机录制

上面我们将相机的预览显示讲完了，接下里我们讲如何将录制视频。就目前来说，Android的录制方式就要有下面三中：

使用MediaRecord进行录制。（这个不讲解）
使用MediaCodec进行录制(我们讲这种) 。
使用FFMpeg+x264/openh264。(软编码的方式，后面出专门的文章讲解到这部分)。

1. 什么是MediaCodec?

MediaCodec官方文档地址 MediaCodec是一个多媒体编解码处理类，可用于访问Android底层的多媒体编解码器。例如，编码器/解码器组件。它是Android底层多媒体支持基础架构的一部分（通常与MediaExtractor, MediaSync, MediaMuxer, MediaCrypto, MediaDrm, Image, Surface, 以及AudioTrack一起使用）。请原谅我后面那一段是从官网搬过来的,知道它是用来处理音视频的That's enough.

2. MediaCodec的操作原理？

MediaCodec到底是如何将数据进行处理生成.mp4文件的呢？我们先看下图（在官方图片上进行了部分改动和标记）：这里写图片描述既然上面我们提到MediaCodec是一个编码器处理类，从图上看我们可以知道，他就是2的输入的数据进行处理，然后输出到3中去保存。每个编码器都包含一组输入和输出缓存，中间的两条从Codec出发又返回Codec的虚线就代表两组缓存。当编码器启动后，两组缓存便存在。由编码器发送空缓存给输入区（提供数据区），输入区将输入缓存填充满，再返回给编码器进行编码，编码完成之后将数据进行输出，输出之后将缓冲区返回给编码器。

如果你是个吃货你可以这样理解：Codec是榨汁机，在榨汁之前准备两个杯子。一个杯子（输入缓存）用来装苹果一直往榨汁机里面倒，倒完了继续回去装苹果。另一个杯子(输出缓存)用来装榨出来的苹果汁，无论你将果汁放到哪里去（放一个大瓶子里面或者喝掉），杯子空了你就还回来继续接果汁，知道将榨汁机里面的果汁接完为止。

对，就这么简单，八九不离十的样子，反正我也不知道我说得对不对？

这里写图片描述

4. MediaCodec的使用步骤：

创建MediaFormat，并设置相关属性，MediaFormat.KEY_COLOR_FORMAT(颜色格式)，KEY_BIT_RATE(比特率)，KEY_FRAME_RATE(帧速)，KEY_I_FRAME_INTERVAL(关键帧间隔，0表示要求所有的都是关键帧，负值表示除第一帧外无关键帧)。

温馨提示

：没有设置以上前三个属性你可以能会出现以下错误：

 Process: com.aserbao.androidcustomcamera, PID: 18501
                  android.media.MediaCodec$CodecException: Error 0x80001001
                      at android.media.MediaCodec.native_configure(Native Method)
                      at android.media.MediaCodec.configure(MediaCodec.java:1909)
                      ……

创建一个MediaCodec的编码器，并配置格式。
创建一个MediaMuxer来合成视频。
通过dequeueInput/OutputBuffer()获取输入输出缓冲区。
通过getInputBuffers获取输入队列，然后通过queueInputBuffer把原始YUV数据送入编码器。
通过dequeueOutputBuffer方法获取当前编解码状态，根据不同的状态进行处理。
再然后在输出队列端同样通过dequeueOutputBuffer获取输出的h264流。
处理完输出数据之后，需要通过releaseOutputBuffer把输出buffer还给系统，重新放到输出队列中。
使用MediaMuxer混合。

温馨提示：下面实例是通过直接在mediacodec的输入surface上进行绘制，所以不会有上述输入队列的操作。关于MediaCodec的很多细节，官方已经讲得很详细了，这里不过多阐述。

官方地址：MediaCodec MediaCodec中文文档 MediaCodec同步缓存处理方式（来自官方实例，还有异步缓存处理及同步数组的处理方式这里不做多讲解，如果有兴趣到官方查看），配合上面的步骤看会理解更多，如果还是不明白建议查看下面实例之后再回头来看步骤和实例：

MediaCodec codec = MediaCodec.createByCodecName(name);
 codec.configure(format, …);
 MediaFormat outputFormat = codec.getOutputFormat(); // option B
 codec.start();
 for (;;) {
   int inputBufferId = codec.dequeueInputBuffer(timeoutUs);
   if (inputBufferId >= 0) {
     ByteBuffer inputBuffer = codec.getInputBuffer(…);
     // fill inputBuffer with valid data
     …
     codec.queueInputBuffer(inputBufferId, …);
   }
   int outputBufferId = codec.dequeueOutputBuffer(…);
   if (outputBufferId >= 0) {
     ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferId);
     MediaFormat bufferFormat = codec.getOutputFormat(outputBufferId); // option A
     // bufferFormat is identical to outputFormat
     // outputBuffer is ready to be processed or rendered.
     …
     codec.releaseOutputBuffer(outputBufferId, …);
   } else if (outputBufferId == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
     // Subsequent data will conform to new format.
     // Can ignore if using getOutputFormat(outputBufferId)
     outputFormat = codec.getOutputFormat(); // option B
   }
 }
 codec.stop();
 codec.release();

5. 讲个实例，使用MediaCodec录制一段绘制到Surface上的数据

如果你之前没有使用过MediaCodec录制过视频，这个实例建议你看一下，如果你非常了解了，请跳过。效果图如下：

这里写图片描述

难得给下代码，当然，项目中会有更多关于MediaCodec的实例，最后会给出：

public class PrimaryMediaCodecActivity extends BaseActivity {
    private static final String TAG = "PrimaryMediaCodecActivi";
    private static final String MIME_TYPE = "video/avc";
    private static final int WIDTH = 1280;
    private static final int HEIGHT = 720;
    private static final int BIT_RATE = 4000000;
    private static final int FRAMES_PER_SECOND = 4;
    private static final int IFRAME_INTERVAL = 5;

    private static final int NUM_FRAMES = 4 * 100;
    private static final int START_RECORDING = 0;
    private static final int STOP_RECORDING = 1;

    @BindView(R.id.btn_recording)
    Button mBtnRecording;
    @BindView(R.id.btn_watch)
    Button mBtnWatch;
    @BindView(R.id.primary_mc_tv)
    TextView mPrimaryMcTv;
    public MediaCodec.BufferInfo mBufferInfo;
    public MediaCodec mEncoder;
    @BindView(R.id.primary_vv)
    VideoView mPrimaryVv;
    private Surface mInputSurface;
    public MediaMuxer mMuxer;
    private boolean mMuxerStarted;
    private int mTrackIndex;
    private long mFakePts;
    private boolean isRecording;

    private int cuurFrame = 0;

    private MyHanlder mMyHanlder = new MyHanlder(this);
    public File mOutputFile;

    @OnClick({R.id.btn_recording, R.id.btn_watch})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            case R.id.btn_recording:
                if (mBtnRecording.getText().equals("开始录制")) {
                    try {
                        mOutputFile = new File(Environment.getExternalStorageDirectory().getAbsolutePath(), System.currentTimeMillis() + ".mp4");
                        startRecording(mOutputFile);
                        mPrimaryMcTv.setText("文件保存路径为：" + mOutputFile.toString());
                        mBtnRecording.setText("停止录制");
                        isRecording = true;
                    } catch (IOException e) {
                        e.printStackTrace();
                        mBtnRecording.setText("出现异常了，请查明原因");
                    }
                } else if (mBtnRecording.getText().equals("停止录制")) {
                    mBtnRecording.setText("开始录制");
                    stopRecording();
                }
                break;
            case R.id.btn_watch:
                String absolutePath = mOutputFile.getAbsolutePath();
                if (!TextUtils.isEmpty(absolutePath)) {
                    if(mBtnWatch.getText().equals("查看视频")) {
                        mBtnWatch.setText("删除视频");
                        mPrimaryVv.setVideoPath(absolutePath);
                        mPrimaryVv.start();
                    }else if(mBtnWatch.getText().equals("删除视频")){
                        if (mOutputFile.exists()){
                            mOutputFile.delete();
                            mBtnWatch.setText("查看视频");
                        }
                    }
                }else{
                    Toast.makeText(this, "请先录制", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }

    private static class MyHanlder extends Handler {
        private WeakReference<PrimaryMediaCodecActivity> mPrimaryMediaCodecActivityWeakReference;

        public MyHanlder(PrimaryMediaCodecActivity activity) {
            mPrimaryMediaCodecActivityWeakReference = new WeakReference<PrimaryMediaCodecActivity>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            PrimaryMediaCodecActivity activity = mPrimaryMediaCodecActivityWeakReference.get();
            if (activity != null) {
                switch (msg.what) {
                    case START_RECORDING:
                        activity.drainEncoder(false);
                        activity.generateFrame(activity.cuurFrame);
                        Log.e(TAG, "handleMessage: " + activity.cuurFrame);
                        if (activity.cuurFrame < NUM_FRAMES) {
                            this.sendEmptyMessage(START_RECORDING);
                        } else {
                            activity.drainEncoder(true);
                            activity.mBtnRecording.setText("开始录制");
                            activity.releaseEncoder();
                        }
                        activity.cuurFrame++;
                        break;
                    case STOP_RECORDING:
                        Log.e(TAG, "handleMessage: STOP_RECORDING");
                        activity.drainEncoder(true);
                        activity.mBtnRecording.setText("开始录制");
                        activity.releaseEncoder();
                        break;
                }
            }
        }
    }

    @Override
    protected int setLayoutId() {
        return R.layout.activity_primary_media_codec;
    }


    private void startRecording(File outputFile) throws IOException {
        cuurFrame = 0;
        prepareEncoder(outputFile);
        mMyHanlder.sendEmptyMessage(START_RECORDING);
    }

    private void stopRecording() {
        mMyHanlder.removeMessages(START_RECORDING);
        mMyHanlder.sendEmptyMessage(STOP_RECORDING);
    }

    /**
     * 准备视频编码器，muxer，和一个输入表面。
     */
    private void prepareEncoder(File outputFile) throws IOException {
        mBufferInfo = new MediaCodec.BufferInfo();
        MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, WIDTH, HEIGHT);

        //1. 设置一些属性。没有指定其中的一些可能会导致MediaCodec.configure()调用抛出一个无用的异常。
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
                MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        format.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);//比特率(比特率越高，音视频质量越高，编码文件越大)
        format.setInteger(MediaFormat.KEY_FRAME_RATE, FRAMES_PER_SECOND);//设置帧速
        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);//设置关键帧间隔时间

        //2.创建一个MediaCodec编码器，并配置格式。获取一个我们可以用于输入的表面，并将其封装到处理EGL工作的类中。
        mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);
        mEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        mInputSurface = mEncoder.createInputSurface();
        mEncoder.start();
        //3. 创建一个MediaMuxer。我们不能在这里添加视频跟踪和开始合成，因为我们的MediaFormat里面没有缓冲数据。
        // 只有在编码器开始处理数据后才能从编码器获得这些数据。我们实际上对多路复用音频没有兴趣。我们只是想要
        // 将从MediaCodec获得的原始H.264基本流转换为.mp4文件。
        mMuxer = new MediaMuxer(outputFile.toString(), MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);

        mMuxerStarted = false;
        mTrackIndex = -1;
    }

    private void drainEncoder(boolean endOfStream) {
        final int TIMEOUT_USEC = 10000;
        if (endOfStream) {
            mEncoder.signalEndOfInputStream();//在输入信号end-of-stream。相当于提交一个空缓冲区。视频编码完结
        }
        ByteBuffer[] encoderOutputBuffers = mEncoder.getOutputBuffers();
        while (true) {
            int encoderStatus = mEncoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_USEC);
            if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {//没有可以输出的数据使用时
                if (!endOfStream) {
                    break;      // out of while
                }
            } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                //输出缓冲区已经更改，客户端必须引用新的
                encoderOutputBuffers = mEncoder.getOutputBuffers();
            } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                //输出格式发生了变化，后续数据将使用新的数据格式。
                if (mMuxerStarted) {
                    throw new RuntimeException("format changed twice");
                }
                MediaFormat newFormat = mEncoder.getOutputFormat();
                mTrackIndex = mMuxer.addTrack(newFormat);
                mMuxer.start();
                mMuxerStarted = true;
            } else if (encoderStatus < 0) {
            } else {
                ByteBuffer encodedData = encoderOutputBuffers[encoderStatus];
                if (encodedData == null) {
                    throw new RuntimeException("encoderOutputBuffer " + encoderStatus +
                            " was null");
                }
                if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                    //当我们得到的时候，编解码器的配置数据被拉出来，并给了muxer。这时候可以忽略。不做处理
                    mBufferInfo.size = 0;
                }
                if (mBufferInfo.size != 0) {
                    if (!mMuxerStarted) {
                        throw new RuntimeException("muxer hasn't started");
                    }
                    //调整ByteBuffer值以匹配BufferInfo。
                    encodedData.position(mBufferInfo.offset);
                    encodedData.limit(mBufferInfo.offset + mBufferInfo.size);
                    mBufferInfo.presentationTimeUs = mFakePts;
                    mFakePts += 1000000L / FRAMES_PER_SECOND;

                    mMuxer.writeSampleData(mTrackIndex, encodedData, mBufferInfo);
                }
                mEncoder.releaseOutputBuffer(encoderStatus, false);
                if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                    if (!endOfStream) {
                        Log.e(TAG, "意外结束");
                    } else {
                        Log.e(TAG, "正常结束");
                    }
                    isRecording = false;
                    break;
                }
            }
        }
    }

    private void generateFrame(int frameNum) {
        Canvas canvas = mInputSurface.lockCanvas(null);
        try {
            int width = canvas.getWidth();
            int height = canvas.getHeight();
            float sliceWidth = width / 8;
            Paint paint = new Paint();
            for (int i = 0; i < 8; i++) {
                int color = 0xff000000;
                if ((i & 0x01) != 0) {
                    color |= 0x00ff0000;
                }
                if ((i & 0x02) != 0) {
                    color |= 0x0000ff00;
                }
                if ((i & 0x04) != 0) {
                    color |= 0x000000ff;
                }
                paint.setColor(color);
                canvas.drawRect(sliceWidth * i, 0, sliceWidth * (i + 1), height, paint);
            }

            paint.setColor(0x80808080);
            float sliceHeight = height / 8;
            int frameMod = frameNum % 8;
            canvas.drawRect(0, sliceHeight * frameMod, width, sliceHeight * (frameMod + 1), paint);
            paint.setTextSize(50);
            paint.setColor(0xffffffff);

            for (int i = 0; i < 8; i++) {
                if(i % 2 == 0){
                    canvas.drawText("aserbao", i * sliceWidth, sliceHeight * (frameMod + 1), paint);
                }else{
                    canvas.drawText("aserbao", i * sliceWidth, sliceHeight * frameMod, paint);
                }
            }
        } finally {
            mInputSurface.unlockCanvasAndPost(canvas);
        }
    }

    private void releaseEncoder() {
        if (mEncoder != null) {
            mEncoder.stop();
            mEncoder.release();
            mEncoder = null;
        }
        if (mInputSurface != null) {
            mInputSurface.release();
            mInputSurface = null;
        }
        if (mMuxer != null) {
            mMuxer.stop();
            mMuxer.release();
            mMuxer = null;
        }
    }
}

4. 了解下音频录制

Android下的音频录制主要分两种：

AudioRecord(基于字节流录音) （我们主要讲这个）。
MediaRecorder(基于文件录音) ：

虽然我们这里只讲第一种，在这里还是讲下优缺点：

使用AudioRecord录音优点：可以对语音进行实时处理，比如变音，降噪，增益……，灵活性比较大。缺点：就是输出的格式是PCM，你录制出来不能用播放器播放，需要用到AudioTrack来处理。
使用 MediaRecorder：优点：高度封装，操作简单，支持编码，压缩，少量的音频格式文件，灵活性差。缺点：没法对音频进行实时处理。

1. AudioRecord的工作流程

创建AudioRecord实例，配置参数，初始化内部的音频缓冲区。

  /**
  *@param audioSource 音频采集的输入源,常用的值包括：DEFAULT（默认），VOICE_RECOGNITION（用于语音识别，等同于DEFAULT），MIC（由手机麦克风输入）等等，通常我们使用MIC
  *@param sampleRateInHz 采样率，注意，目前44100Hz是唯一可以保证兼容所有Android手机的采样率。
  *@param channelConfig 这个参数是用来配置“数据位宽”的，可选的值也是以常量的形式定义在 AudioFormat 类中，常用的是 ENCODING_PCM_16BIT（16bit），ENCODING_PCM_8BIT（8bit），注意，16BIT是可以保证兼容所有Android手机的。
  *@param bufferSizeInBytes 它配置的是 AudioRecord 内部的音频缓冲区的大小，该缓冲区的值不能低于一帧“音频帧”（Frame）的大小，一帧音频帧的大小计算如下：int size = 采样率 x 位宽 x 采样时间（取值2.5ms ~ 120ms） x 通道数.
  */
  
 public AudioRecord(int audioSource, int sampleRateInHz, int channelConfig, int audioFormat,
            int bufferSizeInBytes)

上面提到的采样时间这里说一下，每个手机厂商设置的可能都不一样，我们设置的采样时间越短，声音的延时就越小。我们可以通过getMinBufferSize()方法来确定我们需要输入的bufferSizeInBytes值，官方说明是说小于getMinBufferSize()的值就会初始化失败。

开始采集音频。这个比较简单：

AudioRecord.startRecording();//开始采集
AudioRecord.stop();//停止采集
……
AudioRecord.read(byte[] audioData, int offsetInBytes, int sizeInBytes);//读取数据

开启线程，将数据保存为pcm文件。
停止采集，资源释放。

关于AudioRecord录制的音频的例子就不在这里贴出来了，之后项目中会接入录音变音，降噪，增益等功能。都会在代码中给出。

5. 了解下音视频混合

前面讲到了视频和音频的录制，那么如何将他们混合呢？同样就我所知目前有两种方法：

使用MediaMuxer进行混合。(我们将下这种，也是市面上最常用的)。
使用FFmpeg进行混合。(目前不讲，后面添加背景音乐会提到)

1. 了解下MediaMuxer

MediaMuxer官方文档地址 MediaMuxer最多仅支持一个视频track,一个音频的track.如果你想做混音怎么办？用ffmpeg进行混合吧。(目前还在研究FFMPEG这一块，欢迎大家一块来讨论。哈哈哈……)，目前MediaMuxer支持MP4、Webm和3GP文件作为输出。视频编码的主要格式用H.264(AVC)，音频用AAC编码（关于音频你用其他的在IOS端压根就识别不出来，我就踩过这个坑！）。

2. MediaMuxer的工作流程

创建MediaMuxer对象。
添加媒体通道，并将MediaFormat添加到MediaMuxer中去。
通过start()开始混合。
writeSampleData()方法向mp4文件中写入数据。
stop()混合关闭并进行资源释放。

官方实例：

MediaMuxer muxer = new MediaMuxer("temp.mp4", OutputFormat.MUXER_OUTPUT_MPEG_4);
 // More often, the MediaFormat will be retrieved from MediaCodec.getOutputFormat()
 // or MediaExtractor.getTrackFormat().
 MediaFormat audioFormat = new MediaFormat(...);
 MediaFormat videoFormat = new MediaFormat(...);
 int audioTrackIndex = muxer.addTrack(audioFormat);
 int videoTrackIndex = muxer.addTrack(videoFormat);
 ByteBuffer inputBuffer = ByteBuffer.allocate(bufferSize);
 boolean finished = false;
 BufferInfo bufferInfo = new BufferInfo();

 muxer.start();
 while(!finished) {
   // getInputBuffer() will fill the inputBuffer with one frame of encoded
   // sample from either MediaCodec or MediaExtractor, set isAudioSample to
   // true when the sample is audio data, set up all the fields of bufferInfo,
   // and return true if there are no more samples.
   finished = getInputBuffer(inputBuffer, isAudioSample, bufferInfo);
   if (!finished) {
     int currentTrackIndex = isAudioSample ? audioTrackIndex : videoTrackIndex;
     muxer.writeSampleData(currentTrackIndex, inputBuffer, bufferInfo);
   }
 };
 muxer.stop();
 muxer.release();

好了，综上所述知识，已经实现了从预览到录制完成的讲解。

这里写图片描述

6. 了解下多段视频拼接合成

多段视频合成这里提供两种方案：

使用MediaCodec，MediaExtractor，MediaMuxer.(讲思路)。
使用mp4parser合成视频。(将使用)。
使用FFMpeg来实现。(音视频这一块找它就没错了，基本没有它实现不了的)。

下面我们主要来讲下两种方式的使用，第一种我们讲思路，第二种讲如何使用？第三个暂时不讲。

1. 讲下如何使用Android原生实现视频合成。

只讲思路及实现步骤，代码在项目中之后给出，目前我还没写进去，原谅我最近偷懒一波。大体思路如下：

我们通过MediaExtractor将媒体文件分解并找到轨道及帧数据。
将分解后的数据填充到MediaCodec的缓冲区中去。
通过MediaMuxer将MediaCodec中的数据和找到的音轨进行混合。
遍历第二个视频文件。

差不多就是这样滴，因为这个我是看别人是这么做的，我偷懒用了mp4parser,所以仅能给个位提供思路了，今后有时间再了解下。

这里写图片描述

2. 讲下如何使用mp4parser合成多个视频

上面有提到我现在使用的就是这个，他是开源滴，来来来，点这里给你们传送门。虽然上面对于使用方法都说得很清楚了，虽然我的项目中也会有源代码，但是我还是要把这部分写出来：

/**
   * 对Mp4文件集合进行追加合并(按照顺序一个一个拼接起来)
   * @param mp4PathList [输入]Mp4文件路径的集合(支持m4a)(不支持wav)
   * @param outPutPath  [输出]结果文件全部名称包含后缀(比如.mp4)
   * @throws IOException 格式不支持等情况抛出异常
   */
 public String mergeVideo(List<String> paths, String filePath) {
        long begin = System.currentTimeMillis();
        List<Movie> movies = new ArrayList<>();
        String filePath = "";
        if(paths.size() == 1){
            return paths.get(0);
        }
        try {
            for (int i = 0; i < paths.size(); i++) {
                if(paths != null  && paths.get(i) != null) {
                    Movie movie = MovieCreator.build(paths.get(i));//视频消息实体类
                    movies.add(movie);
                }
            }
            List<Track> videoTracks = new ArrayList<>();
            List<Track> audioTracks = new ArrayList<>();
            for (Movie movie : movies) {
                for (Track track : movie.getTracks()) {
                    if ("vide".equals(track.getHandler())) {
                        videoTracks.add(track);//从Movie对象中取出视频通道
                    }
                    if ("soun".equals(track.getHandler())) {
                        audioTracks.add(track);//Movie对象中得到的音频轨道
                    }
                }
            }
            Movie result = new Movie();
            if (videoTracks.size() > 0) {
		          // 将所有视频通道追加合并
                result.addTrack(new AppendTrack(videoTracks.toArray(new Track[videoTracks.size()])));
            }
            if (audioTracks.size() > 0) {
            // 将所有音频通道追加合并
                result.addTrack(new AppendTrack(audioTracks.toArray(new Track[audioTracks.size()])));
            }
            Container container = new DefaultMp4Builder().build(result);
            filePath = getRecorderPath();
            FileChannel fc = new RandomAccessFile(String.format(filePath), "rw").getChannel();//合成并输出到指定文件中
            container.writeContainer(fc);
            fc.close();
        }  catch (Exception e) {
            e.printStackTrace();
            return paths.get(0);
        }
        long end = System.currentTimeMillis();
        return filePath;
    }

7. 了解下如何获取视频帧？

先看下我们要实现什么功能，如下：

这里写图片描述

简单分析下，我们现在需要将整个视频的部分帧拿出在下面显示出来，并且添加上面的动态贴纸显示。

1. 如何拿出视频帧？

Android平台下主要有两种拿视频帧的方法：

使用ThumbnailUtils,一般用来拿去视频缩略图。
使用MediaMetadataRetriever的getFrameAtTime()拿视频帧（我们用的这种方式）。

MediaMetadataRetriever mediaMetadata = new MediaMetadataRetriever();
        mediaMetadata.setDataSource(mContext, Uri.parse(mInputVideoPath));
        mVideoRotation = mediaMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
        mVideoWidth = Integer.parseInt(mediaMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
        mVideoHeight = Integer.parseInt(mediaMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
        mVideoDuration = Integer.parseInt(mediaMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION));
        int  frameTime = 1000 * 1000;//帧间隔
        int  frame = mVideoDuration * 1000 / frameTime;//帧总数
        mAsyncTask = new AsyncTask<Void, Void, Boolean>() {
            @Override
            protected Boolean doInBackground(Void... params) {
                myHandler.sendEmptyMessage(ClEAR_BITMAP);
                for (int x = 0; x < frame; x++) {
	                //拿到帧图像
                    Bitmap bitmap = mediaMetadata.getFrameAtTime(frameTime * x, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);    
                }
                mediaMetadata.release();//释放别忘记
                return true;
            }

            @Override
            protected void onPostExecute(Boolean result) {
                myHandler.sendEmptyMessage(SUBMIT);//所有帧拿完了
            }

拿完所有帧，好了，好了，下一个话题。

2. 如何分解Gif图？

看到上面的等撩了么？

这里写图片描述

先说下为什么要将Gif图进行分解操作，因为我在添加动态贴纸的时候是在OpenGl Es的OnDraw方法中通过每次动态修改纹理来达到动态贴纸的效果的。所以必须要将Gif图分解成每帧的形式。怎么将Gif图解析出来呢？Google出来一个工具类GifDecoder！当然，后面我去找了Glide的源码，分析其内部Gif图的显示流程，发现其实原理是一样的。Glide StandardGifDecoder当然，关于Glide的Gif图解析内容还是蛮多的，这里不做分析（没有太过深入研究），今后有时间看能不能写一篇文章专门分析。

当然，关于GifDecoder的代码，这里就不贴出来了，会在项目中给出！当然，现在项目中还没有，因为文章写完，我这个项目肯定写不完的，最近事太多，忙着开产品讨论会，尽量在讨论之前5月25号之前能将项目写完。所以这里还请各位多谅解下。

7. 了解下FFmpeg

参考文章：1.FFmpeg官网2. 官方项目地址github3. [FFmpeg]ffmpeg各类参数说明与使用示例

如果你有接触到音视频开发这一块，肯定听说过FFmpeg这个庞然大物。为什么说庞然大物？因为我最近在学习这个，越学越觉得自己无知。哎，不多说了，我要加班恶补FFMpeg了。

1. 了解下什么是FFmpeg

FFmpeg是一个自由软件，可以运行音频和视频多种格式的录影、转换、流功能[2]，包含了libavcodec——这是一个用于多个项目中音频和视频的解码器库，以及libavformat——一个音频与视频格式转换库。(来源wiki)，简单点可以将FFmpeg理解成音视频处理软件。可以通过输入命令的方式对视频进行任何操作。没错，是任何（一点都不夸张）！

2. 如何在Android下使用FFmpeg

对于FFmpeg,我只想说，我还是个小白，希望各位大大不要在这个问题上抓着我严刑拷打。众所周知的，FFmpge是C实现的，所以生成so文件再调用吧！怎么办？我不会呀？这时候就要去找前人种的树了。这里给一个我参考使用的FFmpeg文件库导入EpMedia，哎，乘凉，感谢这位大大！

这里写图片描述

当然，如果想了解下FFmpeg的编译，可以看下Android最简单的基于FFmpeg的例子(一)---编译FFmpeg类库](http://www.ihubin.com/blog/android-ffmpeg-demo-1/)

如何使用？

//请记住这个cmd，输入命令cmd，我们就等着行了
 EpEditor.execCmd(cmd, 0, new OnEditorListener() {
            @Override
            public void onSuccess() {
                
            }

            @Override
            public void onFailure() {
             
            }

            @Override
            public void onProgress(float v) {
            }
        });

下面是在我的应用中使用到的一些命令：

1. 视频加减速命令：

设置变速值为speed（范围为0.5-2之间）;参数值：setpts= 1/speed;atempo=speed 减速：speed = 0.5;

ffmpeg -i /sdcard/WeiXinRecordedDemo/1515059397193/mergeVideo.mp4 -filter_complex [0:v]setpts=2.000000*PTS[v];[0:a]atempo=0.500000[a] -map [v] -map [a] -y /sdcard/WeiXinRecordedDemo/1515059397193/speedVideo.mp4

加速：speed = 2;

ffmpeg -i /sdcard/WeiXinRecordedDemo/1515118254029/mergeVideo.mp4 -filter_complex [0:v]setpts=0.500000*PTS[v];[0:a]atempo=2.000000[a] -map [v] -map [a] -y /sdcard/WeiXinRecordedDemo/1515118254029/speedVideo.mp4

2. 视频剪切命令：

ffmpeg -i /sdcard/WeiXinRecordedDemo/1515060907399/finish.mp4 -vcodec copy -acodec copy -ss 00:00:00 -t 00:00:01 /sdcard/WeiXinRecordedDemo/1515060907399/1515060998134.mp4

3. 视频压缩命令：

    String path = "/storage/emulated/0/ych/123.mp4";
    String currentOutputVideoPath = "/storage/emulated/0/ych/video/123456.mp4";
    String  commands ="-y -i " + path + " -strict-2 -vcodec libx264 -preset ultrafast " +
                        "-crf 24 -acodec aac -ar 44100 -ac 2 -b:a 96k -s 640x480 -aspect 16:9 " + currentOutputVideoPath;

4.给视频添加背景音乐

 ffmpeg -y -i /storage/emulated/0/DCIM/Camera/VID_20180104_121113.mp4 -i /storage/emulated/0/ych/music/A Little Kiss.mp3 -filter_complex [0:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,volume=1.0[a0];[1:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,volume=0.5[a1];[a0][a1]amix=inputs=2:duration=first[aout] -map [aout] -ac 2 -c:v copy -map 0:v:0 /storage/emulated/0/ych/music/1515468589128.mp4

5. 加字幕

命令：

ffmpeg -i <input> -filter_complex subtitles=filename=<SubtitleName>-y <output>

说明：利用libass来为视频嵌入字幕，字幕是直接嵌入到视频里的硬字幕。

6. 加水印

  String mCommands ="-y -i "+ videoPath + " -i " + imagePath + " -filter_complex [0:v]scale=iw:ih[outv0];[1:0]scale=240.0:84.0[outv1];[outv0][outv1]overlay=main_w-overlay_w-10:main_h-overlay_h-10 -preset ultrafast " + outVideoPath;

说明：imagePath为图片路径，overlay=100:100意义为overlay=x:y，在(x,y)坐标处開始加入水印。scale 为图片的缩放比例

左上角：overlay=10:10 

右上角：overlay=main_w-overlay_w-10:10

左下角：overlay=10:main_h-overlay_h-10 

右下角：overlay=main_w-overlay_w-10:main_h-overlay_h-10

7. 旋转

视频旋转也可以参考使用OpenCV和FastCV,当然前两种是在线处理，如果是视频录制完成，我们可以通过mp4parser进行离线处理。参考博客Android进阶之视频录制播放常见问题

命令：

ffmpeg -i <input> -filter_complex transpose=X -y <output>

说明：transpose=1为顺时针旋转90°，transpose=2逆时针旋转90°。

8. 参考链接及项目

在音视频开发的路上，感谢下面的文章及项目的作者,感谢他们的无私奉献，在前面种好大树，让我们后来者乘凉。

参考学习对象（排名无先后）雷霄骅湖广午王逆流的鱼yuiop 小码哥_WS 感谢四位老哥的博客，给予了我很大帮助。
拍摄录制功能：1. grafika 2. WeiXinRecordedDemo
OpenGL 系列：1. 关于OpenGl的学习：AndroidOpenGLDemo LearnOpenGL-CN 2. 关于滤镜的话：android-gpuimage-plus-master android-gpuimage
关于FFmpeg 1.FFmpeg官网2. 官方项目地址github3. [FFmpeg]ffmpeg各类参数说明与使用示例1. ffmpeg-android-java
贴纸 1. StickerView

9. 结束语

到这里文章基本上结束了，最后想和各位说的是，实在抱歉，确实最近时间有点紧，每天来公司大部分时间在讨论产品，剩下的一小部分时间不是在路上，就是在吃饭睡觉了。每天能抽半个小时写就很不错了。值得庆幸的是，最终它还是完成了，希望通过本文能给大家带来一些实质性的帮助。本来想多写一点，尽量写详细点，但是精力有限，后面的关于滤镜，美颜，变声，及人脸识别部分的之后会再重新整理。最后，项目地址AndroidCamera。

10. 广告

请注意，以下内容将全都是广告：

aserbao的简书
aserbao的csdn
我的同名微信公众号aserbao，分享音视频技术及Android开发小技巧。

这里写图片描述