基于RTMP推送实时AAC+H264流（一）

逃离我推掉我的手 2022-06-12 00:18 361阅读 0赞

最近在做视频监控的项目，搞了一个多星期，总结一下学到的东西，也希望可以帮到有需要的人   
从整体来看，推流端大概是这么个流程：采集、处理、编码、封装、推送   
![rtmp][]   
如上图所示，图像采集线程和声音采集线程经过编码封装，将RTMP包写入到缓冲队列，发送线程从缓冲队列中读取RTMP包中并加上时间戳，然后送往RTMP服务器，由于一秒可能有上百个RTMP包，会造成大量的new和delete，所以实现了一个简单的内存池以减少内存分配及释放的次数

# 采集 #

分为图像和声音，采集图像用的是v4l2 API，采集声音用的是alsa API，这两个都是[Linux][]环境下的，暂时没有考虑其他环境

## v4l2 ##

流程：打开设备、检查设备能力、设置格式、设置缓冲区、读取缓冲队列   
详细代码位于`V4L2Source.cpp`，当然也可以看[官方Demo][Demo]   
打开设备：首先是打开设备文件，也可以用非阻塞的方式打开，但接下来的相关IO操作也是非阻塞的

fd = open("/dev/video0", O_RDWR);
     
      
       1
      
     
      
       1

检查设备能力：通过 `V4L2_CAP_VIDEO_CAPTURE` 位来判断设备是否具有捕获图像的能力

v4l2_capability cap;
    ioctl(fd, VIDIOC_QUERYCAP, &cap);
    if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
        return false;
    }
     
      
       1
       2
       3
       4
       5
      
     
      
       1
       2
       3
       4
       5

设置格式：这一步之前可能需要检查一下摄像头支持的格式，检查需要用到`ioctl`函数和`VIDIOC_ENUM_FMT`参数，这里略过了这一步，统一设置成了支持较多的YUYV，也叫YUY2，然后编码前再把图片转为所需格式

