Android平台下使用FFmpeg进行RTMP推流(摄像头推流)

1字数 2873阅读 13201

简介

前面讲到了在Android平台下使用FFmpeg进行RTMP推流(视频文件推流),里面主要是介绍如何解析视频文件并进行推流,今天要给大家介绍如何在Android平台下获取采集的图像,并进行编码推流。同时项目工程也是在之前的代码基础上新增功能。源码仓库地址FFmpegSample,这一节对应的代码版本是v1.2。大家注意不要下载错了版本。主要涉及的代码。

QQ截图20171124114855.png

建议:这套代码和讲解中,有些地方我也还没研究透彻,但这个不影响我们要实现的功能,我之前也特别纠结一些细节,花了很多的时间。其实学习一门技术和框架是一个慢慢深入的过程,刚开始我们先跑起来,再深入,否则如果你还没入门,就开始纠结一些细节参数,然后又发现网上很难找到答案,那你的自信心就会受到打击,这也是我自己的体验,和大家分享一下。等到我们越来越熟悉FFmpeg和一些技术,那么之前的问题都会迎刃而解

这套代码我在4.4.2上运行时没问题的。所以如果有同学在5.0以上,如果涉及动态权限问题,大家加上即可。学习本章之前最好先看之前的文章,这里是一套连贯的教程

打开摄像头并设置参数

具体代码查看CameraActivity.java

    private Camera getCamera() {
        Camera camera;
        try {
            //打开相机,默认为后置,可以根据摄像头ID来指定打开前置还是后置
            camera = Camera.open(1);
            if (camera != null && !isPreview) {
                try {
                    Camera.Parameters parameters = camera.getParameters();
                    //对拍照参数进行设置
                    for (Camera.Size size : parameters.getSupportedPictureSizes()) {
                        LogUtils.d(size.width + "  " + size.height);
                    }
                    LogUtils.d("============");
                    for (Camera.Size size : parameters.getSupportedPreviewSizes()) {
                        LogUtils.d(size.width + "  " + size.height);
                    }
                    parameters.setPreviewSize(screenWidth, screenHeight); // 设置预览照片的大小
                    parameters.setPreviewFpsRange(30000, 30000);
                    parameters.setPictureFormat(ImageFormat.NV21); // 设置图片格式
                    parameters.setPictureSize(screenWidth, screenHeight); // 设置照片的大小
                    camera.setParameters(parameters);
                    //指定使用哪个SurfaceView来显示预览图片
                    camera.setPreviewDisplay(sv.getHolder()); // 通过SurfaceView显示取景画面
                    camera.setPreviewCallback(new StreamIt()); // 设置回调的类
                    camera.startPreview(); // 开始预览
                    //Camera.takePicture()方法进行拍照
                    camera.autoFocus(null); // 自动对焦
                } catch (Exception e) {
                    e.printStackTrace();
                }
                isPreview = true;
            }
        } catch (Exception e) {
            camera = null;
            e.printStackTrace();
            Toast.makeText(this, "无法获取前置摄像头", Toast.LENGTH_LONG);
        }
        return camera;
    }

Camera.open(int cameraId)

这里是创建一个Camera对象对应具体的硬件摄像头,如果摄像头已经被其他app打开,就会抛出RuntimeException异常。

cameraId是camera的Id。我们可以通过getNumberOfCameras()

获取摄像头的数量,那id的范围就是0~(getNumberOfCameras()-1)。一般情况下传0就直接获取到后置摄像头,1就获取到前置摄像头。当然有些设备可能有些不同。

Camera.Parameters

这个类用于存储和设置摄像头的参数信息,当然Camera有很多默认参数,所以我们只需要通过camera.getParameters()获取该对象,然后并设置我们需要修改的属性即可。我们看一些常见的属性设置

  • setPreviewSize

    设置预览图像的大小

  • setPictureSize

    设置照片的大小

  • setPreviewFpsRange

    设置Fps,帧率。但我发现并没有什么卵用。每次修改后采集的频率还是没变,擦!

  • setPictureFormat

    设置采集到图像的像素格式,Android推荐NV21。那我们就用这个,这个参数很重要,后面编码我们会详细讲解。

最后不要忘了调用setParameters进行设置。否则你就白忙活了。

预览和获取采集图像数据

预览

