《Android音视频系列-6》FFmpeg视频文件推流
2019-08-23 本文已影响0人
蓝师傅_Android
阅读本文需要一点JNI基础~
通过本文可以学到如下知识：
- JNI 回调封装
- 视频推流大概流程
如果还没搭建直播服务器，看上一篇文章
搭建直播服务器Nginx+rtmp，如此简单(mac)
上一篇直播服务器搭建好了，也测试推流拉流都是成功的，这一篇将在手机上将一个mp4文件推流到服务器，然后可以通过拉流软件看直播。
1、cmake 配置
# 需要引入我们头文件,以这个配置的目录为基准
include_directories(src/main/jniLibs/include)
# 添加共享库（so）搜索路径
LINK_DIRECTORIES(${CMAKE_SOURCE_DIR}/src/main/jniLibs/armeabi)
AUX_SOURCE_DIRECTORY(${CMAKE_SOURCE_DIR}/src/main/cpp/push PUSH_SRC_LIST)
add_library(
# 编译生成的库的名称叫 push_handle，对应System.loadLibrary("push_handle");
push_handle
# Sets the library as a shared library.
SHARED
# Provides a relative path to your source file(s).
${PUSH_SRC_LIST}
)
target_link_libraries(
push_handle
# 编解码(最重要的库)
avcodec-57
# 设备信息
avdevice-57
# 滤镜特效处理库
avfilter-6
# 封装格式处理库
avformat-57
# 工具库(大部分库都需要这个库的支持)
avutil-55
# 后期处理
postproc-54
# 音频采样数据格式转换库
swresample-2
# 视频像素数据格式转换
swscale-4
# 链接 android ndk 自带的一些库
android
# Links the target library to the log library
# included in the NDK.
# 链接 OpenSLES
OpenSLES
log)
最终生成的so叫 libpush_handle.so
FFmpeg的so跟include文件如下，跟之前的文章一样。
2、Java层推流管理类
public class PushHandle {
static {
System.loadLibrary("push_handle");
}
private PushCallback pushCallback;
public void setCallback(PushCallback pushCallback) {
this.pushCallback = pushCallback;
}
public native int nPushRtmpFile(String filePath, String rtmp_url);
public native int nStopPush();
/**native回调*/
private void onInfo(long pts, long dts, long duration, long index) {
if (pushCallback != null) {
pushCallback.onInfo(pts, dts, duration, index);
}
}
private void onError(int code, String msg) {
if (pushCallback != null) {
pushCallback.onError(code, msg);
}
}
private void onPushComplete() {
if (pushCallback != null) {
pushCallback.onPushComplete();
}
}
}
public native int nPushRtmpFile(String filePath, String rtmp_url); 推流方法就传一个视频文件路径和推流地址，然后就等回调
回调比较简单
public interface PushCallback {
//回调推流每一帧信息
void onInfo(long pts, long dts, long duration, long index);
//错误回调
void onError(int code, String msg);
//推流完成
void onPushComplete();
}
3、Native层
在/src/main/cpp/push目录下定义一个 PushHandle.cpp的c++文件，
然后同步一下，鼠标依次放在PushHandle.java 的 两个native方法上，按 option+enter（win 是alt+enter），自动生成对应的native方法实现，然后就开始写c++代码了。
3.1 JNI回调封装
在当前文件目录新建一个c++ file，名字就叫 PushJniCall，
然后会生成对应的PushJniCall.h头文件和PushJniCall.cpp文件
PushJniCall.h
#ifndef FFMPEGDEMO_PUSHJNICALL_H
#define FFMPEGDEMO_PUSHJNICALL_H
#include <jni.h>
class PushJniCall {
public:
JNIEnv *jniEnv;
//定义java的对象和方法id，在cpp构造函数赋值
jobject jPushCallbackObj;
jmethodID jOnErrorMid;
jmethodID jOnInfoMid;
jmethodID jOnPushCompleteMid;
public:
PushJniCall(JNIEnv *jniEnv,jobject jPushCallbackObj);
~PushJniCall();
public:
//定义回调方法，在cpp实现
void callOnError(int code, char *msg);
void callOnPushComplete();
void callOnInfo(int64_t pts, int64_t dts, int64_t duration, long long index);
};
#endif //FFMPEGDEMO_PUSHJNICALL_H
实现类 PushJniCall.cpp
#include "PushJniCall.h"
PushJniCall::PushJniCall(JNIEnv *jniEnv, jobject jPushCallbackObj) {
this->jniEnv = jniEnv;
//需要创建一个全局应用
this->jPushCallbackObj = jniEnv->NewGlobalRef(jPushCallbackObj);
jclass cls = jniEnv->GetObjectClass(jPushCallbackObj);
//获取方法id
jOnInfoMid = jniEnv->GetMethodID(cls, "onInfo", "(JJJJ)V");
jOnErrorMid = jniEnv->GetMethodID(cls, "onError", "(ILjava/lang/String;)V");
jOnPushCompleteMid = jniEnv->GetMethodID(cls, "onPushComplete", "()V");
}
PushJniCall::~PushJniCall() {
jniEnv->DeleteGlobalRef(jPushCallbackObj);
}
void PushJniCall::callOnError(int code, char *msg) {
//C中的char*转化为JNI中的jstring
jniEnv->CallVoidMethod(jPushCallbackObj, jOnErrorMid, code, msg);
}
void PushJniCall::callOnPushComplete() {
jniEnv->CallVoidMethod(jPushCallbackObj, jOnPushCompleteMid);
}
void PushJniCall::callOnInfo(int64_t pts, int64_t dts, int64_t duration, long long index) {
jniEnv->CallVoidMethod(jPushCallbackObj, jOnInfoMid, (jlong) pts, (jlong) dts,
(jlong) duration, (jlong) index);
}
这些属于JNI基础，应该能看懂，看不懂就去找一篇JNI基础文章看下就行。
[传送门]
3.2 推流核心代码
PushHandle.cpp
推流代码参考文末链接，加了一些注释
#include <jni.h>
#include "PushJniCall.h"
#include "PushStatus.h"
#include "log.h"
//ffmpeg 是c写的，要用c的include
extern "C" {
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
//引入时间
#include "libavutil/time.h"
};
#include <iostream>
using namespace std;
//JNI回调处理
PushJniCall *pushJniCall;
//状态处理
PushStatus *pushStatus;
int avError(int errNum) {
char buf[1024];
//获取错误信息
av_strerror(errNum, buf, sizeof(buf));
LOGE("发生异常：%s",buf);
if (pushJniCall != NULL) {
pushJniCall->callOnError(errNum, buf);
}
return errNum;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_lanshifu_ffmpegdemo_push_PushHandle_nPushRtmpFile(JNIEnv *env, jobject instance,
jstring path_, jstring rtmp_url) {
pushJniCall = new PushJniCall(env, instance);
pushStatus = new PushStatus();
const char *inUrl = env->GetStringUTFChars(path_, 0);
const char *outUrl = env->GetStringUTFChars(rtmp_url, 0);
LOGW("nPushRtmpFile,inUrl = %s", inUrl);
LOGW("nPushRtmpFile,outUrl = %s", outUrl);
int videoindex = -1;
/// 1.使用FFmpeg之前要调用av_register_all和avformat_network_init
//初始化所有的封装和解封装 flv mp4 mp3 mov。不包含编码和解码
av_register_all();
//初始化网络库
avformat_network_init();
//////////////////////////////////////////////////////////////////
// 输入流处理部分
/////////////////////////////////////////////////////////////////
//输入封装的上下文。包含所有的格式内容和所有的IO。如果是文件就是文件IO，网络就对应网络IO
AVFormatContext *ictx = NULL;
AVFormatContext *octx = NULL;
AVPacket pkt;
int ret = 0;
try {
///2.打开文件，解封文件头
ret = avformat_open_input(&ictx, inUrl, 0, NULL);
if (ret < 0) {
avError(ret);
throw ret;
}
LOGD("avformat_open_input success!");
///3.获取音频视频的信息 .h264 flv 没有头信息
ret = avformat_find_stream_info(ictx, 0);
if (ret != 0) {
avError(ret);
throw ret;
}
LOGD("avformat_find_stream_info success!");
av_dump_format(ictx, 0, inUrl, 0);
//////////////////////////////////////////////////////////////////
// 输出流处理部分
/////////////////////////////////////////////////////////////////
/// 4.创建输出上下文,如果是输入文件 flv可以不传，可以从文件中判断。如果是流则必须传
ret = avformat_alloc_output_context2(&octx, NULL, "flv", outUrl);
if (ret < 0) {
avError(ret);
throw ret;
}
LOGD("avformat_alloc_output_context2 success!");
///遍历输入流列表，一般有音频流和视频流，为输出内容添加音视频流
for (int i = 0; i < ictx->nb_streams; i++) {
//获取输入视频流，可能是音频流，视频流？
AVStream *in_stream = ictx->streams[i];
///为输出内容添加一个音视频流，格式什么的跟输入流保持一致。
AVStream *out_stream = avformat_new_stream(octx, in_stream->codec->codec);
LOGD("avformat_new_stream %d, success!", i);
if (!out_stream) {
LOGE("未能成功添加音视频流 %d", i);
ret = AVERROR_UNKNOWN;
throw ret;
}
//这个不知道有什么用，注释掉吧，不影响结果
// if (octx->oformat->flags & AVFMT_GLOBALHEADER) {
// out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
// }
/// 输入流参数拷贝到输出流
ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
if (ret < 0) {
LOGD("copy 编解码器上下文失败\n");
}
out_stream->codecpar->codec_tag = 0;
///记录视频流的位置
if (videoindex == -1 && ictx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
videoindex = i;
LOGD("找到视频流的位置 %d,", videoindex);
}
}
//打印输出的格式信息
av_dump_format(octx, 0, outUrl, 1);
LOGD("准备推流...");
//////////////////////////////////////////////////////////////////
// 准备推流
/////////////////////////////////////////////////////////////////
///打开IO
ret = avio_open(&octx->pb, outUrl, AVIO_FLAG_READ_WRITE);
// todo :Linux服务器地址报错 IO error,本地服务器不会
if (ret < 0) {
avError(ret);
throw ret;
}
LOGD("打开IO avio_open success!");
///写入头部信息
ret = avformat_write_header(octx, 0);
if (ret < 0) {
avError(ret);
throw ret;
}
LOGD("写入头部信息 avformat_write_header Success!");
//推流每一帧数据
//int64_t pts [ pts*(num/den) 第几秒显示]
//int64_t dts 解码时间 [P帧(相对于上一帧的变化) I帧(关键帧，完整的数据) B帧(上一帧和下一帧的变化)] 有了B帧压缩率更高。
//获取当前的时间戳 微妙
long long start_time = av_gettime();
long long frame_index = 0;
LOGD("开始推流 >>>>>>>>>>>>>>>");
while (!pushStatus->isExit) {
//输入输出视频流
AVStream *in_stream, *out_stream;
///不断读取每一帧数据
ret = av_read_frame(ictx, &pkt);
if (ret < 0) {
//数据读完，播放完成
break;
}
/*
PTS（Presentation Time Stamp）显示播放时间
DTS（Decoding Time Stamp）解码时间
*/
//没有显示时间（比如未解码的 H.264 ）
if (pkt.pts == AV_NOPTS_VALUE) {
//AVRational time_base：时基。通过该值可以把PTS，DTS转化为真正的时间。
AVRational time_base1 = ictx->streams[videoindex]->time_base;
//计算两帧之间的时间
/*
r_frame_rate 基流帧速率 （不是太懂，先知道流程就行）
av_q2d 转化为double类型
*/
int64_t calc_duration = (double) AV_TIME_BASE / av_q2d(ictx->streams[videoindex]->r_frame_rate);
//配置参数
pkt.pts = (double) (frame_index * calc_duration) / (double) (av_q2d(time_base1) * AV_TIME_BASE);
pkt.dts = pkt.pts;
pkt.duration = (double) calc_duration / (double) (av_q2d(time_base1) * AV_TIME_BASE);
}
///通过睡眠的方式保持播放时间同步
if (pkt.stream_index == videoindex) {
AVRational time_base = ictx->streams[videoindex]->time_base;
AVRational time_base_q = {1, AV_TIME_BASE};
//计算视频播放时间，比如在11s播放
int64_t pts_time = av_rescale_q(pkt.dts, time_base, time_base_q);
//计算实际视频的播放时间，比如已经播放了10s
int64_t now_time = av_gettime() - start_time;
if (pts_time > now_time) {
//睡眠一段时间（目的是让当前视频记录的播放时间与实际时间同步）
av_usleep((unsigned int) (pts_time - now_time));
}
}
//输入输出视频流赋值
in_stream = ictx->streams[pkt.stream_index];
out_stream = octx->streams[pkt.stream_index];
//计算延时后，重新指定时间戳，调函数即可
pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base,
(AVRounding) (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base,
(AVRounding) (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
pkt.duration = (int) av_rescale_q(pkt.duration, in_stream->time_base,out_stream->time_base);
//字节流的位置，-1 表示不知道字节流位置
pkt.pos = -1;
if (pkt.stream_index == videoindex) {
//当前视频帧数
frame_index++;
}
//回调数据
if (pushJniCall != NULL) {
pushJniCall->callOnInfo(pkt.pts, pkt.dts, pkt.duration, frame_index);
}
///把一帧数据写到输出流（推流）
ret = av_interleaved_write_frame(octx, &pkt);
if (ret < 0) {
LOGE("推流失败 ret=%d",ret);
break;
}
}
ret = 0;
} catch (int errNum) {
if (pushJniCall != NULL) {
pushJniCall->callOnError(errNum, const_cast<char *>("出错了"));
}
}
if (pushJniCall != NULL) {
pushJniCall->callOnPushComplete();
}
LOGD("推流结束》》》");
//关闭资源
if (octx != NULL){
avio_close(octx->pb);
octx = NULL;
}
//释放输出封装上下文
if (octx != NULL) {
avformat_free_context(octx);
}
//关闭输入上下文
if (ictx != NULL) {
avformat_close_input(&ictx);
ictx = NULL;
}
//释放
av_packet_unref(&pkt);
env->ReleaseStringUTFChars(path_, outUrl);
return ret;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_lanshifu_ffmpegdemo_push_PushHandle_nStopPush(JNIEnv *env, jobject instance) {
LOGD("nStopPush");
if (pushStatus != NULL){
pushStatus->isExit = true;
}
}
其中，日志封装了一个 log.h，如下
#ifndef _LOG_H
#define _LOG_H
#define LOGN (void) 0
#ifndef WIN32
#include <android/log.h>
#define LOG_VERBOSE 1
#define LOG_DEBUG 2
#define LOG_INFO 3
#define LOG_WARNING 4
#define LOG_ERROR 5
#define LOG_FATAL 6
#define LOG_SILENT 7
#ifndef LOG_TAG
//#define LOG_TAG __FILE__
#define LOG_TAG "JNI_TAG"
#endif
#ifndef LOG_LEVEL
#define LOG_LEVEL LOG_VERBOSE
#endif
#define LOGP(level, fmt, ...) \
__android_log_print(level, LOG_TAG, "%s:" fmt, \
__PRETTY_FUNCTION__, ##__VA_ARGS__)
#if LOG_VERBOSE >= LOG_LEVEL
#define LOGV(fmt, ...) \
LOGP(ANDROID_LOG_VERBOSE, fmt, ##__VA_ARGS__)
#else
#define LOGV(...) LOGN
#endif
#if LOG_DEBUG >= LOG_LEVEL
#define LOGD(fmt, ...) \
LOGP(ANDROID_LOG_DEBUG, fmt, ##__VA_ARGS__)
#else
#define LOGD(...) LOGN
#endif
#if LOG_INFO >= LOG_LEVEL
#define LOGI(fmt, ...) \
LOGP(ANDROID_LOG_INFO, fmt, ##__VA_ARGS__)
#else
#define LOGI(...) LOGN
#endif
#if LOG_WARNING >= LOG_LEVEL
#define LOGW(fmt, ...) \
LOGP(ANDROID_LOG_WARN, fmt, ##__VA_ARGS__)
#else
#define LOGW(...) LOGN
#endif
#if LOG_ERROR >= LOG_LEVEL
#define LOGE(fmt, ...) \
LOGP(ANDROID_LOG_ERROR, fmt, ##__VA_ARGS__)
#else
#define LOGE(...) LOGN
#endif
#if LOG_FATAL >= LOG_LEVEL
#define LOGF(fmt, ...) \
LOGP(ANDROID_LOG_FATAL, fmt, ##__VA_ARGS__)
#else
#define LOGF(...) LOGN
#endif
#if LOG_FATAL >= LOG_LEVEL
#define LOGA(condition, fmt, ...) \
if (!(condition)) \
{ \
__android_log_assert(condition, LOG_TAG, "(%s:%u) %s: error:%s " fmt, \
__FILE__, __LINE__, __PRETTY_FUNCTION__, condition, ##__VA_ARGS__); \
}
#else
#define LOGA(...) LOGN
#endif
#else
#include <stdio.h>
#define LOGP(fmt, ...) printf("%s line:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
#define LOGV(fmt, ...) LOGP(fmt, ##__VA_ARGS__)
#define LOGD(fmt, ...) LOGP(fmt, ##__VA_ARGS__)
#define LOGI(fmt, ...) LOGP(fmt, ##__VA_ARGS__)
#define LOGW(fmt, ...) LOGP(fmt, ##__VA_ARGS__)
#define LOGE(fmt, ...) LOGP(fmt, ##__VA_ARGS__)
#define LOGF(fmt, ...) LOGP(fmt, ##__VA_ARGS__)
#define LOGA(...) LOGN
#endif // ANDROID_PROJECT
#endif // _LOG_H
PushStatus 主要是管理状态，比如退出的时候要取消推流，将标志位改成true
PushStatus.h
#ifndef FFMPEGDEMO_PLAYERSTATUS_H
#define FFMPEGDEMO_PLAYERSTATUS_H
class PushStatus {
public:
/**
* 是否退出，打算用这个变量来做退出(销毁)
*/
bool isExit = false;
};
#endif //FFMPEGDEMO_PLAYERSTATUS_H
PushStatus.cpp
#include "PushStatus.h"
最终Activity中调用
点击推流按钮开个子线程执行
private void filePushRunable() {
mPushHandle = new PushHandle();
mPushHandle.setCallback(new PushCallback() {
@Override
public void onInfo(final long pts, final long dts, final long duration, final long index) {
runOnUiThread(new Runnable() {
@Override
public void run() {
StringBuilder sb = new StringBuilder();
sb.append("pts: ").append(pts).append("\n");
sb.append("dts: ").append(dts).append("\n");
sb.append("duration: ").append(duration).append("\n");
sb.append("index: ").append(index).append("\n");
tvPushInfo.setText(sb.toString());
}
});
}
@Override
public void onError(final int code, final String msg) {
runOnUiThread(new Runnable() {
@Override
public void run() {
tvPushInfo.setText("失败，code=" + code + ",msg=" + msg);
}
});
}
@Override
public void onPushComplete() {
runOnUiThread(new Runnable() {
@Override
public void run() {
tvPushInfo.setText("推流完成");
}
});
}
});
String videoPath = "/sdcard/input1.mp4";
mPushHandle.nPushRtmpFile(videoPath, "rtmp://192.168.43.144:1935/test/live");
}
打印日志
可以看到推流是成功的，拉流试试
嗯，是成功的，2019 AG超玩会回归了，中单老帅认识吧，哈哈。
总结一下推流的大概流程：
- 打开输入文件，解封文件头，
avformat_open_input - 获取输入音视频文件的信息
avformat_find_stream_info - 创建输出流上下文
avformat_alloc_output_context2 - 添加音视频流
avformat_new_stream - 输入流参数拷贝到输出流
avcodec_parameters_copy - 打开推流地址
avio_open - 写入头部信息
avformat_write_header - 不断读取输入视频文件的每一帧
av_read_frame - 没有显示时间的帧添加时间
- 同步视频记录的时间和实际播放时间
- 更正时间戳
- 推流
av_interleaved_write_frame
代码中可能有些不太好理解，没关系，只要这个流程清楚了就行，后面文章再深入一点理解FFmpeg。
下一篇介绍摄像头推流，可以结合OpenGL，添加滤镜和水印，应该会比较有意思。
