一、准备工作

sudo apt-get install libv4l-dev

二、编码实现

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>
#include <time.h>

#define CAMERA_DEVICE "/dev/video0"
#define INITIAL_IMAGE_PATH "./"
#define VIDEO_WIDTH 1366
#define VIDEO_HEIGHT 768
#define VIDEO_FORMAT V4L2_PIX_FMT_JPEG
#define BUFFER_COUNT 2    //image count in device buffer queue
#define DESIRED_IMAGE_COUNT 5

#define M2S(x) #x

typedef struct video_buffer 
{
    void   *start;
    size_t  length;
}VideoBuffer;

//get each image's path name via different catching time
void get_image_name(char _str[],int _num)
{
    char time_str[30];
    time_t timep;
    struct tm *p;
    time(&timep);
    p=localtime(&timep);

    sprintf(time_str,"%d%d%d_%d_%d_%d_%d",(1900+p->tm_year), (1+p->tm_mon),p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec,_num);
    strcat(time_str,".jpg");

    strcat(_str,time_str);    
}

int main(int argc,char **argv)
{
    int fd  = 0;     //camera handel
    int err = 0;     //returned value of function: inctl 
    char image_path[80] = INITIAL_IMAGE_PATH;
    struct v4l2_capability cap;
    struct v4l2_fmtdesc fmtdesc;
    struct v4l2_format format;
    struct v4l2_requestbuffers req; //buffer in device
    struct v4l2_buffer buf;
    struct video_buffer *video_buf = NULL;

    //1. open file of camera    
    printf("#open camera:\n");

    fd=open(CAMERA_DEVICE,O_RDWR,0);
    if(fd == -1)
    {
        printf("failed to open camera!\n");
        exit(0);
    }
    printf("fd=%d\n",fd);

    //2. query driver's capability
    printf("\n#query driver's capability:\n");

    if(ioctl(fd, VIDIOC_QUERYCAP, &cap) == -1)
    {
        printf("failed to query driver's driver capability!\n");
        exit(0);
    }
    printf("cap.capabilities=0x%x\n",cap.capabilities);

    //3. enumerate image format(s) driver supported
    printf("\n#enumerate image format(s) driver supported:\n");

    fmtdesc.index=0;
    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    printf("image format(s) driver supported:\n");
    do{
        err=ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc);
        printf("index:%d,flag:%d, format name:%s,pixelformat=0x%x \n",fmtdesc.index,fmtdesc.flags,fmtdesc.description,fmtdesc.pixelformat);
        fmtdesc.index++;
    }while(0==err);

    //4. set frame format
    printf("\n#set frame format:\n");

    memset(&format,0,sizeof(struct v4l2_format));

    format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    format.fmt.pix.width = VIDEO_WIDTH; //width of frame photo
    format.fmt.pix.height = VIDEO_HEIGHT;//hight of frame photo
    format.fmt.pix.pixelformat = VIDEO_FORMAT;//frame format

    err = ioctl(fd, VIDIOC_TRY_FMT, &format);
     if(err == -1){
         printf("Unsupported video format value of %s: .\n",M2S(VIDEO_FORMAT));
         return 0;
     }
    err = ioctl(fd, VIDIOC_S_FMT, &format);
    printf("set value of VIDIOC_S_FMT=%d\n",err);

    //5. apply memory for images from catching video
    printf("\n#apply memory for images from catching video:\n");

    req.count = BUFFER_COUNT;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;
    if(ioctl(fd,VIDIOC_REQBUFS,&req) == -1) //VIDIOC_REQBUFS means allocate memory from device
    {
        printf("failed to apply memory for images from catching video!\n");
        exit(0);
    }

    //6. apply phycisal(program) memory and map it to memory of images
    printf("\n#apply phycisal memory and map it to memory of images:\n");

    video_buf = calloc(req.count, sizeof(*video_buf));
    int numBufs=0;
    for (numBufs = 0; numBufs < req.count; numBufs++) 
    {
        memset( &buf, 0, sizeof(buf) );

        buf.index = numBufs;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;

        //apply buffer memory from device
        if (ioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) 
        {
            printf("faild to get buffer memory%d\n",numBufs);
            exit(0);
        }

        video_buf[numBufs].length = buf.length;

        // map device buffer into program memory so that we can get information of image(s) and display in monitor
        video_buf[numBufs].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE,MAP_SHARED,fd, buf.m.offset);

        if (video_buf[numBufs].start == MAP_FAILED) 
        {
            printf("video_buf[%d] ",numBufs);
            perror("map error:");
            exit(0);
        }

        //queue buffer to save images from device
        if (ioctl(fd, VIDIOC_QBUF, &buf) == -1) 
        {
            printf("fiald to push into buffer queue\n");
            exit(0);
        }
        printf("Frame buffer %d: address=0x%x, length=%d\n", numBufs, (unsigned int)video_buf[numBufs].start, video_buf[numBufs].length);
    }


    //7. start to record video
    printf("\n#start to record video:\n");

    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    err = ioctl(fd, VIDIOC_STREAMON, &type);//VIDIOC_STREAMON： start command:video captuer,then  the device program will start 
                                                    //colloct video data and save it into device's buffer
    if (err < 0) 
    {
        printf("VIDIOC_STREAMON failed (%d)\n", err);
        exit(0);
    }

    int loop_i;
    for(loop_i=0;loop_i<DESIRED_IMAGE_COUNT;loop_i++)
    {
        // Get frame
        err = ioctl(fd, VIDIOC_DQBUF, &buf);//get a photo from device and save into device buffer,because of mapping before,
                                                    //it also saved into program memory 
        if (err < 0)
        {
            printf("VIDIOC_DQBUF failed (%d)\n", err);
            exit(0);
        }

        // save frame 
        strcpy(image_path,INITIAL_IMAGE_PATH);//Re-initialise path name of image
        get_image_name(image_path,loop_i+1);//get new path name


        FILE *fp = fopen(image_path, "wb");
        if (fp < 0) 
        {
            printf("open frame data file failed\n");
            exit(0);
        }

        fwrite(video_buf[buf.index].start, 1, buf.length, fp);
        fclose(fp);

        printf("Capture frame%d saved in %s\n",loop_i+1,image_path);

        // Re-queen buffer
        err = ioctl(fd, VIDIOC_QBUF, &buf);
        if (err < 0)
        {
            printf("VIDIOC_QBUF failed (%d)\n", err);
            exit(0);
        }
    }
    // Release the resource
    for (numBufs=0; numBufs< req.count; numBufs++) 
    {
        munmap(video_buf[numBufs].start, video_buf[numBufs].length);
    }

    //8. close file of camera
    printf("\n#close camera:\n");
    if(fd != -1)
    {            
        if(close(fd) != -1)
            printf("succeed to close camera!\n");
    }
    else
    {
        printf("failed to close camera!\n");
        exit(0);
    }

    //9. free memory 
    free(video_buf);

    return 0;
}