第一个问题,用什么来承载预览图像。Android提供了SurfaceView和GLSurfaceView。这里为了方便大家上手,我们先选择使用SurfaceView稍微简单一点,对SurfaceView大家不熟的可以查找相关资料。接下来就是使用SurfaceView

  • 布局中添加SurfaceView。这里我做了一个继承类MySurfaceView

        <com.wangheart.rtmpfile.MySurfaceView
            android:id="@+id/sv"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    
  • 获取SurfaceHolder并设置回调

    SurfaceView里有一个SurfaceHolder用来控制SurfaceView的相关操作。比如设置SurfaceView的Callback,用来监听SurfaceView的创建,变化和销毁。这里只需要实现SurfaceHolder.Callback的接口

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            setStartPreview(mCamera, mHolder);
        }
    
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            setStartPreview(mCamera, mHolder);
        }
    
        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            releaseCamera();
        }
    

    然后设置到SurfaceHolder中mHolder.addCallback(this)

  • SurfaceView与Camera关联

    因为我们要讲图像预览到SurfaceView上,那么必定有地方存在关联。这里很简单,就是调用Camera的setPreviewDisplay,将SurfaceView的SurfaceHolder设置进去即可。

  • 开始预览

    直接调用camera的startPreview开始进行预览。那么什么时候调用这个方法呢?

    1. 设置一个按钮,点击之后我们就调用这个方法进行预览
    2. SurfaceView的创建回调方法中surfaceCreated中进行调用,因为图像要预览到SurfaceView中,所以必须得SurfaceView已成功创建。

获取采集数据

前面我们已经知道怎么预览图像了。接下来就是获取采集数据。这个也很容易就是调用Camera的setPreviewCallback设置预览回调。我们实现一下这个接口

    public class StreamIt implements Camera.PreviewCallback {
        @Override
        public void onPreviewFrame(final byte[] data, Camera camera) {
            long endTime = System.currentTimeMillis();
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    encodeTime = System.currentTimeMillis();
                    FFmpegHandle.getInstance().onFrameCallback(data);
                    LogUtils.w("编码第:" + (encodeCount++) + "帧,耗时:" + (System.currentTimeMillis() - encodeTime));
                }
            });
            LogUtils.d("采集第:" + (++count) + "帧,距上一帧间隔时间:"
                    + (endTime - previewTime) + "  " + Thread.currentThread().getName());
            previewTime = endTime;
        }
    }

很简单,这个接口就是讲原始数据进行回调。这里大家也看到了,我把采集的时间间隔和编码消耗的时间打印出来了。

编码

前面把基础的如何采集摄像头数据讲了一下,接下来就是进行视频数据编码。

开启线程编码

因为编码毕竟会比较耗时,所以我们需要放到线程中处理,这里我用了一个单线程池,避免每次开启和销毁线程产生的开销。为了保证图片按顺序编码,这里使用单线程池。

ExecutorService executor = Executors.newSingleThreadExecutor();

获取到采集的数据后就可以丢进去进行编码

executor.execute(new Runnable() {
    @Override
    public void run() {
        encodeTime = System.currentTimeMillis();
        FFmpegHandle.getInstance().onFrameCallback(data);
        LogUtils.w("编码第:" + (encodeCount++) + "帧,耗时:" + (System.currentTimeMillis() - encodeTime));
    }
});

这里大家也看出来了调用FFmpegHandle.getInstance().onFrameCallback(data);进行编码。

初始化编码相关操作

这里我们使用的是FFmpeg,所以在编码前我们会先做一些初始化以及参数设置工作,所以我们在FFmpegHandle中增加一个native方法public native int initVideo(String url);

对应到C++层,也就是ffmpeg_handle.cpp

AVFormatContext *ofmt_ctx;
AVStream *video_st;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVPacket enc_pkt;
AVFrame *pFrameYUV;
int count = 0;
int yuv_width;
int yuv_height;
int y_length;
int uv_length;
int width = 480;
int height = 320;
int fps = 15;
/**
 * 初始化
 */