v4l2_format fmt;
    
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = width;
    fmt.fmt.pix.height = height;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.field = V4L2_FIELD_NONE;
    
    ioctl(fd, VIDIOC_S_FMT, &fmt);
    if (fmt.fmt.pix.pixelformat != V4L2_PIX_FMT_YUV420) {
        return false;
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12

设置缓冲区：缓冲区是一个队列，用于接收图像数据，这里用`mmap`的方式，将内核空间的内存映射到用户空间，这样可以避免拷贝，这里首先需要定义一个结构体来保存返回缓冲区的位置和大小

v4l2_requestbuffers reqbuf;
    v4l2_buffer buf;
    
    reqbuf.count = 4;
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    reqbuf.memory = V4L2_MEMORY_MMAP;
    ioctl(fd, VIDIOC_REQBUFS, &reqbuf);
    
    for (int i = 0; i < mBufCount; ++i) {
        buf.index = i;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        ioctl(fd, VIDIOC_QUERYBUF, &buf);
    
        mQueueBuf[i].length = buf.length;
        mQueueBuf[i].data = static_cast<char*>(mmap(0, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset));
    
        ioctl(fd, VIDIOC_QBUF, &buf);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19

读取缓冲队列：首先需要开始捕获图像，然后从缓冲队列中取出一个缓冲区，处理完之后需要放回缓冲队列

v4l2_buffer buf;
    v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ioctl(fd, VIDIOC_STREAMON, &type);
    
    memset(&buf, 0, sizeof(buf));
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    
    while (ioctl(fd, VIDIOC_DQBUF, &buf) == -1) {
        if (errno == EIO) continue;
    }
    
    process(mQueueBuf[buf.index].data);
    
    ioctl(fd, VIDIOC_QBUF, &buf);
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15

至此就完成了简单的图像采集，需要说明一下，所有贴出的代码，为了方便观看和说明，与项目中的相比，去掉了一些判断，做了一些修改

## alsa ##

流程：打开设备、设置参数、读取数据   
详细代码位于`PCMSource.cpp`，开始之前可能需要了解一些相关知识，比如采样率，帧，通道，样本等，详情可以到网上搜索   
打开设备：打开设备并获取到句柄

snd_pcm_t *handle;
    snd_pcm_open(&handle, "default", SND_PCM_STREAM_CAPTURE, 0);
     
      
       1
       2
      
     
      
       1
       2

设置参数：这里`SND_PCM_ACCESS_RW_INTERLEAVED`表示交错模式，也就是设置立体声时，数据格式为左声道样本和右声道样本交错存放，`frames`表示一周期内的帧数，比如按照这里的配置，一次获取的数据量为`1024 * 2 * 16bit = 4096byte`

int direct;
    int rate = 44100;
    snd_pcm_hw_params_t *param;
    snd_pcm_uframes_t frames = 1024;
    
    snd_pcm_hw_params_alloca(&param);
    snd_pcm_hw_params_any(handle, param);
    snd_pcm_hw_params_set_access(handle, param, SND_PCM_ACCESS_RW_INTERLEAVED);
    snd_pcm_hw_params_set_format(handle, param, SND_PCM_FORMAT_S16_LE);
    snd_pcm_hw_params_set_channels(handle, param, 2);
    snd_pcm_hw_params_set_rate_near(handle, param, &rate, &direct);
    snd_pcm_hw_params_set_period_size_near(handle, param, &frames, &direct);
    snd_pcm_hw_params(handle, param);
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13

读取数据：这里可能上溢，简单来说就是缓冲区中数据满了还没有被读取，这种情况调用`snd_pcm_prepare`重新准备设备，然后再次尝试读取

int ret;
    while ((ret = snd_pcm_readi(handle, buf, frames)) < 0) {
        if (ret == -EPIPE) {
            // overrun, retry!
            snd_pcm_prepare(handle);
        } else if (ret < 0) {
            break;
        } else {
            process(ret, buf);
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

# 处理 #

这一步主要是对获取到的图像和声音数据进行处理，比如降噪，美颜什么的，由于没学过，不了解这块的知识，所以不知道怎么处理声音，图像也只是进行了简单地处理   
详细代码位于`YUYVConverter.cpp`和`MotionDetector.cpp`

## YUYV2I420 ##

由于x264编码用的baseline配置，所以编码需要I420格式的图像，如果无需动态检测，则可以直接把YUYV格式转为I420格式，前者是2个Y共用一对UV，后者是4个Y共用一对UV，除此之外还有存储格式上的不同，所以YUYV转换I420就是先把Y提取出来，然后隔行取一次UV，下面是个简单的例子

/*
    4*4 YUYV packed
    Y00 U00 Y01 V00 Y02 U01 Y03 V01
    Y10 U10 Y11 V10 Y12 U11 Y13 V11
    Y20 U20 Y21 V20 Y22 U21 Y23 V21
    Y30 U30 Y31 V30 Y32 U31 Y33 V31
    
    4*4 I420 planar
    Y00 Y01 Y02 Y03
    Y10 Y11 Y12 Y13
    Y20 Y21 Y22 Y23
    Y30 Y31 Y32 Y33
    U00 U01 U20 U21
    V00 V01 V20 V21
    */
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15

const int length = width * height * 2;
    const int stride = width * 2;
    
    char *pY = buf;
    char *pU = pY + width * height;
    char *pV = pU + (width * height / 4); 
    bool uFlags = true;
    
    for (int i = 0; i < length; ++i) {
        if (i % 2 == 0) {
            *(pY++) = data[i];
        } else if ((i / stride) % 2 == 0) {
            if (uFlags) {
                *(pU++) = data[i];
            } else {
                *(pV++) = data[i];
            }
            uFlags = !uFlags;
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20

## YUYV2RGB24 ##

因为动态检测用的是[OpenCV][]库，需要将图像输入到cv::Mat这个类，但是我不知道怎么直接用cv::Mat存储YUYV图像，所以就先转换到了RGB格式，转换也不难，一组YUYV对应两组RGB，然后再用YUV的值算出RGB的值即可，这里我直接用的公式计算，涉及了较多的浮点运算，可能效率会比较低，有一种查表的方法，预先算出可能的值，牺牲小部分空间换取时间，由于YUV和RGB的取值范围都是\[0, 255\]，所以可以用多个256\*256的二维数组存下相应的值，此外，还要注意处理溢出的情况

const int length = width * height * 2;
    char *p = buf;
    int y1, y2, u, v;
    
    for (int i = 0; i < length; i += 4) {
        y1 = *(data++);
        u = *(data++);
        y2 = *(data++);
        v = *(data++);
    
        *(p++) = 1.164 * (y1 - 16) + 1.596 * (v - 128);
        *(p++) = 1.164 * (y1 - 16) - 0.391 * (u - 128) - 0.813 * (v - 128);
        *(p++) = 1.164 * (y1 - 16) + 2.018 * (u - 128);
        *(p++) = 1.164 * (y2 - 16) + 1.596 * (v - 128);     
        *(p++) = 1.164 * (y2 - 16) - 0.391 * (u - 128) - 0.813 * (v - 128);
        *(p++) = 1.164 * (y2 - 16) + 2.018 * (u - 128);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17

## 动态检测 ##

用[opencv][OpenCV]库进行背景消除，将图像腐蚀膨胀，然后找出前景的轮廓，根据轮廓大小，判断是否需要在相应位置画出框框，最后还要把格式转换为I420

// cv::Ptr<cv::BackgroundSubtractor> sb = cv::createBackgroundSubtractorMOG2(500, 16, false);
    
    cv::Mat fg, rgb, yuv;
    std::vector<std::vector<cv::Point>> contours;
    
    rgb.create(height, width, CV_8UC3);
    memcpy(rgb.data, data, height * width * 3);
    
    sb->apply(rgb, fg);
    
    cv::erode(fg, fg, cv::Mat());
    cv::dilate(fg, fg, cv::Mat());
    cv::findContours(fg, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
    drawRect(contours, rgb, 1000);
    cv::cvtColor(rgb, yuv, CV_RGB2YUV_I420);
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
      
     
      
      
       
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15

接下来的部分将写在下一篇博文中，最后附上[项目地址][Link 1]

http://blog.csdn.net/scnu20142005027/article/details/56847293

[rtmp]: /images/20220612/f26cb93deb264164a7a63c0d51282235.png
[Linux]: http://lib.csdn.net/base/linux
[Demo]: http://v4l.videotechnology.com/dwg/capture.c
[OpenCV]: http://lib.csdn.net/base/opencv
[Link 1]: https://github.com/Arachnid-27/live-rtmp-publisher