Makefile

DIRS = 

CC = gcc
CXX = g++
AR = ar
ARFLAGS = -scurv
RANLIB = ranlib

CFLAGS = -Wall -g -DDEBUG
CXXFLAGS = -Wall -g
LDFLAGS = 

SRCS = $(wildcard *.c)
OBJS = $(patsubst %.c,%.o,$(SRCS))

TARGETS = main

all : $(TARGETS)

$(TARGETS): $(OBJS)
    $(CC) -o$@ $^ $(LDFLAGS)

clean :
    @for dir in $(DIRS); \
    do \
        make -C $$dir clean; \
        echo; \
    done
    rm -rf $(OBJS) $(TARGETS)

.PHONY: all clean

三、v4l2相关内容

https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/v4l2.htm

3.1 Querying Capabilities

对于大多数摄像头，需要关注V4L2_CAP_VIDEO_CAPTURE、V4L2_CAP_STREAMING两个Capabilities

3.1.1 Device Capabilities Flags

3.1.2 The System Call API

/**
  * struct v4l2_capability - Describes V4L2 device caps returned by VIDIOC_QUERYCAP
  *
  * @driver:       name of the driver module (e.g. "bttv")
  * @card:     name of the card (e.g. "Hauppauge WinTV")
  * @bus_info:     name of the bus (e.g. "PCI:" + pci_name(pci_dev) )
  * @version:      KERNEL_VERSION
  * @capabilities: capabilities of the physical device as a whole
  * @device_caps:  capabilities accessed via this particular device (node)
  * @reserved:     reserved fields for future extensions
  */
struct v4l2_capability {
    __u8    driver[16];
    __u8    card[32];
    __u8    bus_info[32];
    __u32   version;
    __u32   capabilities;
    __u32   device_caps;
    __u32   reserved[3];
};

int ioctl(int fd, VIDIOC_QUERYCAP, struct v4l2_capability *argp;


On success 0 is returned, 
on error -1 and the errno variable is set appropriately. 
The generic error codes are described at the Generic Error Codes chapter

3.2 Enumerate image format(s) driver supported