声 明
首先,这一系列文章均基于自己的理解和实践,可能有不对的地方,欢迎大家指正。
其次,这是一个入门系列,涉及的知识也仅限于够用,深入的知识网上也有许许多多的博文供大家学习了。
最后,写文章过程中,会借鉴参考其他人分享的文章,会在文章最后列出,感谢这些作者的分享。
码字不易,转载请注明出处!
教程代码:【Github传送门:https://github.com/ChenLittlePing/LearningVideo】 |
---|
目录
一、Android音视频硬解码篇:
二、使用OpenGL渲染视频画面篇
三、Android FFmpeg音视频解码篇
7,Android FFmpeg视频编码
本文你可以了解到
如何使用 FFmepg 对编辑好的视频进行重新编码,生成可以播放的音视频文件。
写在前面
本文是音视频系列文章的最后一篇了,也是拖了最久的一篇(懒癌发作-_-!!),终于下定决心,把坑填完。话不多说了,马上进入正文。
在【上一篇文章】中,介绍了如何对音视频文件进行解封和重新封装,这个过程不涉及音视频的解码和编码,也就是没有对音视频进行编辑,这无法满足日常的开发需求。
因此,本文将填上编辑过程的空缺,为本系列画上句号。
一、整体流程说明
在前面的几篇文章中,我们已经做好了 解码器
, OpenGL 渲染器
,因此,编码的时候,除了需要 编码器
外,还需要将之前的内容做好整合。下面通过一张图做一下简要说明:
![](https://i-blog.csdnimg.cn/blog_migrate/37d316c5d6ed5b8a146edba4b0c0c954.png)
模块
首先可以关注到,这个过程有三个大模块,也是三个 独立又互相关联
的线程,分别负责:
原视频解码
OpenGL 画面渲染
目标视频编码
数据流向
看下视频数据是如何流转的:
原视频经过
解码器
解码后,得到YUV
数据,经过格式转换,成为RGB
数据。解码器
将RGB
数据传递给绘制器
,等待OpenGL 渲染器
使用。OpenGL 渲染器
通过内部的线程循环,在适当的时候,调用绘制器
渲染画面。画面绘制完毕以后,得到经过
OpenGL
渲染(编辑过)的画面,送到编码器
进行编码。最后,将编码好的数据,写入本地文件。
说明:
本文将主要讲音视频的
编码
知识,由于整个过程涉及到解码
、OpenGL 渲染
这两个前面介绍过的知识点,我们将复用之前封装好的工具,并在一些特殊地方根据编码的需要做一些适配。因此接下来在涉及到解码和OpenGL的地方,至贴出适配的代码,具体可以查看之前的文章,或者直接查看源码。
二、关于 x264 so 库编译和引入
由于 x264
是基于 GPL
开源协议的,而 FFmpeg
默认是基于 LGPL
协议的,当引入 x264
时,由于 GPL
的传染性,导致我们的代码也必须开源,你可以使用 OpenH264
来代替。
这里仍然使用 x264
来学习相关的编码过程。
另外,限于篇幅,本文不会介绍关于 x264
的编译,会另外写文章介绍。
x264 so 库的引入和其他 so 引入是一样的,具体请参考之前的文章,或者查看源码中的 CMakeList.txt 。
FFmpeg
已经内置了 h264 解码器,所以如果只是解码,并不需要引入x264
。
三、封装编码器
编码过程和解码过程是非常类似的,其实就是解码的逆过程,因此整个代码框架流程和解码器 BaseDecoder
基本是一致的。
定义 BaseEncoder
// BaseEncoder.h
class BaseEncoder: public IEncoder {
private:
// 编码格式 ID
AVCodecID m_codec_id;
// 线程依附的JVM环境
JavaVM *m_jvm_for_thread = NULL;
// 编码器
AVCodec *m_codec = NULL;
// 编码上下文
AVCodecContext *m_codec_ctx = NULL;
// 编码数据包
AVPacket *m_encoded_pkt = NULL;
// 写入Mp4的输入流索引
int m_encode_stream_index = 0;
// 原数据时间基
AVRational m_src_time_base;
// 缓冲队列
std::queue<OneFrame *> m_src_frames;
// 操作数据锁
std::mutex m_frames_lock;
// 状态回调
IEncodeStateCb *m_state_cb = NULL;
bool Init();
/**
* 循环拉去已经编码的数据,直到没有数据或者编码完毕
* @return true 编码结束;false 编码未完成
*/
bool DrainEncode();
/**
* 编码一帧数据
* @return 错误信息
*/
int EncodeOneFrame();
// 新建编码线程
void CreateEncodeThread();
// 解码静态方法,给线程调用
static void Encode(std::shared_ptr<BaseEncoder> that);
void OpenEncoder();
// 循环编码
void LoopEncode();
void DoRelease();
// 省略一些非重点代码(具体请查看源码)
// .......
protected:
// Mp4 封装器
Mp4Muxer *m_muxer = NULL;
//-------------子类需要复写的方法 begin-----------
// 初始化编码参数(上下文)
virtual void InitContext(AVCodecContext *codec_ctx) = 0;
// 配置Mp4 混淆通道信息
virtual int ConfigureMuxerStream(Mp4Muxer *muxer, AVCodecContext *ctx) = 0;
// 处理一帧数据
virtual AVFrame* DealFrame(OneFrame *one_frame) = 0;
// 释放资源
virtual void Release() = 0;
virtual const char *const LogSpec() = 0;
//-------------子类需要复写的方法 end-----------
public:
BaseEncoder(JNIEnv *env, Mp4Muxer *muxer, AVCodecID codec_id);
// 压入一帧待编码数据(由外部调用)
void PushFrame(OneFrame *one_frame) override ;
// 判断是否缓冲数据过多,用于控制缓冲队列大小
bool TooMuchData() override {
return m_src_frames.size() > 100;
}
// 设置编码状态监听器
void SetStateReceiver(IEncodeStateCb *cb) override {
this->m_state_cb = cb;
}
};
编码器定义并不复杂,无非就是编码需要用到的编码器 m_codec
、解码上下文 m_codec_id
等,以及封装对应的函数方法来拆分编码过程中的几个步骤。这里主要强调几点:
控制编码缓冲队列大小
由于编码过程中,编码速度远远小于解码速度,因此需要控制缓冲队列大小,避免大量的数据堆积,导致内容溢出或申请内存失败问题。
时间戳转换
时间戳转换在上篇文章中已经有说明,具体请查看上篇文章。总之,由于原视频和目标视频时间基是不一样的,因此需要对时间戳进行转换,才能保证编码保存后的时间是正常的。
确保 MP4 轨道索引是正确的
MP4 有音频和视频两个轨道,需要在写入的时候,对应好,具体查看代码中的
m_encode_stream_index
。
实现 BaseEncoder
初始化
// BaseEncoder.cpp
BaseEncoder::BaseEncoder(JNIEnv *env, Mp4Muxer *muxer, AVCodecID codec_id)
: m_muxer(muxer),
m_codec_id(codec_id) {
if (Init()) {
env->GetJavaVM(&m_jvm_for_thread);
CreateEncodeThread();
}
}
bool BaseEncoder::Init() {
// 1. 查找编码器
m_codec = avcodec_find_encoder(m_codec_id);
if (m_codec == NULL) {
LOGE(TAG, "Fail to find encoder, code id is %d", m_codec_id)
return false;
}
// 2. 分配编码上下文
m_codec_ctx = avcodec_alloc_context3(m_codec);
if (m_codec_ctx == NULL) {
LOGE(TAG, "Fail to alloc encoder context")
return false;
}
// 3. 初始化编码数据包
m_encoded_pkt = av_packet_alloc();
av_init_packet(m_encoded_pkt);
return true;
}
void BaseEncoder::CreateEncodeThread() {
// 使用智能指针,线程结束时,自动删除本类指针
std::shared_ptr<BaseEncoder> that(this);
std::thread t(Encode, that);
t.detach();
}
编码需要两个参数,m_muxer
和 m_codec_id
,既:MP4 混合器和编码格式ID。
其中,编码格式 ID 根据音频和视频需要来设置,比如视频 H264 为:AV_CODEC_ID_H264
,音频 AAC 为:AV_CODEC_ID_AAC
。
接着,调用 Init()
方法:
根据编码格式 ID 查找编码器
分配编码上下文
初始化编码数据包
最后,创建编码线程。
封装编码流程
// BaseEncoder.cpp
void BaseEncoder::Encode(std::shared_ptr<BaseEncoder> that) {
JNIEnv * env;
//将线程附加到虚拟机,并获取env
if (that->m_jvm_for_thread->AttachCurrentThread(&env, NULL) != JNI_OK) {
LOG_ERROR(that->TAG, that->LogSpec(), "Fail to Init encode thread");
return;
}
that->OpenEncoder(); // 1
that->LoopEncode(); // 2
that->DoRelease(); // 3
//解除线程和jvm关联
that->m_jvm_for_thread->DetachCurrentThread();
}
过程和解码非常类似。
第1步,打开编码器
// BaseEncoder.cpp
void BaseEncoder::OpenEncoder() {
// 调用子类方法,根据音频和视频的不同,初始化编码上下文
InitContext(m_codec_ctx);
int ret = avcodec_open2(m_codec_ctx, m_codec, NULL);
if (ret < 0) {
LOG_ERROR(TAG, LogSpec(), "Fail to open encoder : %d", m_codec);
return;
}
m_encode_stream_index = ConfigureMuxerStream(m_muxer, m_codec_ctx);
}
第2步,开启编码循环
编码的核心方法只有两个:
avcodec_send_frame
: 数据发到编码队列
avcodec_receive_packet
: 接收编码好的数据
编码过程主要有 5 个步骤:
从缓冲队列中获取待解码数据
将原始数据交给子类处理(音频和视频根据自己的需求处理)
通过
avcodec_send_frame
将数据发送到编码器编码将编码好的数据抽取出来
还有一点,既第 5 点,重新发送数据。
需要说明一下这里采取的 双循环
编码逻辑:除了最外层的 while(tue)
循环以外,里面还有一个 while (m_src_frames.size() > 0)
循环。
在缓冲队列有数据,并且 FFmpeg 内部编码队列未满
的情况下,会不断地往 FFmpeg
发送数据,直到发现 FFmpeg
编码返回 AVERROR(EAGAIN)
,则说明内部队列已满,需要先将编码的数据抽取出来,也就是调用 DrainEncode()
方法。
还有一点需要说明的是:如何判读所有数据已经都发送给编码器了?
这里通过
one_frame->line_size
来判断。当监听到解码器通知解码完成的时候,则把一个空的帧数据
OneFrame
的line_size
设置为0
,并压入缓冲队列。
BaseEncoder
拿到这个空数据帧时,往FFmpeg
的avcodec_send_frame()
发送一个NULL
数据,则FFmpeg
会自动结束编码。
具体请看以下代码:
// BaseEncoder.cpp
void BaseEncoder::LoopEncode() {
if (m_state_cb != NULL) {
m_state_cb->EncodeStart();
}
while (true) {
if (m_src_frames.size() == 0) {
Wait();
}
while (m_src_frames.size() > 0) {
// 1. 获取待解码数据
m_frames_lock.lock();
OneFrame *one_frame = m_src_frames.front();
m_src_frames.pop();
m_frames_lock.unlock();
AVFrame *frame = NULL;
if (one_frame->line_size != 0) {
m_src_time_base = one_frame->time_base;
// 2. 子类处理数据
frame = DealFrame(one_frame);
delete one_frame;
if (m_state_cb != NULL) {
m_state_cb->EncodeSend();
}
if (frame == NULL) {
continue;
}
} else { //如果数据长度为0,说明编码已经结束,压入空frame,使编码器进入结束状态
delete one_frame;
}
// 3. 将数据发送到编码器
int ret = avcodec_send_frame(m_codec_ctx, frame);
switch (ret) {
case AVERROR_EOF:
LOG_ERROR(TAG, LogSpec(), "Send frame finish [AVERROR_EOF]")
break;
case AVERROR(EAGAIN): //编码编码器已满,先取出已编码数据,再尝试发送数据
while (ret == AVERROR(EAGAIN)) {
LOG_ERROR(TAG, LogSpec(), "Send frame error[EAGAIN]: %s", av_err2str(AVERROR(EAGAIN)));
// 4. 将编码好的数据榨干
if (DrainEncode()) return; //编码结束
// 5. 重新发送数据
ret = avcodec_send_frame(m_codec_ctx, frame);
}
break;
case AVERROR(EINVAL):
LOG_ERROR(TAG, LogSpec(), "Send frame error[EINVAL]: %s", av_err2str(AVERROR(EINVAL)));
break;
case AVERROR(ENOMEM):
LOG_ERROR(TAG, LogSpec(), "Send frame error[ENOMEM]: %s", av_err2str(AVERROR(ENOMEM)));
break;
default:
break;
}
if (ret != 0) break;
}
if (DrainEncode()) break; //编码结束
}
}
接下来看下上面提到的 DrainEncode()
方法:
// BaseEncoder.cpp
bool BaseEncoder::DrainEncode() {
int state = EncodeOneFrame();
while (state == 0) {
state = EncodeOneFrame();
}
return state == AVERROR_EOF;
}
int BaseEncoder::EncodeOneFrame() {
int state = avcodec_receive_packet(m_codec_ctx, m_encoded_pkt);
switch (state) {
case AVERROR_EOF: //解码结束
LOG_ERROR(TAG, LogSpec(), "Encode finish")
break;
case AVERROR(EAGAIN): //编码还未完成,待会再来
LOG_INFO(TAG, LogSpec(), "Encode error[EAGAIN]: %s", av_err2str(AVERROR(EAGAIN)));
break;
case AVERROR(EINVAL):
LOG_ERROR(TAG, LogSpec(), "Encode error[EINVAL]: %s", av_err2str(AVERROR(EINVAL)));
break;
case AVERROR(ENOMEM):
LOG_ERROR(TAG, LogSpec(), "Encode error[ENOMEM]: %s", av_err2str(AVERROR(ENOMEM)));
break;
default: // 成功获取到一帧编码好的数据,写入 MP4
//将视频pts/dts转换为容器pts/dts
av_packet_rescale_ts(m_encoded_pkt, m_src_time_base,
m_muxer->GetTimeBase(m_encode_stream_index));
if (m_state_cb != NULL) {
m_state_cb->EncodeFrame(m_encoded_pkt->data);
long cur_time = (long)(m_encoded_pkt->pts*av_q2d(m_muxer->GetTimeBase(m_encode_stream_index))*1000);
m_state_cb->EncodeProgress(cur_time);
}
m_encoded_pkt->stream_index = m_encode_stream_index;
m_muxer->Write(m_encoded_pkt);
break;
}
av_packet_unref(m_encoded_pkt);
return state;
}
同样是一个 while
循环,根据接收数据的状态来判断是否结束循环。
主要逻辑在 EncodeOneFrame()
中,通过 avcodec_receive_packet()
获取 FFmpeg
中已经完成编码的数据,如果该方法返回 0
说明获取成功,可以将数据写入 MP4
中。
EncodeOneFrame()
返回的就是 avcodec_receive_packet
的返回值,那么当其为 0
时,循环获取下一帧数据,直到返回值为 AVERROR(EAGAIN)
或 AVERROR_EOF
,既:没有数据 或 编码结束。
如此,通过以上几个循环,不断往编码器塞入数据,和拉取数据,直到完成所有数据编码,结束编码。
第3步,结束编码,释放资源
完成编码后,需要释放相关的资源
// BaseEncoder.cpp
void BaseEncoder::DoRelease() {
if (m_encoded_pkt != NULL) {
av_packet_free(&m_encoded_pkt);
m_encoded_pkt = NULL;
}
if (m_codec_ctx != NULL) {
avcodec_close(m_codec_ctx);
avcodec_free_context(&m_codec_ctx);
}
// 调用子类方法,释放子类资源
Release();
if (m_state_cb != NULL) {
m_state_cb->EncodeFinish();
}
}
封装视频编码器
视频编码器继承自上面定义好的基础编码器 BaseEncoder
。
// VideoEncoder.h
class VideoEncoder: public BaseEncoder {
private:
const char * TAG = "VideoEncoder";
// 视频格式转化工具
SwsContext *m_sws_ctx = NULL;
// 一阵 YUV 数据
AVFrame *m_yuv_frame = NULL;
// 目标视频宽高
int m_width = 0, m_height = 0;
void InitYUVFrame();
protected:
const char *const LogSpec() override {
return "视频";
};
void InitContext(AVCodecContext *codec_ctx) override;
int ConfigureMuxerStream(Mp4Muxer *muxer, AVCodecContext *ctx) override;
AVFrame* DealFrame(OneFrame *one_frame) override;
void Release() override;
public:
VideoEncoder(JNIEnv *env, Mp4Muxer *muxer, int width, int height);
};
具体实现:
1. 构造方法:
// VideoEncoder.cpp
VideoEncoder::VideoEncoder(JNIEnv *env, Mp4Muxer *muxer, int width, int height)
: BaseEncoder(env, muxer, AV_CODEC_ID_H264),
m_width(width),
m_height(height) {
m_sws_ctx = sws_getContext(width, height, AV_PIX_FMT_RGBA,
width, height, AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR,
NULL, NULL, NULL);
}
这里根据目标输出视频的宽高,原格式(OpenGL输出的RGBA数据)/目标格式(YUV),初始化格式转换器,这个与解码刚好是相反的过程。
2. 编码参数初始化:
2.1 初始化上下文和子类内部数据,主要时配置编码视频的 宽高
、码率
、帧率
、时间基
等。
还有一个比较重要的参数就是 qmin
和qmax
,其值范围为 [0~51],用于配置编码画面质量,值越大,画面质量越低,视频文件越小。可以跟自己的需求配置。
还有就是 InitYUVFrame()
申请转码需要用到的 YUV
数据内存空间。
// VideoEncoder.cpp
void VideoEncoder::InitContext(AVCodecContext *codec_ctx) {
codec_ctx->bit_rate = 3*m_width*m_height;
codec_ctx->width = m_width;
codec_ctx->height = m_height;
//把1秒钟分成fps个单位
codec_ctx->time_base = {1, ENCODE_VIDEO_FPS};
codec_ctx->framerate = {ENCODE_VIDEO_FPS, 1};
//画面组大小
codec_ctx->gop_size = 50;
//没有B帧
codec_ctx->max_b_frames = 0;
codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
codec_ctx->thread_count = 8;
av_opt_set(codec_ctx->priv_data, "preset", "ultrafast", 0);
av_opt_set(codec_ctx->priv_data, "tune", "zerolatency", 0);
//这是量化范围设定,其值范围为0~51,
//越小质量越高,需要的比特率越大,0为无损编码
codec_ctx->qmin = 28;
codec_ctx->qmax = 50;
//全局的编码信息
codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
InitYUVFrame();
LOGI(TAG, "Init codec context success")
}
void VideoEncoder::InitYUVFrame() {
//设置YUV输出空间
m_yuv_frame = av_frame_alloc();
m_yuv_frame->format = AV_PIX_FMT_YUV420P;
m_yuv_frame->width = m_width;
m_yuv_frame->height = m_height;
//分配空间
int ret = av_frame_get_buffer(m_yuv_frame, 0);
if (ret < 0) {
LOGE(TAG, "Fail to get yuv frame buffer");
}
}
2.2 根据解码器信息,写入对应的 MP4 轨道信息。
// VideoEncoder.cpp
int VideoEncoder::ConfigureMuxerStream(Mp4Muxer *muxer, AVCodecContext *ctx) {
return muxer->AddVideoStream(ctx);
}
3. 处理数据
还记得父类定义的子类数据处理方法吗?
视频编码器需要将 OpenGL
输出到 RGBA
数据转化为 YUV
数据,才能送进编码器编码。
// VideoEncoder.cpp
AVFrame* VideoEncoder::DealFrame(OneFrame *one_frame) {
uint8_t *in_data[AV_NUM_DATA_POINTERS] = { 0 };
in_data[0] = one_frame->data;
int src_line_size[AV_NUM_DATA_POINTERS] = { 0 };
src_line_size[0] = one_frame->line_size;
int h = sws_scale(m_sws_ctx, in_data, src_line_size, 0, m_height,
m_yuv_frame->data, m_yuv_frame->linesize);
if (h <= 0) {
LOGE(TAG, "转码出错");
return NULL;
}
m_yuv_frame->pts = one_frame->pts;
return m_yuv_frame;
}
4. 释放子类资源
编码结束后,父类回调子类方法,方法资源,通知 Mp4Muxer
结束视频通道写入。
// VideoEncoder.cpp
void VideoEncoder::Release() {
if (m_yuv_frame != NULL) {
av_frame_free(&m_yuv_frame);
m_yuv_frame = NULL;
}
if (m_sws_ctx != NULL) {
sws_freeContext(m_sws_ctx);
m_sws_ctx = NULL;
}
// 结束视频通道数据写入
m_muxer->EndVideoStream();
}
封装音频编码器
音频编码器基本视频是一样的,只是参数配置有所不同,直接来看实现就好。
常规的音频参数配置:比特率,编码格式,通道数量等
重点看下 InitFrame()
方法,这里需要通过通道数、编码格式等,借助 av_samples_get_buffer_size()
方法,计算用来保存目标帧数据的内存大小。
// AudioEncoder.cpp
AudioEncoder::AudioEncoder(JNIEnv *env, Mp4Muxer *muxer)
: BaseEncoder(env, muxer, AV_CODEC_ID_AAC) {
}
void AudioEncoder::InitContext(AVCodecContext *codec_ctx) {
codec_ctx->codec_type = AVMEDIA_TYPE_AUDIO;
codec_ctx->sample_fmt = ENCODE_AUDIO_DEST_FORMAT;
codec_ctx->sample_rate = ENCODE_AUDIO_DEST_SAMPLE_RATE;
codec_ctx->channel_layout = ENCODE_AUDIO_DEST_CHANNEL_LAYOUT;
codec_ctx->channels = ENCODE_AUDIO_DEST_CHANNEL_COUNTS;
codec_ctx->bit_rate = ENCODE_AUDIO_DEST_BIT_RATE;
InitFrame();
}
void AudioEncoder::InitFrame() {
m_frame = av_frame_alloc();
m_frame->nb_samples = 1024;
m_frame->format = ENCODE_AUDIO_DEST_FORMAT;
m_frame->channel_layout = ENCODE_AUDIO_DEST_CHANNEL_LAYOUT;
int size = av_samples_get_buffer_size(NULL, ENCODE_AUDIO_DEST_CHANNEL_COUNTS, m_frame->nb_samples,
ENCODE_AUDIO_DEST_FORMAT, 1);
uint8_t *frame_buf = (uint8_t *) av_malloc(size);
avcodec_fill_audio_frame(m_frame, ENCODE_AUDIO_DEST_CHANNEL_COUNTS, ENCODE_AUDIO_DEST_FORMAT,
frame_buf, size, 1);
}
int AudioEncoder::ConfigureMuxerStream(Mp4Muxer *muxer, AVCodecContext *ctx) {
return muxer->AddAudioStream(ctx);
}
AVFrame* AudioEncoder::DealFrame(OneFrame *one_frame) {
m_frame->pts = one_frame->pts;
memcpy(m_frame->data[0], one_frame->data, 4096);
memcpy(m_frame->data[1], one_frame->ext_data, 4096);
return m_frame;
}
void AudioEncoder::Release() {
m_muxer->EndAudioStream();
}
最后,DealFrame
需要将 one_frame
中保存的左右声道的数据复制到 m_frame
申请的内存中,并返回给 父类
送到编码器编码。
四、获取 OpenGL 渲染的视频数据
我们知道,视频数据经过 OpenGL 编辑以后,是无法直接送到编码器进行编码的,需要通过 OpenGL
的 glReadPixels
方法来获取。
下面就改造一下原来定义的 OpenGLRender
来实现。
完整代码请查看工程源码。
在渲染方法 Render()
中,增加获取的画面的方法:
// OpenGLRender.cpp
void OpenGLRender::Render() {
if (RENDERING == m_state) {
m_drawer_proxy->Draw();
m_egl_surface->SwapBuffers();
if (m_need_output_pixels && m_pixel_receiver != NULL) {//输出画面rgba
m_need_output_pixels = false;
Render(); //再次渲染最新的画面
size_t size = m_window_width * m_window_height * 4 * sizeof(uint8_t);
uint8_t *rgb = (uint8_t *) malloc(size);
if (rgb == NULL) {
realloc(rgb, size);
LOGE(TAG, "内存分配失败: %d", rgb)
}
glReadPixels(0, 0, m_window_width, m_window_height, GL_RGBA, GL_UNSIGNED_BYTE, rgb);
// 将数据发送出去
m_pixel_receiver->ReceivePixel(rgb);
}
}
}
增加一个请求方法,用于通知 OpenGLRender
将数据输发送出来:
// OpenGLRender.cpp
void OpenGLRender::RequestRgbaData() {
m_need_output_pixels = true;
}
原理很简单,在解码器解码一帧数据送入
OpenGL
渲染以后,就马上通知OpenGLRender
将画面发送出来。
当然了,还需要定义一个接收器:
// OpenGLPixelReceiver.h
class OpenGLPixelReceiver {
public:
virtual void ReceivePixel(uint8_t *rgba) = 0;
};
五、MP4 封装器
该部分内容基本就是【上一篇文章】的定义的重打包 FFRepack
工具的重新封装,这里不再赘述,请查看上一篇文章,或源码。
// Mp4Muxer.cpp
void Mp4Muxer::Init(JNIEnv *env, jstring path) {
const char *u_path = env->GetStringUTFChars(path, NULL);
int len = strlen(u_path);
m_path = new char[len];
strcpy(m_path, u_path);
//新建输出上下文
avformat_alloc_output_context2(&m_fmt_ctx, NULL, NULL, m_path);
// 释放引用
env->ReleaseStringUTFChars(path, u_path);
}
int Mp4Muxer::AddVideoStream(AVCodecContext *ctx) {
int stream_index = AddStream(ctx);
m_video_configured = true;
Start();
return stream_index;
}
int Mp4Muxer::AddAudioStream(AVCodecContext *ctx) {
int stream_index = AddStream(ctx);
m_audio_configured = true;
Start();
return stream_index;
}
int Mp4Muxer::AddStream(AVCodecContext *ctx) {
AVStream *video_stream = avformat_new_stream(m_fmt_ctx, NULL);
avcodec_parameters_from_context(video_stream->codecpar, ctx);
video_stream->codecpar->codec_tag = 0;
return video_stream->index;
}
void Mp4Muxer::Start() {
if (m_video_configured && m_audio_configured) {
av_dump_format(m_fmt_ctx, 0, m_path, 1);
//打开文件输入
int ret = avio_open(&m_fmt_ctx->pb, m_path, AVIO_FLAG_WRITE);
if (ret < 0) {
LOGE(TAG, "Open av io fail")
return;
} else {
LOGI(TAG, "Open av io: %s", m_path)
}
//写入头部信息
ret = avformat_write_header(m_fmt_ctx, NULL);
if (ret < 0) {
LOGE(TAG, "Write header fail")
return;
} else {
LOGI(TAG, "Write header success")
}
}
}
void Mp4Muxer::Write(AVPacket *pkt) {
int ret = av_interleaved_write_frame(m_fmt_ctx, pkt);
// uint64_t time = uint64_t (pkt->pts*av_q2d(GetTimeBase(pkt->stream_index))*1000);
// LOGE(TAG, "Write one frame pts: %lld, ret = %s", time , av_err2str(ret))
}
void Mp4Muxer::EndAudioStream() {
LOGI(TAG, "End audio stream")
m_audio_end = true;
Release();
}
void Mp4Muxer::EndVideoStream() {
LOGI(TAG, "End video stream")
m_video_end = true;
Release();
}
void Mp4Muxer::Release() {
if (m_video_end && m_audio_end) {
if (m_fmt_ctx) {
//写入文件尾部
av_write_trailer(m_fmt_ctx);
//关闭输出IO
avio_close(m_fmt_ctx->pb);
//释放资源
avformat_free_context(m_fmt_ctx);
m_fmt_ctx = NULL;
}
delete [] m_path;
LOGI(TAG, "Muxer Release")
if (m_mux_finish_cb) {
m_mux_finish_cb->OnMuxFinished();
}
}
}
六、整合调用
有了以上工具的定义和封装,加上之前的解码器和渲染器,就万事俱备,只欠东风了!
我们需要将他们整合在一起,串联起整个【解码--编辑--编码--写入MP4】流程。
定义合成器 Synthesizer
。
初始化
// Synthesizer.cpp
// 这里直接写死视频宽高了, 需要根据自己的需求动态配置
static int WIDTH = 1920;
static int HEIGHT = 1080;
Synthesizer::Synthesizer(JNIEnv *env, jstring src_path, jstring dst_path) {
// 封装器
m_mp4_muxer = new Mp4Muxer();
m_mp4_muxer->Init(env, dst_path);
m_mp4_muxer->SetMuxFinishCallback(this);
// --------------------------视频配置--------------------------
// 【视频编码器】
m_v_encoder = new VideoEncoder(env, m_mp4_muxer, WIDTH, HEIGHT);
m_v_encoder->SetStateReceiver(this);
// 【绘制器】
m_drawer_proxy = new DefDrawerProxyImpl();
VideoDrawer *drawer = new VideoDrawer();
m_drawer_proxy->AddDrawer(drawer);
// 【OpenGL 渲染器】
m_gl_render = new OpenGLRender(env, m_drawer_proxy);
// 设置离屏渲染画面宽高
m_gl_render->SetOffScreenSize(WIDTH, HEIGHT);
// 接收经过(编辑)渲染的画面数据
m_gl_render->SetPixelReceiver(this);
// 【视频解码器】
m_video_decoder = new VideoDecoder(env, src_path, true);
m_video_decoder->SetRender(drawer);
// 监听解码状态
m_video_decoder->SetStateReceiver(this);
//--------------------------音频配置--------------------------
// 【音频编码器】
m_a_encoder = new AudioEncoder(env, m_mp4_muxer);
// 监听编码状态
m_a_encoder->SetStateReceiver(this);
// 【音频解码器】
m_audio_decoder = new AudioDecoder(env, src_path, true);
// 监听解码状态
m_audio_decoder->SetStateReceiver(this);
}
可以看到,解码流程和以前几乎时一模一样的,三个不一样的地方是:
需要告诉解码器,这是合成过程,无需在解码后加入时间同步。
OpenGL 渲染是离屏渲染,需要设置渲染尺寸
音频无需渲染到 OpenSL 中,直接发送出来压入编码即可。
启动
初始化完毕后,解码器进入等待,需要外面触发进入循环解码流程。
// Synthesizer.cpp
void Synthesizer::Start() {
m_video_decoder->GoOn();
m_audio_decoder->GoOn();
}
当调用了 BaseDecoder
的 GoOn()
方法以后,整个【解码-->编码】流程将被启动。
而将它们粘合起来的,就是解码器的状态回调方法 DecodeOneFrame()
。
// Synthesizer.cpp
bool Synthesizer::DecodeOneFrame(IDecoder *decoder, OneFrame *frame) {
if (decoder == m_video_decoder) {
// 等待上一帧画面数据压入编码缓冲队列
while (m_cur_v_frame) {
av_usleep(2000); // 2ms
}
m_cur_v_frame = frame;
m_gl_render->RequestRgbaData();
return m_v_encoder->TooMuchData();
} else {
m_cur_a_frame = frame;
m_a_encoder->PushFrame(frame);
return m_a_encoder->TooMuchData();
}
}
void Synthesizer::ReceivePixel(uint8_t *rgba) {
OneFrame *rgbFrame = new OneFrame(rgba, m_cur_v_frame->line_size,
m_cur_v_frame->pts, m_cur_v_frame->time_base);
m_v_encoder->PushFrame(rgbFrame);
// 清空上一帧数据信息
m_cur_v_frame = NULL;
}
当接收到解码器的一帧数据后,
如果是音频数据,直接将数据通过
BaseDecoder
的PushFrame()
方法压入队列。如果是视频数据,将当前帧数据信息保存下来,并通知
OpenGLRender
将画面数据发送出来。在ReceivePixel()
方法中接收到画面数据后,将数据PushFrame()
到视频编码器中。
直到解码完毕,在 DecodeFinish()
方法中,压入空数据帧,通知编码器结束编码。
// Synthesizer.cpp
void Synthesizer::DecodeFinish(IDecoder *decoder) {
// 编码结束,压入一帧空数据,通知编码器结束编码
if (decoder == m_video_decoder) {
m_v_encoder->PushFrame(new OneFrame(NULL, 0, 0, AVRational{1, 25}, NULL));
} else {
m_a_encoder->PushFrame(new OneFrame(NULL, 0, 0, AVRational{1, 25}, NULL));
}
}
void Synthesizer::EncodeFinish() {
LOGI("Synthesizer", "EncodeFinish ...");
}
void Synthesizer::OnMuxFinished() {
LOGI("Synthesizer", "OnMuxFinished ...");
m_gl_render->Stop();
if (m_mp4_muxer != NULL) {
delete m_mp4_muxer;
}
m_drawer_proxy = NULL;
}
至此,整个流程就完整了!!!