最纯粹的直播技术实战03-通过filter进行旋转及卡顿修复
最新实战教程，Android自己主动化刷量、作弊与防作弊，案例：刷友盟统计、批量注冊苹果帐号
这个系列的文章将会研究最纯粹的Android直播的实现。并且不是用如今的集成SDK来达到直播的技术实现，而是从一个比較底层的直播实现来探讨这个技术，这样子对于直播技术的实现。现成的一些直播框架等都有一个比較好的理解。
上一篇文章把Camera的处理以及推流给实现了，但还留下了几个bug。这一篇文章就把一些bug处理一下。主要处理两个bug
- 直播画面颠倒
- 直播卡顿的问题
假设没有看过之前的文章的能够戳这里
首先，先把画面颠倒的问题解决先。颠倒的话。我们能够通过多种方式完毕，比方说从Camera里面获取到的NV21数据进行一个旋转的操作也能够。但这里，使用FFmpeg里的filter来完毕，顺便学习一下filter的使用
FFmpeg的filter初始化起来非常的复杂，但初始化完毕后，使用就非常的简单了。
想要了解filter的强大功能，能够看看官方文档
那么我们须要使用filter。那就须要写一个初始化函数了
/**
* 初始化filter
*/
int init_filters(const char *filters_descr) {
/**
* 注冊全部AVFilter
*/
avfilter_register_all();
char args[512];
int ret = 0;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
//为FilterGraph分配内存
filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
/**
* 要填入正确的參数
*/
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
src_width, src_height, pCodecCtx->pix_fmt,
pCodecCtx->time_base.num, pCodecCtx->time_base.den,
pCodecCtx->sample_aspect_ratio.num, pCodecCtx->sample_aspect_ratio.den);
//创建并向FilterGraph中加入一个Filter
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);
if (ret < 0) {
LOGE("Cannot create buffer source\n");
goto end;
}
//创建并向FilterGraph中加入一个Filter
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);
if (ret < 0) {
LOGE("Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
LOGE("Cannot set output pixel format\n");
goto end;
}
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
//将一串通过字符串描写叙述的Graph加入到FilterGraph中
if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr, &inputs, &outputs, NULL)) < 0) {
LOGE("parse ptr error\n");
goto end;
}
//检查FilterGraph的配置
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) {
LOGE("parse config error\n");
goto end;
}
//缓存frame。用来保存filter后的frame
new_frame = av_frame_alloc();
//uint8_t *out_buffer = (uint8_t *) av_malloc(av_image_get_buffer_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, 1));
//av_image_fill_arrays(new_frame->data, new_frame->linesize, out_buffer, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, 1);
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}能够看到filter的初始化是挺麻烦的，但初始化完毕后，仅仅须要调用两个函数就能够非常方便的使用了
//向FilterGraph中加入一个AVFrame
ret = av_buffersrc_add_frame(buffersrc_ctx, yuv_frame);
if (ret >= 0) {
//从FilterGraph中取出一个AVFrame
ret = av_buffersink_get_frame(buffersink_ctx, new_frame);
if (ret >= 0) {
ret = encode(pCodecCtx, &pkt, new_frame, &got_packet);
} else {
LOGE("Error while getting the filtergraph\n");
}
} else {
LOGE("Error while feeding the filtergraph\n");
}
所以初始化麻烦，使用起来就非常方便了。可是由于进行的旋转的操作，所以旋转后的frame的width和height就设置了，所以要对编码器的宽高进行改动。不然就无法编码成功
watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMTQ4NTUzMQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="pcodec" title="">
到这里，基本上就能够通过filter来把直播画面颠倒的问题给解决掉了。
那么就能够解决第二个问题就是直播卡顿的问题了。这个问题主要是由于pts/dts的设置问题
首先，我们要先把streamerHandle这个native方法改动一下，给它再加入一个參数，这个參数是用于设置pts的
/**
* 对每一次预览的数据进行编码推流
* @param data NV21格式的数据
* @param timestamp 用于设置pts
* @return 0成功，小于0失败
*/
private native int streamerHandle(byte[] data, long timestamp);在LiveActivity里面改动完毕后，要刻去更新一下c里面相应的方法，不然就报错了
在这里，为了提高性能，我们能够把Camera的setPreviewCallback换成setPreviewCallbackWithBuffer，这样子就能够避免预览的时候，频繁创建byte[]和频繁的GC
watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMTQ4NTUzMQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="camera" title="">
那么把LiveActivity写好之后呢，我们就须要去到native层去设置好pts
watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMTQ4NTUzMQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="pts" title="">
av_packet_rescale_ts这个函数的主要作用就是：将packet中的有效定时字段（timestamp/duration）从一个time_base转换为还有一个time_base
FFmpeg的time_base实际上就是指时间的刻度，
比方说当
time_base为{1, 30}的时候。假设pts为20，那么要变成
time_base为{1, 1000000}刻度时的pts就要进行转换(20 * 1 / 30) / (1 / 1000000)并且解码器那里有一个
time_base，编码器又有自己的time_base，所以当进行操作后。须要进行一个time_base的转换才行
设置完毕这个之后。还须要用传递进来的timestamp计算也pts，并设置好
到这里，就基本上能够把直播画面卡顿的问题给解决掉了。
完整的native代码就例如以下：
//
// Created by Administrator on 2017/2/19.
//
#include <jni.h>
#include <stdio.h>
#include <android/log.h>
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/time.h"
#include "libavutil/imgutils.h"
#include "libavfilter/avfiltergraph.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"
#include "libavutil/opt.h"
#define LOG_TAG "FFmpeg"
#define LOGE(format, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, format, ##__VA_ARGS__)
#define LOGI(format, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, format, ##__VA_ARGS__)
AVFormatContext *ofmt_ctx = NULL;
AVStream *out_stream = NULL;
AVPacket pkt;
AVCodecContext *pCodecCtx = NULL;
AVCodec *pCodec = NULL;
AVFrame *yuv_frame;
int frame_count;
int src_width;
int src_height;
int y_length;
int uv_length;
int64_t start_time;
/**
* 定义filter相关的变量
*/
const char *filter_descr = "transpose=clock"; //顺时针旋转90度的filter描写叙述
AVFilterContext *buffersink_ctx;
AVFilterContext *buffersrc_ctx;
AVFilterGraph *filter_graph;
int filterInitResult;
AVFrame *new_frame;
/**
* 回调函数。用来把FFmpeg的log写到sdcard里面
*/
void live_log(void *ptr, int level, const char* fmt, va_list vl) {
FILE *fp = fopen("/sdcard/123/live_log.txt", "a+");
if(fp) {
vfprintf(fp, fmt, vl);
fflush(fp);
fclose(fp);
}
}
/**
* 编码函数
* avcodec_encode_video2被deprecated后，自己封装的
*/
int encode(AVCodecContext *pCodecCtx, AVPacket* pPkt, AVFrame *pFrame, int *got_packet) {
int ret;
*got_packet = 0;
ret = avcodec_send_frame(pCodecCtx, pFrame);
if(ret <0 && ret != AVERROR_EOF) {
return ret;
}
ret = avcodec_receive_packet(pCodecCtx, pPkt);
if(ret < 0 && ret != AVERROR(EAGAIN)) {
return ret;
}
if(ret >= 0) {
*got_packet = 1;
}
return 0;
}
/**
* 初始化filter
*/
int init_filters(const char *filters_descr) {
/**
* 注冊全部AVFilter
*/
avfilter_register_all();
char args[512];
int ret = 0;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
//为FilterGraph分配内存
filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
/**
* 要填入正确的參数
*/
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
src_width, src_height, pCodecCtx->pix_fmt,
pCodecCtx->time_base.num, pCodecCtx->time_base.den,
pCodecCtx->sample_aspect_ratio.num, pCodecCtx->sample_aspect_ratio.den);
//创建并向FilterGraph中加入一个Filter
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);
if (ret < 0) {
LOGE("Cannot create buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);
if (ret < 0) {
LOGE("Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
LOGE("Cannot set output pixel format\n");
goto end;
}
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
//将一串通过字符串描写叙述的Graph加入到FilterGraph中
if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr, &inputs, &outputs, NULL)) < 0) {
LOGE("parse ptr error\n");
goto end;
}
//检查FilterGraph的配置
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) {
LOGE("parse config error\n");
goto end;
}
new_frame = av_frame_alloc();
//uint8_t *out_buffer = (uint8_t *) av_malloc(av_image_get_buffer_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, 1));
//av_image_fill_arrays(new_frame->data, new_frame->linesize, out_buffer, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, 1);
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
JNIEXPORT jstring JNICALL
Java_com_xiaoxiao_live_MainActivity_helloFromFFmpeg(JNIEnv *env, jobject instance) {
// TODO
char info[10000] = {0};
sprintf(info, "%s\n", avcodec_configuration());
return (*env)->NewStringUTF(env, info);
}
JNIEXPORT jint JNICALL
Java_com_xiaoxiao_live_LiveActivity_streamerRelease(JNIEnv *env, jobject instance) {
// TODO
if(pCodecCtx) {
avcodec_close(pCodecCtx);
pCodecCtx = NULL;
}
if(ofmt_ctx) {
avio_close(ofmt_ctx->pb);
}
if(ofmt_ctx) {
avformat_free_context(ofmt_ctx);
ofmt_ctx = NULL;
}
if(yuv_frame) {
av_frame_free(&yuv_frame);
yuv_frame = NULL;
}
if(filter_graph) {
avfilter_graph_free(&filter_graph);
filter_graph = NULL;
}
if(new_frame) {
av_frame_free(&new_frame);
new_frame = NULL;
}
}
JNIEXPORT jint JNICALL
Java_com_xiaoxiao_live_LiveActivity_streamerFlush(JNIEnv *env, jobject instance) {
// TODO
int ret;
int got_packet;
AVPacket packet;
if(!(pCodec->capabilities & CODEC_CAP_DELAY)) {
return 0;
}
while(1) {
packet.data = NULL;
packet.size = 0;
av_init_packet(&packet);
ret = encode(pCodecCtx, &packet, NULL, &got_packet);
if(ret < 0) {
break;
}
if(!got_packet) {
ret = 0;
break;
}
LOGI("Encode 1 frame size:%d\n", packet.size);
AVRational time_base = ofmt_ctx->streams[0]->time_base;
AVRational r_frame_rate1 = {60, 2};
AVRational time_base_q = {1, AV_TIME_BASE};
int64_t calc_duration = (double)(AV_TIME_BASE) * (1 / av_q2d(r_frame_rate1));
packet.pts = av_rescale_q(frame_count * calc_duration, time_base_q, time_base);
packet.dts = packet.pts;
packet.duration = av_rescale_q(calc_duration, time_base_q, time_base);
packet.pos = -1;
frame_count++;
ofmt_ctx->duration = packet.duration * frame_count;
ret = av_interleaved_write_frame(ofmt_ctx, &packet);
if(ret < 0) {
break;
}
}
//写文件尾
av_write_trailer(ofmt_ctx);
return 0;
}
JNIEXPORT jint JNICALL
Java_com_xiaoxiao_live_LiveActivity_streamerHandle(JNIEnv *env, jobject instance,
jbyteArray data_, jlong timestamp) {
jbyte *data = (*env)->GetByteArrayElements(env, data_, NULL);
// TODO
int ret, i, resultCode;
int got_packet = 0;
resultCode = 0;
/**
* 这里就是之前说的NV21转为AV_PIX_FMT_YUV420P这样的格式的操作了
*/
memcpy(yuv_frame->data[0], data, y_length);
for (i = 0; i < uv_length; i++) {
*(yuv_frame->data[2] + i) = *(data + y_length + i * 2);
*(yuv_frame->data[1] + i) = *(data + y_length + i * 2 + 1);
}
yuv_frame->format = pCodecCtx->pix_fmt;
yuv_frame->width = src_width;
yuv_frame->height = src_height;
//yuv_frame->pts = frame_count;
//yuv_frame->pts = (1.0 / 30) * 90 * frame_count;
yuv_frame->pts = timestamp * 30 / 1000000;
pkt.data = NULL;
pkt.size = 0;
av_init_packet(&pkt);
if (filterInitResult >= 0) {
ret = 0;
//向FilterGraph中加入一个AVFrame
ret = av_buffersrc_add_frame(buffersrc_ctx, yuv_frame);
if (ret >= 0) {
//从FilterGraph中取出一个AVFrame
ret = av_buffersink_get_frame(buffersink_ctx, new_frame);
if (ret >= 0) {
ret = encode(pCodecCtx, &pkt, new_frame, &got_packet);
} else {
LOGE("Error while getting the filtergraph\n");
}
} else {
LOGE("Error while feeding the filtergraph\n");
}
}
if(filterInitResult < 0 || ret < 0) {
LOGE("encode from yuv data");
/**
* 由于通过filter后，packet的宽高已经改变了。初始化的编码器已经无法使用了。
* 所以要兼容filter无法初始化的话，须要又一次初始化一个相应宽高的编码器
*/
//进行编码
//ret = encode(pCodecCtx, &pkt, yuv_frame, &got_packet);
}
if(ret < 0) {
resultCode = -1;
LOGE("Encode error\n");
goto end;
}
if(got_packet) {
LOGI("Encode frame: %d\tsize:%d\n", frame_count, pkt.size);
frame_count++;
pkt.stream_index = out_stream->index;
//将packet中的有效定时字段（timestamp/duration）从一个time_base转换为还有一个time_base
av_packet_rescale_ts(&pkt, pCodecCtx->time_base, out_stream->time_base);
//写PTS/DTS
/*AVRational time_base1 = ofmt_ctx->streams[0]->time_base;
AVRational r_frame_rate1 = {60, 2};
AVRational time_base_q = {1, AV_TIME_BASE};
int64_t calc_duration = (double)(AV_TIME_BASE) * (1 / av_q2d(r_frame_rate1));
pkt.pts = av_rescale_q(frame_count * calc_duration, time_base_q, time_base1);
pkt.dts = pkt.pts;
pkt.duration = av_rescale_q(calc_duration, time_base_q, time_base1);
pkt.pos = -1;
//处理延迟
int64_t pts_time = av_rescale_q(pkt.dts, time_base1, time_base_q);
int64_t now_time = av_gettime() - start_time;
if(pts_time > now_time) {
av_usleep(pts_time - now_time);
}*/
ret = av_interleaved_write_frame(ofmt_ctx, &pkt);
if(ret < 0) {
LOGE("Error muxing packet");
resultCode = -1;
goto end;
}
av_packet_unref(&pkt);
}
end:
(*env)->ReleaseByteArrayElements(env, data_, data, 0);
return resultCode;
}
JNIEXPORT jint JNICALL
Java_com_xiaoxiao_live_LiveActivity_streamerInit(JNIEnv *env, jobject instance, jint width,
jint height) {
// TODO
int ret = 0;
const char *address = "rtmp://192.168.1.102/oflaDemo/test";
src_width = width;
src_height = height;
//yuv数据格式里面的 y的大小（占用的空间）
y_length = width * height;
//u/v占用的空间大小
uv_length = y_length / 4;
//设置回调函数，写log
av_log_set_callback(live_log);
//激活全部的功能
av_register_all();
//推流就须要初始化网络协议
avformat_network_init();
//初始化AVFormatContext
avformat_alloc_output_context2(&ofmt_ctx, NULL, "flv", address);
if(!ofmt_ctx) {
LOGE("Could not create output context\n");
return -1;
}
//寻找编码器。这里用的就是x264的那个编码器了
pCodec = avcodec_find_encoder(AV_CODEC_ID_H264);
if(!pCodec) {
LOGE("Can not find encoder!\n");
return -1;
}
//初始化编码器的context
pCodecCtx = avcodec_alloc_context3(pCodec);
pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P; //指定编码格式
pCodecCtx->width = height;
pCodecCtx->height = width;
pCodecCtx->time_base.num = 1;
pCodecCtx->time_base.den = 30;
pCodecCtx->bit_rate = 800000;
pCodecCtx->gop_size = 300;
if(ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER) {
pCodecCtx->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
pCodecCtx->qmin = 10;
pCodecCtx->qmax = 51;
pCodecCtx->max_b_frames = 3;
AVDictionary *dicParams = NULL;
av_dict_set(&dicParams, "preset", "ultrafast", 0);
av_dict_set(&dicParams, "tune", "zerolatency", 0);
//打开编码器
if(avcodec_open2(pCodecCtx, pCodec, &dicParams) < 0) {
LOGE("Failed to open encoder!\n");
return -1;
}
//新建输出流
out_stream = avformat_new_stream(ofmt_ctx, pCodec);
if(!out_stream) {
LOGE("Failed allocation output stream\n");
return -1;
}
out_stream->time_base.num = 1;
out_stream->time_base.den = 30;
//复制一份编码器的配置给输出流
avcodec_parameters_from_context(out_stream->codecpar, pCodecCtx);
//打开输出流
ret = avio_open(&ofmt_ctx->pb, address, AVIO_FLAG_WRITE);
if(ret < 0) {
LOGE("Could not open output URL %s", address);
return -1;
}
ret = avformat_write_header(ofmt_ctx, NULL);
if(ret < 0) {
LOGE("Error occurred when open output URL\n");
return -1;
}
//初始化一个帧的数据结构，用于编码用
//指定AV_PIX_FMT_YUV420P这样的格式的
yuv_frame = av_frame_alloc();
uint8_t *out_buffer = (uint8_t *) av_malloc(av_image_get_buffer_size(pCodecCtx->pix_fmt, src_width, src_height, 1));
av_image_fill_arrays(yuv_frame->data, yuv_frame->linesize, out_buffer, pCodecCtx->pix_fmt, src_width, src_height, 1);
start_time = av_gettime();
/**
* 初始化filter
*/
filterInitResult = init_filters(filter_descr);
if(filterInitResult < 0) {
LOGE("Filter init error");
}
return 0;
}总结
那么，到这里就能够把上面说的两个问题给解决掉了。但还是有一定的延迟（还在找原因），并且当摄像头切换成前摄像头的时候，会发现画面还是颠倒的，由于前摄像头须要顺时针旋转270度才行的，那么这时候就会发现filter在处理这个旋转的时候有点局限性了。由于filter初始化太麻烦了。所以用filter来解决这个直播画面颠倒的问题有点麻烦。所以就须要使用另外的方法来解决问题了。
那么就应该在编码前就把预览的数据给旋转过来。为了以后兴许的扩展，比方说加上美颜功能这些。那就须要在预览前就要对数据进行改动再预览，那就SurfaceView就无法满足这个要求那就须要须要TextureView或GLSurfaceView了。这两个都能够在预览前拿到数据，再自己绘制出来的。GLSurfaceView功能更加强大。所以就能够使用它了
所以如今还有的问题就是：
- 使用GLSurfaceView解决前后摄像头直播画面颠倒的问题
- 加入声音
- 降低延迟
- 兴许功能加入
这些问题都须要兴许解决的，所下面一篇文章就使用GLSurfaceView来取代filter解决直播画面颠倒的问题