MJPG-streamer源码分析-输入部分

MJPG-streamer仅可以创建一个输入通道，对一个相机进行采集（如需多个，需另行修改）。在进行相机采集开始前，需要对其进行初始化，包括采集过程的全局变量定义和内存开辟。运行过程则是将相机采集得到的数据，根据从相机映射到内存的地址上，按照不同的格式要求（YUV或MJPEG）进行操作，包括格式转换和数据复制，最后图像数据被复制到指定的全局数据缓冲区。

====================================输入通道初始化过程=======================================

input_init()函数的初始化过程概括如下：

1、【定义和初始化变量】

包括width=640, height=480, fps=5, format=V4L2_PIX_FMT_MJPEG，char *argv[MAX_ARGUMENTS]={NULL}, *dev = "/dev/video0",

2、【初始化互斥锁】

pthread_mutex_init(&controls_mutex, NULL)

3、【解析参数】

将传入的单串参数param->parameter_string转换为字符串数组，存放在argv数组中，调用c = getopt_long_only(argc, argv, "", long_options, &option_index);通过option_index和switch将对应参数存放在目标对象上，包括dev，width，height，fps，format，gquality，dynctrls，led或打印help，具体可看源码。这个过程跟主函数中对参数的解析过程类似，只是在主函数中，主要是把输入参数分别分配到全局变量的输入参数和输出参数上，而在初始化函数中，参数解析也是类似的，只是把参数解析成对应对象，如width, height, fps, format等参数，

4、【设置参数input_uvc.c全局参数】

其中，在input_uvc.c文件中也定义了一个全局变量global的对象指针，并将其指向了主函数文件中的全局对象，这样，在input_uvc.c文件中的采集线程处理函数void *cam_thread( void *arg )可以直接通过该指针直接调用。
pglobal = param->global;
videoIn = malloc(sizeof(struct vdIn));
memset(videoIn, 0, sizeof(struct vdIn));

5、【打开视频设备并准备数据结构】

init_videoIn(videoIn, dev, width, height, fps, format, 1)

定义videoIn的结构体如下，其中videoIn用于存放输入的所有参数，包括图像大小、帧率、格式、缓冲区、相机参数等，

struct vdIn {
    int fd;
    char *videodevice;
    char *status;
    char *pictName;
    struct v4l2_capability cap;
    struct v4l2_format fmt;
    struct v4l2_buffer buf;
    struct v4l2_requestbuffers rb;
    void *mem[NB_BUFFER];
    unsigned char *tmpbuffer;
    unsigned char *framebuffer;
    int isstreaming;
    int grabmethod;
    int width;
    int height;
    int fps;
    int formatIn;
    int formatOut;
    int framesizeIn;
    int signalquit;
    int toggleAvi;
    int getPict;
    int rawFrameCapture;
    /* raw frame capture */
    unsigned int fileCounter;
    /* raw frame stream capture */
    unsigned int rfsFramesWritten;
    unsigned int rfsBytesWritten;
    /* raw stream capture */
    FILE *captureFile;
    unsigned int framesWritten;
    unsigned int bytesWritten;
    int framecount;
    int recordstart;
    int recordtime;
};

设备打开函数init_videoIn()：主要是对vdIn定义的对象（即在input_init()函数传入的videoIn参数，该参数在初始化文件中是全局状态）进行赋值初始化，并调用init_v4l2()函数初始化设备，通过返回的相机参数，由于相机返回的图像格式可能是YUYV，也可能是MJPEG格式，两种格式在处理上有所不同，因此不同格式下数据需要复制到vd对象上不同的缓冲区，对应后续不同图像复制处理函数，因此需要根据格式不同，对对应的缓冲区的内存进行分配（也就是说，只有一种格式缓冲区会被分配内存）。

