内容一：Android平台下视频编码？

1、查找编码器？

遇到了问题：找不到编码器？->h264编码器
答案：因为我们没有编译libx264库->支持h264编码
首先：编译libx264库->脚本
其次：将libx264库加入到ffmpeg库里面

2、编码实现

#include <jni.h>
#include <string>
#include "android/log.h"

extern "C" {
//导入音视频头文件库
//核心库
#include "libavcodec/avcodec.h"
//封装格式处理库
#include "libavformat/avformat.h"
//工具库
#include "libavutil/imgutils.h"
//视频像素数据格式库
#include "libswscale/swscale.h"

JNIEXPORT void JNICALL Java_com_tz_dream_ffmpeg_android_video_encode_MainActivity_ffmpegVideoEncode(
        JNIEnv *env, jobject jobj, jstring jinFilePath, jstring joutFilePath);

}

int flush_encoder(AVFormatContext *fmt_ctx, unsigned int stream_index) {
    int ret;
    int got_frame;
    AVPacket enc_pkt;
    if (!(fmt_ctx->streams[stream_index]->codec->codec->capabilities &
          CODEC_CAP_DELAY))
        return 0;
    while (1) {
        enc_pkt.data = NULL;
        enc_pkt.size = 0;
        av_init_packet(&enc_pkt);
        ret = avcodec_encode_video2(fmt_ctx->streams[stream_index]->codec, &enc_pkt,
                                    NULL, &got_frame);
        av_frame_free(NULL);
        if (ret < 0)
            break;
        if (!got_frame) {
            ret = 0;
            break;
        }
        __android_log_print(ANDROID_LOG_INFO, "main",
                            "Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n", enc_pkt.size);
        /* mux encoded frame */
        ret = av_write_frame(fmt_ctx, &enc_pkt);
        if (ret < 0)
            break;
    }
    return ret;
}