extern "C"
JNIEXPORT jint JNICALL
Java_com_wangheart_rtmpfile_ffmpeg_FFmpegHandle_initVideo(JNIEnv *env, jobject instance,
                                                          jstring url_) {
    const char *out_path = env->GetStringUTFChars(url_, 0);
    logd(out_path);

    //计算yuv数据的长度
    yuv_width = width;
    yuv_height = height;
    y_length = width * height;
    uv_length = width * height / 4;

    av_register_all();

    //output initialize
    avformat_alloc_output_context2(&ofmt_ctx, NULL, "flv", out_path);
    //output encoder initialize
    pCodec = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (!pCodec) {
        loge("Can not find encoder!\n");
        return -1;
    }
    pCodecCtx = avcodec_alloc_context3(pCodec);
    //编码器的ID号,这里为264编码器,可以根据video_st里的codecID 参数赋值
    pCodecCtx->codec_id = pCodec->id;
    //像素的格式,也就是说采用什么样的色彩空间来表明一个像素点
    pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
    //编码器编码的数据类型
    pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    //编码目标的视频帧大小,以像素为单位
    pCodecCtx->width = width;
    pCodecCtx->height = height;
    pCodecCtx->framerate = (AVRational) {fps, 1};
    //帧率的基本单位,我们用分数来表示,
    pCodecCtx->time_base = (AVRational) {1, fps};
    //目标的码率,即采样的码率;显然,采样码率越大,视频大小越大
    pCodecCtx->bit_rate = 400000;
    //固定允许的码率误差,数值越大,视频越小
//    pCodecCtx->bit_rate_tolerance = 4000000;
    pCodecCtx->gop_size = 50;
    /* Some formats want stream headers to be separate. */
    if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
        pCodecCtx->flags |= CODEC_FLAG_GLOBAL_HEADER;

    //H264 codec param
//    pCodecCtx->me_range = 16;
    //pCodecCtx->max_qdiff = 4;
    pCodecCtx->qcompress = 0.6;
    //最大和最小量化系数
    pCodecCtx->qmin = 10;
    pCodecCtx->qmax = 51;
    //Optional Param
    //两个非B帧之间允许出现多少个B帧数
    //设置0表示不使用B帧
    //b 帧越多,图片越小
    pCodecCtx->max_b_frames = 0;
    // Set H264 preset and tune
    AVDictionary *param = 0;
    //H.264
    if (pCodecCtx->codec_id == AV_CODEC_ID_H264) {
//        av_dict_set(&param, "preset", "slow", 0);
        /**
         * 这个非常重要,如果不设置延时非常的大
         * ultrafast,superfast, veryfast, faster, fast, medium
         * slow, slower, veryslow, placebo. 这是x264编码速度的选项
       */
        av_dict_set(&param, "preset", "superfast", 0);
        av_dict_set(&param, "tune", "zerolatency", 0);
    }

    if (avcodec_open2(pCodecCtx, pCodec, &param) < 0) {
        loge("Failed to open encoder!\n");
        return -1;
    }

    //Add a new stream to output,should be called by the user before avformat_write_header() for muxing
    video_st = avformat_new_stream(ofmt_ctx, pCodec);
    if (video_st == NULL) {
        return -1;
    }
    video_st->time_base.num = 1;
    video_st->time_base.den = fps;
//    video_st->codec = pCodecCtx;
    video_st->codecpar->codec_tag = 0;
    avcodec_parameters_from_context(video_st->codecpar, pCodecCtx);

    //Open output URL,set before avformat_write_header() for muxing
    if (avio_open(&ofmt_ctx->pb, out_path, AVIO_FLAG_READ_WRITE) < 0) {
        loge("Failed to open output file!\n");
        return -1;
    }

    //Write File Header
    avformat_write_header(ofmt_ctx, NULL);

    return 0;
}

首先需要声明一些全局的变量,方便后面编码使用AVFormatContext、AVStream等。

  • 进行FFmpeg初始化

    这个和之前讲到的一样av_register_all()

  • 创建输出格式上下文

    avformat_alloc_output_context2这些之前都讲到过,就不错累述

  • 获取编码器

    pCodec = avcodec_find_encoder(AV_CODEC_ID_H264)获取编码器。这里我们使用H264进行视频编码。如果编码器获取失败就没有下文了

  • 创建编码器上下文

    pCodecCtx = avcodec_alloc_context3(pCodec)

  • 设置编码器参数

    这些参数我个参数的设置上都有加注释,大家查看即可。同时参考音视频编码相关名词详解。这讲几个主要的参数

    • pix_fmt 像素的格式这里我们使用的AV_PIX_FMT_YUV420P,也就是YUV平面格式,三个平面分别存放Y、U、V数据。
    • codec_type 编码器编码的数据类型
    • framerate 帧率
    • time_base 帧率的基本单位
    • gop_size GOP的大小
  • AVDictionary设置

    • 前面讲了一些常规参数的设置,这里还有一些重要参数设置

          if (pCodecCtx->codec_id == AV_CODEC_ID_H264) {
      //        av_dict_set(&param, "preset", "slow", 0);
              /**
               * 这个非常重要,如果不设置延时非常的大
               * ultrafast,superfast, veryfast, faster, fast, medium
               * slow, slower, veryslow, placebo. 这是x264编码速度的选项
             */
              av_dict_set(&param, "preset", "superfast", 0);
              av_dict_set(&param, "tune", "zerolatency", 0);
          }
      

      一定要注意preset这个参数的设置。否则你会发现你编码的延迟特别大,网上有许多朋友遇到这个问题。

  • 使用给定的编码器和参数初始化编码上下文

    avcodec_open2(pCodecCtx, pCodec, &param)

  • 创建视频流

    video_st = avformat_new_stream(ofmt_ctx, pCodec)这个就和之前的推文件流一样了。创建并设置相关的参数

  • 打开输出上下文

    avio_open(&ofmt_ctx->pb, out_path, AVIO_FLAG_READ_WRITE)

  • 写入输出头信息

    avformat_write_header(ofmt_ctx, NULL)