int init_videoIn(struct vdIn *vd, char *device, int width, int height, int fps, int format, int grabmethod)
{
  if (vd == NULL || device == NULL)
    return -1;
  if (width == 0 || height == 0)
    return -1;
  if (grabmethod < 0 || grabmethod > 1)
    grabmethod = 1;		//mmap by default;
  vd->videodevice = NULL;
  vd->status = NULL;
  vd->pictName = NULL;
  vd->videodevice = (char *) calloc (1, 16 * sizeof (char));
  vd->status = (char *) calloc (1, 100 * sizeof (char));
  vd->pictName = (char *) calloc (1, 80 * sizeof (char));
  //函数说明:最多从源串中拷贝n－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为n 的话，将不会溢出。
  //函数返回值:若成功则返回欲写入的字符串长度，若出错则返回负值。
  snprintf (vd->videodevice, 12, "%s", device);
  vd->toggleAvi = 0;
  vd->getPict = 0;
  vd->signalquit = 1;
  vd->width = width;
  vd->height = height;
  vd->fps = fps;
  vd->formatIn = format;
  vd->grabmethod = grabmethod;
  //初始化设备
  if (init_v4l2 (vd) < 0) {
    fprintf (stderr, " Init v4L2 failed !! exit fatal \n");
    goto error;;
  }
  /* alloc a temp buffer to reconstruct the pict */
  vd->framesizeIn = (vd->width * vd->height << 1);
  switch (vd->formatIn) {
  case V4L2_PIX_FMT_MJPEG:
    vd->tmpbuffer = (unsigned char *) calloc(1, (size_t) vd->framesizeIn);
    if (!vd->tmpbuffer)
      goto error;
    vd->framebuffer =
        (unsigned char *) calloc(1, (size_t) vd->width * (vd->height + 8) * 2);
    break;
  case V4L2_PIX_FMT_YUYV:
    vd->framebuffer =
        (unsigned char *) calloc(1, (size_t) vd->framesizeIn);
    break;
  default:
    fprintf(stderr, " should never arrive exit fatal !!\n");
    goto error;
    break;
  }
  if (!vd->framebuffer)
    goto error;
  return 0;
error:
  free(vd->videodevice);
  free(vd->status);
  free(vd->pictName);
  close(vd->fd);
  return -1;
}

调用init_v4l2()函数，主要是对相机参数的初始化。尤其重要部分是，把相机采集后得到数据的缓冲区映射到内存上