//视频编码
JNIEXPORT void JNICALL Java_com_tz_dream_ffmpeg_android_video_encode_MainActivity_ffmpegVideoEncode(
        JNIEnv *env, jobject jobj, jstring jinFilePath, jstring joutFilePath) {
    //第一步：注册组件->编码器、解码器等等…
    av_register_all();

    //第二步：初始化封装格式上下文->视频编码->处理为视频压缩数据格式
    AVFormatContext *avformat_context = avformat_alloc_context();
    //注意事项：FFmepg程序推测输出文件类型->视频压缩数据格式类型
    const char *coutFilePath = env->GetStringUTFChars(joutFilePath, NULL);
    //得到视频压缩数据格式类型(h264、h265、mpeg2等等...)
    AVOutputFormat *avoutput_format = av_guess_format(NULL, coutFilePath, NULL);
    //指定类型
    avformat_context->oformat = avoutput_format;

    //第三步：打开输出文件
    //参数一：输出流
    //参数二：输出文件
    //参数三：权限->输出到文件中
    if (avio_open(&avformat_context->pb, coutFilePath, AVIO_FLAG_WRITE) < 0) {
        __android_log_print(ANDROID_LOG_INFO, "main", "打开输出文件失败");
        return;
    }

    //第四步：创建输出码流->创建了一块内存空间->并不知道他是什么类型流->希望他是视频流
    AVStream *av_video_stream = avformat_new_stream(avformat_context, NULL);

    //第五步：查找视频编码器
    //1、获取编码器上下文
    AVCodecContext *avcodec_context = av_video_stream->codec;

    //2、设置编解码器上下文参数->必需设置->不可少
    //目标：设置为是一个视频编码器上下文->指定的是视频编码器
    //上下文种类：视频解码器、视频编码器、音频解码器、音频编码器
    //2.1 设置视频编码器ID
    avcodec_context->codec_id = avoutput_format->video_codec;
    //2.2 设置编码器类型->视频编码器
    //视频编码器->AVMEDIA_TYPE_VIDEO
    //音频编码器->AVMEDIA_TYPE_AUDIO
    avcodec_context->codec_type = AVMEDIA_TYPE_VIDEO;
    //2.3 设置读取像素数据格式->编码的是像素数据格式->视频像素数据格式->YUV420P(YUV422P、YUV444P等等...)
    //注意：这个类型是根据你解码的时候指定的解码的视频像素数据格式类型
    avcodec_context->pix_fmt = AV_PIX_FMT_YUV420P;
    //2.4 设置视频宽高->视频尺寸
    avcodec_context->width = 640;
    avcodec_context->height = 352;
    //2.5 设置帧率->表示每秒25帧
    //视频信息->帧率 : 25.000 fps
    //f表示：帧数
    //ps表示：时间(单位：每秒)
    avcodec_context->time_base.num = 1;
    avcodec_context->time_base.den = 25;
    //2.6 设置码率
    //2.6.1 什么是码率？
    //含义：每秒传送的比特(bit)数单位为 bps(Bit Per Second)，比特率越高，传送数据速度越快。
    //单位：bps，"b"表示数据量，"ps"表示每秒
    //目的：视频处理->视频码率
    //2.6.2 什么是视频码率?
    //含义：视频码率就是数据传输时单位时间传送的数据位数，一般我们用的单位是kbps即千位每秒
    //视频码率计算如下？
    //基本的算法是：【码率】(kbps)=【视频大小 - 音频大小】(bit位) /【时间】(秒)
    //例如：Test.mov时间 = 24，文件大小(视频+音频) = 1.73MB
    //视频大小 = 1.34MB（文件占比：77%） = 1.34MB * 1024 * 1024 * 8 = 字节大小 = 468365字节 = 468Kbps
    //音频大小 = 376KB（文件占比：21%）
    //计算出来值->码率 : 468Kbps->表示1000，b表示位(bit->位)
    //总结：码率越大，视频越大
    avcodec_context->bit_rate = 468000;

    //2.7 设置GOP->影响到视频质量问题->画面组->一组连续画面
    //MPEG格式画面类型：3种类型->分为->I帧、P帧、B帧
    //I帧->内部编码帧->原始帧(原始视频数据)
    //    完整画面->关键帧(必需的有，如果没有I，那么你无法进行编码，解码)
    //    视频第1帧->视频序列中的第一个帧始终都是I帧，因为它是关键帧
    //P帧->向前预测帧->预测前面的一帧类型，处理数据(前面->I帧、B帧)
    //    P帧数据->根据前面的一帧数据->进行处理->得到了P帧
    //B帧->前后预测帧(双向预测帧)->前面一帧和后面一帧
    //    B帧压缩率高，但是对解码性能要求较高。
    //总结：I只需要考虑自己 = 1帧，P帧考虑自己+前面一帧 = 2帧，B帧考虑自己+前后帧 = 3帧
    //    说白了->P帧和B帧是对I帧压缩
    //每250帧，插入1个I帧，I帧越少，视频越小->默认值->视频不一样
    avcodec_context->gop_size = 250;

    //2.8 设置量化参数->数学算法(高级算法)->不讲解了
    //总结：量化系数越小，视频越是清晰
    //一般情况下都是默认值，最小量化系数默认值是10，最大量化系数默认值是51
    avcodec_context->qmin = 10;
    avcodec_context->qmax = 51;

    //2.9 设置b帧最大值->设置不需要B帧
    avcodec_context->max_b_frames = 0;

    //第二点：查找编码器->h264
    //找不到编码器->h264
    //重要原因是因为：编译库没有依赖x264库（默认情况下FFmpeg没有编译进行h264库）
    //第一步：编译h264库
    AVCodec *avcodec = avcodec_find_encoder(avcodec_context->codec_id);
    if (avcodec == NULL) {
        __android_log_print(ANDROID_LOG_INFO, "main", "找不到编码器");
        return;
    }

    __android_log_print(ANDROID_LOG_INFO, "main", "编码器名称为：%s", avcodec->name);


    //第六步：打开h264编码器
    //缺少优化步骤？
    //编码延时问题
    //编码选项->编码设置
    AVDictionary *param = 0;
    if (avcodec_context->codec_id == AV_CODEC_ID_H264) {
        //需要查看x264源码->x264.c文件
        //第一个值：预备参数
        //key: preset
        //value: slow->慢
        //value: superfast->超快
        av_dict_set(&param, "preset", "slow", 0);
        //第二个值：调优
        //key: tune->调优
        //value: zerolatency->零延迟
        av_dict_set(&param, "tune", "zerolatency", 0);
    }
    if (avcodec_open2(avcodec_context, avcodec, &param) < 0) {
        __android_log_print(ANDROID_LOG_INFO, "main", "打开编码器失败");
        return;
    }

    //第七步：写入文件头信息
    avformat_write_header(avformat_context, NULL);

    //第8步：循环编码yuv文件->视频像素数据(yuv格式)->编码->视频压缩数据(h264格式)
    //8.1 定义一个缓冲区
    //作用：缓存一帧视频像素数据
    //8.1.1 获取缓冲区大小
    int buffer_size = av_image_get_buffer_size(avcodec_context->pix_fmt,
                                               avcodec_context->width,
                                               avcodec_context->height,
                                               1);

    //8.1.2 创建一个缓冲区
    int y_size = avcodec_context->width * avcodec_context->height;
    uint8_t *out_buffer = (uint8_t *) av_malloc(buffer_size);

    //8.1.3 打开输入文件
    const char *cinFilePath = env->GetStringUTFChars(jinFilePath, NULL);
    FILE *in_file = fopen(cinFilePath, "rb");
    if (in_file == NULL) {
        __android_log_print(ANDROID_LOG_INFO, "main", "文件不存在");
        return;
    }

    //8.2.1 开辟一块内存空间->av_frame_alloc
    //开辟了一块内存空间
    AVFrame *av_frame = av_frame_alloc();
    //8.2.2 设置缓冲区和AVFrame类型保持一直->填充数据
    av_image_fill_arrays(av_frame->data,
                         av_frame->linesize,
                         out_buffer,
                         avcodec_context->pix_fmt,
                         avcodec_context->width,
                         avcodec_context->height,
                         1);

    int i = 0;

    //9.2 接收一帧视频像素数据->编码为->视频压缩数据格式
    AVPacket *av_packet = (AVPacket *) av_malloc(buffer_size);
    int result = 0;
    int current_frame_index = 1;
    while (true) {
        //8.1 从yuv文件里面读取缓冲区
        //读取大小：y_size * 3 / 2
        if (fread(out_buffer, 1, y_size * 3 / 2, in_file) <= 0) {
            __android_log_print(ANDROID_LOG_INFO, "main", "读取完毕...");
            break;
        } else if (feof(in_file)) {
            break;
        }

        //8.2 将缓冲区数据->转成AVFrame类型
        //给AVFrame填充数据
        //8.2.3 void * restrict->->转成->AVFrame->ffmpeg数据类型
        //Y值
        av_frame->data[0] = out_buffer;
        //U值
        av_frame->data[1] = out_buffer + y_size;
        //V值
        av_frame->data[2] = out_buffer + y_size * 5 / 4;
        av_frame->pts = i;
        //注意时间戳
        i++;
        //总结：这样一来我们的AVFrame就有数据了

        //第9步：视频编码处理
        //9.1 发送一帧视频像素数据
        avcodec_send_frame(avcodec_context, av_frame);
        //9.2 接收一帧视频像素数据->编码为->视频压缩数据格式
        result = avcodec_receive_packet(avcodec_context, av_packet);
        //9.3 判定是否编码成功
        if (result == 0) {
            //编码成功
            //第10步：将视频压缩数据->写入到输出文件中->outFilePath
            av_packet->stream_index = av_video_stream->index;
            result = av_write_frame(avformat_context, av_packet);
            __android_log_print(ANDROID_LOG_INFO, "main", "当前是第%d帧", current_frame_index);
            current_frame_index++;
            //是否输出成功
            if (result < 0) {
                __android_log_print(ANDROID_LOG_INFO, "main", "输出一帧数据失败");
                return;
            }
        }
    }

    //第11步：写入剩余帧数据->可能没有
    flush_encoder(avformat_context, 0);

    //第12步：写入文件尾部信息
    av_write_trailer(avformat_context);

    //第13步：释放内存
    avcodec_close(avcodec_context);
    av_free(av_frame);
    av_free(out_buffer);
    av_packet_free(&av_packet);
    avio_close(avformat_context->pb);
    avformat_free_context(avformat_context);
    fclose(in_file);
}