开始编码

在获取到采集的时候后我们通过线程池调用执行了FFmpegHandle.getInstance().onFrameCallback(mData);接下来我们重点看到onFrameCallback方法。当然这也是一个navive方法。我们看到c++层的实现。

Java_com_wangheart_rtmpfile_ffmpeg_FFmpegHandle_onFrameCallback(JNIEnv *env, jobject instance,
                                                                jbyteArray buffer_) {
//    startTime = av_gettime();
    jbyte *in = env->GetByteArrayElements(buffer_, NULL);

    int ret = 0;

    pFrameYUV = av_frame_alloc();
    int picture_size = av_image_get_buffer_size(pCodecCtx->pix_fmt, pCodecCtx->width,
                                                pCodecCtx->height, 1);
    uint8_t *buffers = (uint8_t *) av_malloc(picture_size);


    //将buffers的地址赋给AVFrame中的图像数据,根据像素格式判断有几个数据指针
    av_image_fill_arrays(pFrameYUV->data, pFrameYUV->linesize, buffers, pCodecCtx->pix_fmt,
                         pCodecCtx->width, pCodecCtx->height, 1);

    //安卓摄像头数据为NV21格式,此处将其转换为YUV420P格式
    ////N21   0~width * height是Y分量,  width*height~ width*height*3/2是VU交替存储
    //复制Y分量的数据
    memcpy(pFrameYUV->data[0], in, y_length); //Y
    pFrameYUV->pts = count;
    for (int i = 0; i < uv_length; i++) {
        //将v数据存到第三个平面
        *(pFrameYUV->data[2] + i) = *(in + y_length + i * 2);
        //将U数据存到第二个平面
        *(pFrameYUV->data[1] + i) = *(in + y_length + i * 2 + 1);
    }

    pFrameYUV->format = AV_PIX_FMT_YUV420P;
    pFrameYUV->width = yuv_width;
    pFrameYUV->height = yuv_height;

    //例如对于H.264来说。1个AVPacket的data通常对应一个NAL
    //初始化AVPacket
    av_init_packet(&enc_pkt);
//    __android_log_print(ANDROID_LOG_WARN, "eric", "编码前时间:%lld",
//                        (long long) ((av_gettime() - startTime) / 1000));
    //开始编码YUV数据
    ret = avcodec_send_frame(pCodecCtx, pFrameYUV);
    if (ret != 0) {
        logw("avcodec_send_frame error");
        return -1;
    }
    //获取编码后的数据
    ret = avcodec_receive_packet(pCodecCtx, &enc_pkt);
//    __android_log_print(ANDROID_LOG_WARN, "eric", "编码时间:%lld",
//                        (long long) ((av_gettime() - startTime) / 1000));
    //是否编码前的YUV数据
    av_frame_free(&pFrameYUV);
    if (ret != 0 || enc_pkt.size <= 0) {
        loge("avcodec_receive_packet error");
        avError(ret);
        return -2;
    }
    enc_pkt.stream_index = video_st->index;
    AVRational time_base = ofmt_ctx->streams[0]->time_base;//{ 1, 1000 };
    enc_pkt.pts = count * (video_st->time_base.den) / ((video_st->time_base.num) * fps);
    enc_pkt.dts = enc_pkt.pts;
    enc_pkt.duration = (video_st->time_base.den) / ((video_st->time_base.num) * fps);
    __android_log_print(ANDROID_LOG_WARN, "eric",
                        "index:%d,pts:%lld,dts:%lld,duration:%lld,time_base:%d,%d",
                        count,
                        (long long) enc_pkt.pts,
                        (long long) enc_pkt.dts,
                        (long long) enc_pkt.duration,
                        time_base.num, time_base.den);
    enc_pkt.pos = -1;
//    AVRational time_base_q = {1, AV_TIME_BASE};
//    //计算视频播放时间
//    int64_t pts_time = av_rescale_q(enc_pkt.dts, time_base, time_base_q);
//    //计算实际视频的播放时间
//    if (count == 0) {
//        startTime = av_gettime();
//    }
//    int64_t now_time = av_gettime() - startTime;
//    __android_log_print(ANDROID_LOG_WARN, "eric", "delt time :%lld", (pts_time - now_time));
//    if (pts_time > now_time) {
//        //睡眠一段时间(目的是让当前视频记录的播放时间与实际时间同步)
//        av_usleep((unsigned int) (pts_time - now_time));
//    }

    ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
    if (ret != 0) {
        loge("av_interleaved_write_frame failed");
    }
    count++;
    env->ReleaseByteArrayElements(buffer_, in, 0);
    return 0;

}