static int init_v4l2(struct vdIn *vd)
{
  int i;
  int ret = 0;
  //打开设备，vd->videodevice在前面经过参数解析后得到
  if ((vd->fd = open(vd->videodevice, O_RDWR)) == -1) {
    perror("ERROR opening V4L interface");
    return -1;
  }

  memset(&vd->cap, 0, sizeof(struct v4l2_capability));
  //设备驱动程序中对设备的I/O通道进行管理的函数，成功返回0，失败返回-1；
  ret = ioctl(vd->fd, VIDIOC_QUERYCAP, &vd->cap);
  if (ret < 0) {
    fprintf(stderr, "Error opening device %s: unable to query device.\n", vd->videodevice);
    goto fatal;
  }

  if ((vd->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
    fprintf(stderr, "Error opening device %s: video capture not supported.\n",
           vd->videodevice);
    goto fatal;;
  }

  if (vd->grabmethod) {
    if (!(vd->cap.capabilities & V4L2_CAP_STREAMING)) {
      fprintf(stderr, "%s does not support streaming i/o\n", vd->videodevice);
      goto fatal;
    }
  } else {
    if (!(vd->cap.capabilities & V4L2_CAP_READWRITE)) {
      fprintf(stderr, "%s does not support read i/o\n", vd->videodevice);
      goto fatal;
    }
  }

  //设备输入参数
  memset(&vd->fmt, 0, sizeof(struct v4l2_format));
  vd->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  vd->fmt.fmt.pix.width = vd->width;
  vd->fmt.fmt.pix.height = vd->height;
  vd->fmt.fmt.pix.pixelformat = vd->formatIn;
  vd->fmt.fmt.pix.field = V4L2_FIELD_ANY;
  ret = ioctl(vd->fd, VIDIOC_S_FMT, &vd->fmt);
  if (ret < 0) {
    perror("Unable to set format");
    goto fatal;
  }

  if ((vd->fmt.fmt.pix.width != vd->width) ||
      (vd->fmt.fmt.pix.height != vd->height)) {
    fprintf(stderr, " format asked unavailable get width %d height %d \n", vd->fmt.fmt.pix.width, vd->fmt.fmt.pix.height);
    vd->width = vd->fmt.fmt.pix.width;
    vd->height = vd->fmt.fmt.pix.height;
    /*
     * look the format is not part of the deal ???
     */
    // vd->formatIn = vd->fmt.fmt.pix.pixelformat;
  }

   //设置帧率
  struct v4l2_streamparm *setfps;
  setfps = (struct v4l2_streamparm *) calloc(1, sizeof(struct v4l2_streamparm));
  memset(setfps, 0, sizeof(struct v4l2_streamparm));
  setfps->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  setfps->parm.capture.timeperframe.numerator = 1;
  setfps->parm.capture.timeperframe.denominator = vd->fps;
  ret = ioctl(vd->fd, VIDIOC_S_PARM, setfps);


   //设置缓冲区参数
  memset(&vd->rb, 0, sizeof(struct v4l2_requestbuffers));
  vd->rb.count = NB_BUFFER;
  vd->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  vd->rb.memory = V4L2_MEMORY_MMAP;

  ret = ioctl(vd->fd, VIDIOC_REQBUFS, &vd->rb);
  if (ret < 0) {
    perror("Unable to allocate buffers");
    goto fatal;
  }

  /*
   * 重要部分，MMAP缓冲区映射，把摄像头采集的数据存放地址映射到内存上，并将对应的内存地址记录在vd->mem[i]上，
   * 这样子在后续的复制采集数据时可以直接操作该内存地址
   */
  for (i = 0; i < NB_BUFFER; i++) {
    memset(&vd->buf, 0, sizeof(struct v4l2_buffer));
    vd->buf.index = i;
    vd->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    vd->buf.memory = V4L2_MEMORY_MMAP;
    ret = ioctl(vd->fd, VIDIOC_QUERYBUF, &vd->buf);
    if (ret < 0) {
      perror("Unable to query buffer");
      goto fatal;
    }

    if (debug)
      fprintf(stderr, "length: %u offset: %u\n", vd->buf.length, vd->buf.m.offset);

    vd->mem[i] = mmap(0 /* start anywhere */ ,
                      vd->buf.length, PROT_READ, MAP_SHARED, vd->fd,
                      vd->buf.m.offset);
    if (vd->mem[i] == MAP_FAILED) {
      perror("Unable to map buffer");
      goto fatal;
    }
    if (debug)
      fprintf(stderr, "Buffer mapped at address %p.\n", vd->mem[i]);
  }

  /*
   * 对缓冲区的队列，将空闲的内存加入可捕获视频的队列中，相机会将视频数据存放在该内存上
   */
  for (i = 0; i < NB_BUFFER; ++i) {
    memset(&vd->buf, 0, sizeof(struct v4l2_buffer));
    vd->buf.index = i;
    vd->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    vd->buf.memory = V4L2_MEMORY_MMAP;
    ret = ioctl(vd->fd, VIDIOC_QBUF, &vd->buf);
    if (ret < 0) {
      perror("Unable to queue buffer");
      goto fatal;;
    }
  }
  return 0;
fatal:
  return -1;

}

上述函数设计到通过ioctl命令与驱动程序进行交互，其中常见ioctl命令有以下几种，对应的功能在后面注释，关于参数更多的解释，可以参考文章： ioctl命令

VIDIOC_QUERYCAP     /* 获取设备支持的操作 */  
VIDIOC_G_FMT        /* 获取设置支持的视频格式 */  
VIDIOC_S_FMT        /* 设置捕获视频的格式 */  
VIDIOC_REQBUFS      /* 向驱动提出申请内存的请求 */  
VIDIOC_QUERYBUF     /* 向驱动查询申请到的内存 */  
VIDIOC_QBUF         /* 将空闲的内存加入可捕获视频的队列 */  
VIDIOC_DQBUF        /* 将已经捕获好视频的内存拉出已捕获视频的队列 */  
VIDIOC_STREAMON     /* 打开视频流 */  
VIDIOC_STREAMOFF    /* 关闭视频流 */  
VIDIOC_QUERYCTRL    /* 查询驱动是否支持该命令 */  
VIDIOC_G_CTRL       /* 获取当前命令值 */  
VIDIOC_S_CTRL       /* 设置新的命令值 */  
VIDIOC_G_TUNER      /* 获取调谐器信息 */  
VIDIOC_S_TUNER      /* 设置调谐器信息 */  
VIDIOC_G_FREQUENCY  /* 获取调谐器频率 */  
VIDIOC_S_FREQUENCY  /* 设置调谐器频率 */  
VIDIOC_DQEVENT   //出队列处理命令

经过了输入通道的初始化之后，完成了相机参数设置、内存映射、格式判定和对应格式缓冲区内存分配，并启动第一次相机的采集，但采集得到的图像数据并未复制出来，因此此时主函数中的全局变量global还未为其缓冲区分配内存。
==========================================输入通道执行过程===============================================

主函数通过调用int input_run(void)函数启动相机采集，源码如下。可以看到，在执行run时，程序先为全局变量的buff分配内存，并为相机创建一个线程，调用线程处理函数cam_thread()。接着使用pthread_detach()，在线程退出时自动释放线程分配的资源。

pthread_detach()的意义在于：创建一个线程默认的状态是joinable，如果一个线程结束运行但没有被join，则它的状态类似于进程中的Zombie Process，即还有一部分资源没有被回收（退出状态码）。所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代 码，回收其资源（类似于wait,waitpid) 。但是调用pthread_join(pthread_id)后，如果该线程没有运行结束，调用者会被阻塞。利用pthread_detach()，这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源。