3、实例工程

https://pan.baidu.com/s/1kVcidBT

内容二：iOS平台下视频编码？

1、第一步：查找编码器

报错：找不到编码器
答案：因为我们没有编译libx264库->支持h264编码
首先：编译libx264库->脚本
build_x264_iOS.sh->结果：libx264.a静态库和头文件
其次：将libx264库加入到ffmpeg库里面
build_ffmpeg_iOS_x264.sh->结果：FFmpeg8个库
注意：依赖libx264.a
指定：
--extra-cflags="-I/Users/yangshaohong/Desktop/ffmpeg-test/test/thin-x264/arm64/include"
--extra-ldflags="-L/Users/yangshaohong/Desktop/ffmpeg-test/test/thin-x264/arm64/lib" \

2、源代码

build_ffmpeg_iOS_x264.sh

#!/bin/bash

#1、首先：定义下载的库名称
source="ffmpeg-3.4"

#2、其次：定义".h/.m/.c"文件编译的结果目录
#目录作用：用于保存.h/.m/.c文件编译后的结果.o文件
cache="cache"

#3、定义".a"静态库保存目录
#pwd命令：表示获取当前目录
staticdir=`pwd`/"ffmpeg-iOS"

#4、添加FFmpeg配置选项->默认配置
#Toolchain options:工具链选项（指定我么需要编译平台CPU架构类型，例如：arm64、x86等等…）
#--enable-cross-compile: 交叉编译
#Developer options:开发者选项
#--disable-debug: 禁止使用调试模式
#Program options选项
#--disable-programs:禁用程序(不允许建立命令行程序)
#Documentation options：文档选项
#--disable-doc：不需要编译文档
#Toolchain options：工具链选项
#--enable-pic：允许建立与位置无关代码
configure_flags="--enable-cross-compile --disable-debug --enable-x86asm --disable-programs --disable-doc --enable-pic"
#核心库(编解码->最重要的库)：avcodec
configure_flags="$configure_flags --enable-avdevice --enable-avcodec --enable-avformat"

