最纯粹的直播技术实战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就设置了，所以要对编码器的宽高进行改动。不然就无法编码成功

到这里，基本上就能够通过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

那么把LiveActivity写好之后呢，我们就须要去到native层去设置好pts

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解决直播画面颠倒的问题

资源下载