int input_run(void) {
  pglobal->buf = malloc(videoIn->framesizeIn);
  if (pglobal->buf == NULL) {
    fprintf(stderr, "could not allocate memory\n");
    exit(EXIT_FAILURE);
  }

  pthread_create(&cam, 0, cam_thread, NULL);
  pthread_detach(cam);

  return 0;
}

对应线程处理函数cam_thread()，主要工作是获取一帧图像，并将其复制到全局缓冲区中，即上述函数所分配的全局buf位置上。获取图像是通过调用nvcGrab(vedioIn)函数，之后根据不同的格式，进行格式转换和复制到全局缓冲区的过程。

其中，当格式是YUYV时，执行pglobal->size = compress_yuyv_to_jpeg(videoIn, pglobal->buf, videoIn->framesizeIn, gquality);，并将所复制的内容大小写进pglobal->size。这个过程需要注意的是，由于YUV格式转换时，需要更多的CPU时间处理，故而会影响性能，应尽量避免使用YUV格式；

当采集格式是MJPEG格式，直接复制到内存中，调用pglobal->size = memcpy_picture(pglobal->buf, videoIn->tmpbuffer, videoIn->buf.bytesused);并将所复制的内容大小写进pglobal->size。

void *cam_thread( void *arg ) {
  /* set cleanup handler to cleanup allocated ressources */
  pthread_cleanup_push(cam_cleanup, NULL);

  //pglobal->stop在主程序中初始化为0，当又ctrl+C按下后，调用signal_handler()函数清理，将其置1。
  //所以在调用run函数时，进入该循环体会不断的采集数据并将其复制到全局变量的缓冲区上，直到被置1才退出
  while( !pglobal->stop ) {

    /* grab a frame */
    if( uvcGrab(videoIn) < 0 ) {
      IPRINT("Error grabbing frames\n");
      exit(EXIT_FAILURE);
    }
  
    DBG("received frame of size: %d\n", videoIn->buf.bytesused);

    /*
     * Workaround for broken, corrupted frames:
     * Under low light conditions corrupted frames may get captured.
     * The good thing is such frames are quite small compared to the regular pictures.
     * For example a VGA (640x480) webcam picture is normally >= 8kByte large,
     * corrupted frames are smaller.
     */
    if ( videoIn->buf.bytesused < minimum_size ) {
      DBG("dropping too small frame, assuming it as broken\n");
      continue;
    }

    /* copy JPG picture to global buffer */
    //将图像复制到全局前，必须锁定互斥锁，保证对该缓冲区的操作只有当前线程，避免冲突
   pthread_mutex_lock( &pglobal->db );

    /*
     * If capturing in YUV mode convert to JPEG now.
     * This compression requires many CPU cycles, so try to avoid YUV format.
     * Getting JPEGs straight from the webcam, is one of the major advantages of
     * Linux-UVC compatible devices.
     */
    if (videoIn->formatIn == V4L2_PIX_FMT_YUYV) {
      DBG("compressing frame\n");
      pglobal->size = compress_yuyv_to_jpeg(videoIn, pglobal->buf, videoIn->framesizeIn, gquality);
    }
    else {
      DBG("copying frame\n");
      pglobal->size = memcpy_picture(pglobal->buf, videoIn->tmpbuffer, videoIn->buf.bytesused);
    }

#if 0
    /* motion detection can be done just by comparing the picture size, but it is not very accurate!! */
    if ( (prev_size - global->size)*(prev_size - global->size) > 4*1024*1024 ) {
        DBG("motion detected (delta: %d kB)\n", (prev_size - global->size) / 1024);
    }
    prev_size = global->size;
#endif

   //pthread_cond_broadcast(),唤醒所有阻塞在某个条件变量上的线程，这些线程被唤醒后将再次竞争相应的互斥锁
    pthread_cond_broadcast(&pglobal->db_update);
    pthread_mutex_unlock( &pglobal->db );

    DBG("waiting for next frame\n");

    /* only use usleep if the fps is below 5, otherwise the overhead is too long */
    if ( videoIn->fps < 5 ) {
      usleep(1000*1000/videoIn->fps);
    }
  }

  DBG("leaving input thread, calling cleanup function now\n");
  pthread_cleanup_pop(1);

  return NULL;
}