#5、定义默认CPU平台架构类型
#arm64 armv7->真机->CPU架构类型
#x86_64 i386->模拟器->CPU架构类型
archs="arm64 armv7 x86_64 i386"

#6、指定我们的这个库编译系统版本->iOS系统下的7.0以及以上版本使用这个静态库
targetversion="7.0"

#7、接受命令后输入参数
#我是动态接受命令行输入CPU平台架构类型(输入参数：编译指定的CPU库)
if [ "$*" ]
then
    #存在输入参数，也就说：外部指定需要编译CPU架构类型
    archs="$*"
fi

echo "循环编译"

#9、for循环编译FFmpeg静态库
currentdir=`pwd`
for arch in $archs
do
    echo "开始编译"
    #9.1、创建目录
    #在编译结果目录下-创建对应的平台架构类型
    mkdir -p "$cache/$arch"
    #9.2、进入这个目录
    cd "$cache/$arch"

    #9.3、配置编译CPU架构类型->指定当前编译CPU架构类型
    #错误三："--arch $arch"
    #正确三："-arch $arch"
    archflags="-arch $arch"

    #9.4、判定一下你到底是编译的是模拟器.a静态库，还是真机.a静态库
    if [ "$arch" = "i386" -o "$arch" = "x86_64" ]
    then
        #模拟器
        platform="iPhoneSimulator"
        #支持最小系统版本->iOS系统
        archflags="$archflags -mios-simulator-version-min=$targetversion"
    else
        #真机(mac、iOS都支持)
        platform="iPhoneOS"
        #支持最小系统版本->iOS系统
        archflags="$archflags -mios-version-min=$targetversion -fembed-bitcode"
        #注意:优化处理(可有可无)
        #如果架构类型是"arm64"，那么
        if [ "$arch" = "arm64" ]
        then
            #GNU汇编器（GNU Assembler），简称为GAS
            #GASPP->汇编器预处理程序
            #解决问题：分段错误
            #通俗一点：就是程序运行时,变量访问越界一类的问题
            EXPORT="GASPP_FIX_XCODE5=1"
        fi
    fi


    #10、正式编译
    #tr命令可以对来自标准输入的字符进行替换、压缩和删除
    #'[:upper:]'->将小写转成大写
    #'[:lower:]'->将大写转成小写
    #将platform->转成大写或者小写
    XCRUN_SDK=`echo $platform | tr '[:upper:]' '[:lower:]'`
    #编译器->编译平台
    CC="xcrun -sdk $XCRUN_SDK clang"

    #架构类型->arm64
    if [ "$arch" = "arm64" ]
    then
        #音视频默认一个编译命令
        #preprocessor.pl帮助我们编译FFmpeg->arm64位静态库
        AS="gas-preprocessor.pl -arch aarch64 -- $CC"
    else
        #默认编译平台
        AS="$CC"
    fi

    echo "执行到了1"

    #目录找到FFmepg编译源代码目录->设置编译配置->编译FFmpeg源码
    #--target-os:目标系统->darwin(mac系统早起版本名字)
    #darwin:是mac系统、iOS系统祖宗
    #--arch:CPU平台架构类型
    #--cc：指定编译器类型选项
    #--as:汇编程序
    #$configure_flags最初配置
    #--extra-cflags
    #--prefix：静态库输出目录
    TMPDIR=${TMPDIR/%\/} $currentdir/$source/configure \
        --target-os=darwin \
        --arch=$arch \
        --cc="$CC" \
        --as="$AS" \
        $configure_flags \
        --enable-gpl \
        --disable-encoders \
        --enable-libx264 \
        --enable-encoder=libx264 \
        --enable-encoder=mjpeg \
        --enable-encoder=png \
        --extra-cflags="$archflags " \
        --extra-ldflags="$archflags " \
        --extra-cflags="-I/Users/yangshaohong/Desktop/ffmpeg-test/test/thin-x264/arm64/include" \
        --extra-ldflags="-L/Users/yangshaohong/Desktop/ffmpeg-test/test/thin-x264/arm64/lib" \
        --prefix="$staticdir/$arch" \
        || exit 1

    echo "执行了"

    #解决问题->分段错误问题
    #安装->导出静态库(编译.a静态库)
    #执行命令
    #将-j设置为支持多核心/线程
    make -j3 install $EXPORT || exit 1
    #回到了我们的脚本文件目录
    cd $currentdir