像素格式转换

在设置摄像头采集的图像格式时候我们设置的是NV21。而我们编码需要的是AV_PIX_FMT_YUV420P。所以这需要进行转换。我们先看下两个像素格式的区别

  • NV21

    是一个YUV 4:2:0数据,应该说是平面和打包混合存储。有两个平面,第一个平面存放Y数据第二个平面VU数据交替存储

  • AV_PIX_FMT_YUV420P

    那不用说是我们熟悉的YUV 4:2:0的像素数据,它是纯平面存储。总共三个平面,分别存放,Y、U、V数据。

我们还需要了解,以为采集的数据YUV是4:2:0。所以Y:(U或V)的大小是4:1。而U:V是1:1。所以当图像宽是width,高是height时,Y分量的大小就是width×heitht,而U是width×heitht/4,V也是U是width×heitht/4。

知道上面的存储格式后我们就知道怎么转换了。

首先复制Y分量的数据

memcpy(pFrameYUV->data[0], in, y_length);

然后遍历VU数据并存放到data[1]和data[2]平面中

    for (int i = 0; i < uv_length; i++) {
        //将v数据存到第三个平面
        *(pFrameYUV->data[2] + i) = *(in + y_length + i * 2);
        //将U数据存到第二个平面
        *(pFrameYUV->data[1] + i) = *(in + y_length + i * 2 + 1);
    }

H264编码

首先我们需要了解两个数据结构AVFrame、AVPacket

AVFrame存放的是原始数据、AVPacket存放的是编码后的数据。所以前面格式转换也是将数据存放到pFrameYUV中。

  • 初始化AVPacket

    av_init_packet(&enc_pkt);

  • 开始编码

    ret = avcodec_send_frame(pCodecCtx, pFrameYUV);

  • 接受编码后的数据

    ret = avcodec_receive_packet(pCodecCtx, &enc_pkt);

是不是很简单,这样编码后的数据就存到了enc_pkt中。到这里只是完成的编码工作,接下来还有一些参数需要设置

PTS、DTS、duration

PTS是显示时间戳,DTS解码时间戳,duration是当当前帧和下一帧的时间间隔,。这个很重要,不然播放会出现问题。

首先我们要知道时间基数,也就是你按什么时间单位算。

AVRational time_base = ofmt_ctx->streams[0]->time_base;

这里的值是{1,1000},这应该就是毫秒。知道时间基础,同时根据fps我们就知道每一帧的时间间隔是1000/fps。

那第n帧的pts就是n×(1000/fps)。对应代码

enc_pkt.pts = count * (video_st->time_base.den) / ((video_st->time_base.num) * fps);

dts和pts设置成一样,标示解码时间和显示时间一致。至于为什么,其实我也没太明白,如果不一致该怎么计算?我们先不管,以后再研究。

duration那就容易了,就是(video_st->time_base.den) / ((video_st->time_base.num) * fps)

这里的三个参数这是可能不太准确,但我们先这样,想把功能跑起来再说,不然我们纠结这些就永无止境了。后面等我们深入了,也就会明白。

输出视频数据

ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);

释放资源

在结束编码推流后我们也需要释放相关的资源

    if (video_st)
        avcodec_close(video_st->codec);
    if (ofmt_ctx) {
        avio_close(ofmt_ctx->pb);
        avformat_free_context(ofmt_ctx);
        ofmt_ctx = NULL;
    }
    return 0;