在nvcGrab(vedioIn)函数中，先执行ioctl命令DQBUF，通知驱动程序获取已存放有图像数据的缓存，该缓存经过初始化已经映射到内存中，故而后续的操作只需要操作对应内存的即可（映射到内存上的起始地址已经保存在vd->mem[i]中）。根据不同的视频格式要求，把视频数据复制到vd变量上不同的位置。之后再执行ioctl命令QBUF，向驱动传递应用程序已经处理完缓存，把对应的缓存加入到空闲捕获队列。之后退出本函数。而在cam_thread()函数中，只要pglobal->stop不为1，则不断采集并将数据存放到指定位置。

其中，当采集格式是MJPEG时，数据被复制到vd->tmpbuffer；采集格式是YUYV时，数据被复制到vd->framebuffer

int uvcGrab(struct vdIn *vd)
{
#define HEADERFRAME1 0xaf
  int ret;

  if (!vd->isstreaming)
    if (video_enable(vd))
      goto err;

  memset(&vd->buf, 0, sizeof(struct v4l2_buffer));
  vd->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  vd->buf.memory = V4L2_MEMORY_MMAP;

  ret = ioctl(vd->fd, VIDIOC_DQBUF, &vd->buf);
  if (ret < 0) {
    perror("Unable to dequeue buffer");
    goto err;
  }

  switch (vd->formatIn) {
    case V4L2_PIX_FMT_MJPEG:
      if (vd->buf.bytesused <= HEADERFRAME1) {    /* Prevent crash
                                                  * on empty image */
        fprintf(stderr, "Ignoring empty buffer ...\n");
        return 0;
      }

      memcpy(vd->tmpbuffer, vd->mem[vd->buf.index], vd->buf.bytesused);

      if (debug)
        fprintf(stderr, "bytes in used %d \n", vd->buf.bytesused);
      break;

    case V4L2_PIX_FMT_YUYV:
      if (vd->buf.bytesused > vd->framesizeIn)
        memcpy (vd->framebuffer, vd->mem[vd->buf.index], (size_t) vd->framesizeIn);
      else
        memcpy (vd->framebuffer, vd->mem[vd->buf.index], (size_t) vd->buf.bytesused);
      break;

    default:
      goto err;
    break;
  }

  ret = ioctl(vd->fd, VIDIOC_QBUF, &vd->buf);
  if (ret < 0) {
    perror("Unable to requeue buffer");
    goto err;
  }

  return 0;

err:
  vd->signalquit = 0;
  return -1;
}

小结：线程执行函数中的循环体执行过程|：先执行图像采集，再锁定互斥锁，根据不同格式，从不同的位置复制图像数据到指定全局缓存中。当格式指定为YUYV时，进行格式转换后再执行复制。最后广播条件变量和解锁互斥锁，通知其他线程有新数据更新。