done

build_x264_iOS.sh

#!/bin/sh

CONFIGURE_FLAGS="--enable-static --enable-pic --disable-cli"

ARCHS="arm64 x86_64 i386 armv7 armv7s"

# directories
SOURCE="x264"
FAT="x264-iOS"

SCRATCH="scratch-x264"
# must be an absolute path
THIN=`pwd`/"thin-x264"

# the one included in x264 does not work; specify full path to working one
GAS_PREPROCESSOR=/usr/local/bin/gas-preprocessor.pl

COMPILE="y"
LIPO="y"

if [ "$*" ]
then
    if [ "$*" = "lipo" ]
    then
        # skip compile
        COMPILE=
    else
        ARCHS="$*"
        if [ $# -eq 1 ]
        then
            # skip lipo
            LIPO=
        fi
    fi
fi

if [ "$COMPILE" ]
then
    CWD=`pwd`
    for ARCH in $ARCHS
    do
        echo "building $ARCH..."
        mkdir -p "$SCRATCH/$ARCH"
        cd "$SCRATCH/$ARCH"
        CFLAGS="-arch $ARCH"
                ASFLAGS=

        if [ "$ARCH" = "i386" -o "$ARCH" = "x86_64" ]
        then
            PLATFORM="iPhoneSimulator"
            CPU=
            if [ "$ARCH" = "x86_64" ]
            then
                CFLAGS="$CFLAGS -mios-simulator-version-min=7.0"
                HOST=
            else
                CFLAGS="$CFLAGS -mios-simulator-version-min=5.0"
            HOST="--host=i386-apple-darwin"
            fi
        else
            PLATFORM="iPhoneOS"
            if [ $ARCH = "arm64" ]
            then
                HOST="--host=aarch64-apple-darwin"
            XARCH="-arch aarch64"
            else
                HOST="--host=arm-apple-darwin"
            XARCH="-arch arm"
            fi
                    CFLAGS="$CFLAGS -fembed-bitcode -mios-version-min=7.0"
                    ASFLAGS="$CFLAGS"
        fi

        XCRUN_SDK=`echo $PLATFORM | tr '[:upper:]' '[:lower:]'`
        CC="xcrun -sdk $XCRUN_SDK clang"
        if [ $PLATFORM = "iPhoneOS" ]
        then
            export AS="gas-preprocessor.pl $XARCH -- $CC"
        else
            export -n AS
        fi
        CXXFLAGS="$CFLAGS"
        LDFLAGS="$CFLAGS"

        CC=$CC $CWD/$SOURCE/configure \
            $CONFIGURE_FLAGS \
            $HOST \
            --extra-cflags="$CFLAGS" \
            --extra-asflags="$ASFLAGS" \
            --extra-ldflags="$LDFLAGS" \
            --prefix="$THIN/$ARCH" || exit 1

        mkdir extras
        ln -s $GAS_PREPROCESSOR extras

        make -j3 install || exit 1
        cd $CWD
    done
fi

if [ "$LIPO" ]
then
    echo "building fat binaries..."
    mkdir -p $FAT/lib
    set - $ARCHS
    CWD=`pwd`
    cd $THIN/$1/lib
    for LIB in *.a
    do
        cd $CWD
        lipo -create `find $THIN -name $LIB` -output $FAT/lib/$LIB
    done

    cd $CWD
    cp -rf $THIN/$1/include $FAT
fi

3、实例工程

https://pan.baidu.com/s/1qYV2yO8

内容三：Android平台下音频编码？

代码没有太大区别？
Copy代码
音频编码也是如此，也需要编译依赖库
作业：提示->libfdk-aac库？-和视频编码类似

1、源代码：

#include <jni.h>
#include <string>
#include "android/log.h"

extern "C"{
//导入音视频头文件库
//核心库
#include "libavcodec/avcodec.h"
//封装格式处理库
#include "libavformat/avformat.h"
//工具库
#include "libavutil/imgutils.h"

JNIEXPORT void JNICALL
Java_com_tz_dream_ffmpeg_android_audio_encode_MainActivity_ffmpegAudioEncode(
        JNIEnv *env, jobject jobj, jstring jinFilePath, jstring joutFilePath);
}


int flush_encoder(AVFormatContext *fmt_ctx, unsigned int stream_index) {
    int ret;
    int got_frame;
    AVPacket enc_pkt;
    if (!(fmt_ctx->streams[stream_index]->codec->codec->capabilities &
          CODEC_CAP_DELAY))
        return 0;
    while (1) {
        enc_pkt.data = NULL;
        enc_pkt.size = 0;
        av_init_packet(&enc_pkt);
        ret = avcodec_encode_video2(fmt_ctx->streams[stream_index]->codec, &enc_pkt,
                                    NULL, &got_frame);
        av_frame_free(NULL);
        if (ret < 0)
            break;
        if (!got_frame) {
            ret = 0;
            break;
        }
        __android_log_print(ANDROID_LOG_INFO, "main",
                            "Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n", enc_pkt.size);
        /* mux encoded frame */
        ret = av_write_frame(fmt_ctx, &enc_pkt);
        if (ret < 0)
            break;
    }
    return ret;
}


//音频编码
JNIEXPORT void JNICALL
Java_com_tz_dream_ffmpeg_android_audio_encode_MainActivity_ffmpegAudioEncode(
        JNIEnv *env, jobject jobj, jstring jinFilePath, jstring joutFilePath) {

    //第一步：注册组件->音频编码器等等…
    av_register_all();

    //第二步：初始化封装格式上下文->视频编码->处理为音频压缩数据格式
    AVFormatContext *avformat_context = avformat_alloc_context();
    //注意事项：FFmepg程序推测输出文件类型->音频压缩数据格式类型->aac格式
    const char *coutFilePath = env->GetStringUTFChars(joutFilePath, NULL);
    //得到音频压缩数据格式类型(aac、mp3等...)
    AVOutputFormat *avoutput_format = av_guess_format(NULL, coutFilePath, NULL);
    //指定类型
    avformat_context->oformat = avoutput_format;

    //第三步：打开输出文件
    //参数一：输出流
    //参数二：输出文件
    //参数三：权限->输出到文件中
    if (avio_open(&avformat_context->pb, coutFilePath, AVIO_FLAG_WRITE) < 0) {
        __android_log_print(ANDROID_LOG_INFO, "main", "打开输出文件失败");
        return;
    }

    //第四步：创建输出码流->创建了一块内存空间->并不知道他是什么类型流->希望他是视频流
    AVStream *av_audio_stream = avformat_new_stream(avformat_context, NULL);

    //第五步：查找音频编码器
    //1、获取编码器上下文
    AVCodecContext *avcodec_context = av_audio_stream->codec;

    //2、设置编解码器上下文参数->必需设置->不可少
    //目标：设置为是一个音频编码器上下文->指定的是音频编码器
    //上下文种类：音频解码器、音频编码器
    //2.1 设置音频编码器ID
    avcodec_context->codec_id = avoutput_format->audio_codec;
    //2.2 设置编码器类型->音频编码器
    //视频编码器->AVMEDIA_TYPE_VIDEO
    //音频编码器->AVMEDIA_TYPE_AUDIO
    avcodec_context->codec_type = AVMEDIA_TYPE_AUDIO;
    //2.3 设置读取音频采样数据格式->编码的是音频采样数据格式->音频采样数据格式->pcm格式
    //注意：这个类型是根据你解码的时候指定的解码的音频采样数据格式类型
    avcodec_context->sample_fmt = AV_SAMPLE_FMT_S16;
    //设置采样率
    avcodec_context->sample_rate = 44100;
    //立体声
    avcodec_context->channel_layout = AV_CH_LAYOUT_STEREO;
    //声道数量
    int channels = av_get_channel_layout_nb_channels(avcodec_context->channel_layout);
    avcodec_context->channels = channels;
    //设置码率
    //基本的算法是：【码率】(kbps)=【视频大小 - 音频大小】(bit位) /【时间】(秒)
    avcodec_context->bit_rate = 128000;

    //第二点：查找音频编码器->aac
    AVCodec *avcodec = avcodec_find_encoder(avcodec_context->codec_id);
    if (avcodec == NULL) {
        __android_log_print(ANDROID_LOG_INFO, "main", "找不到音频编码器");
        return;
    }

    __android_log_print(ANDROID_LOG_INFO, "main", "音频编码器名称为：%s", avcodec->name);


    //第六步：打开aac编码器
    if (avcodec_open2(avcodec_context, avcodec, NULL) < 0) {
        __android_log_print(ANDROID_LOG_INFO, "main", "打开音频编码器失败");
        return;
    }

    //第七步：写入文件头信息
    avformat_write_header(avformat_context, NULL);

    //第8步：循环编码yuv文件->视频像素数据(yuv格式)->编码->视频压缩数据(h264格式)
    //8.1 定义一个缓冲区
    //作用：缓存一帧视频像素数据
    //8.1.1 获取缓冲区大小
    int buffer_size = av_image_get_buffer_size(avcodec_context->pix_fmt,
                                               avcodec_context->width,
                                               avcodec_context->height,
                                               1);

    //8.1.2 创建一个缓冲区
    int y_size = avcodec_context->width * avcodec_context->height;
    uint8_t *out_buffer = (uint8_t *) av_malloc(buffer_size);

    //8.1.3 打开输入文件
    const char *cinFilePath = env->GetStringUTFChars(jinFilePath, NULL);
    FILE *in_file = fopen(cinFilePath, "rb");
    if (in_file == NULL) {
        __android_log_print(ANDROID_LOG_INFO, "main", "文件不存在");
        return;
    }

    //8.2.1 开辟一块内存空间->av_frame_alloc
    //开辟了一块内存空间
    AVFrame *av_frame = av_frame_alloc();
    //8.2.2 设置缓冲区和AVFrame类型保持一直->填充数据
    av_image_fill_arrays(av_frame->data,
                         av_frame->linesize,
                         out_buffer,
                         avcodec_context->pix_fmt,
                         avcodec_context->width,
                         avcodec_context->height,
                         1);

    int i = 0;

    //9.2 接收一帧视频像素数据->编码为->视频压缩数据格式
    AVPacket *av_packet = (AVPacket *) av_malloc(buffer_size);
    int result = 0;
    int current_frame_index = 1;
    while (true) {
        //8.1 从yuv文件里面读取缓冲区
        //读取大小：y_size * 3 / 2
        if (fread(out_buffer, 1, y_size * 3 / 2, in_file) <= 0) {
            __android_log_print(ANDROID_LOG_INFO, "main", "读取完毕...");
            break;
        } else if (feof(in_file)) {
            break;
        }

        //8.2 将缓冲区数据->转成AVFrame类型
        //给AVFrame填充数据
        av_frame->data[0] = out_buffer;
        av_frame->pts = i;
        //注意时间戳
        i++;
        //总结：这样一来我们的AVFrame就有数据了

        //第9步：视频编码处理
        //9.1 发送一帧视频像素数据
        avcodec_send_frame(avcodec_context, av_frame);
        //9.2 接收一帧视频像素数据->编码为->视频压缩数据格式
        result = avcodec_receive_packet(avcodec_context, av_packet);
        //9.3 判定是否编码成功
        if (result == 0) {
            //编码成功
            //第10步：将视频压缩数据->写入到输出文件中->outFilePath
            av_packet->stream_index = av_audio_stream->index;
            result = av_write_frame(avformat_context, av_packet);
            __android_log_print(ANDROID_LOG_INFO, "main", "当前是第%d帧", current_frame_index);
            current_frame_index++;
            //是否输出成功
            if (result < 0) {
                __android_log_print(ANDROID_LOG_INFO, "main", "输出一帧数据失败");
                return;
            }
        }
    }

    //第11步：写入剩余帧数据->可能没有
    flush_encoder(avformat_context, 0);

    //第12步：写入文件尾部信息
    av_write_trailer(avformat_context);

    //第13步：释放内存
    avcodec_close(avcodec_context);
    av_free(av_frame);
    av_free(out_buffer);
    av_packet_free(&av_packet);
    avio_close(avformat_context->pb);
    avformat_free_context(avformat_context);
    fclose(in_file);

}

2、实例工程

https://pan.baidu.com/s/1pKXWfnt