1.. SPDX-License-Identifier: GFDL-1.1-no-invariants-or-later 2 3file: media/v4l/capture.c 4========================= 5 6.. code-block:: c 7 8 /* 9 * V4L2 video capture example 10 * 11 * This program can be used and distributed without restrictions. 12 * 13 * This program is provided with the V4L2 API 14 * see https://linuxtv.org/docs.php for more information 15 */ 16 17 #include <stdio.h> 18 #include <stdlib.h> 19 #include <string.h> 20 #include <assert.h> 21 22 #include <getopt.h> /* getopt_long() */ 23 24 #include <fcntl.h> /* low-level i/o */ 25 #include <unistd.h> 26 #include <errno.h> 27 #include <sys/stat.h> 28 #include <sys/types.h> 29 #include <sys/time.h> 30 #include <sys/mman.h> 31 #include <sys/ioctl.h> 32 33 #include <linux/videodev2.h> 34 35 #define CLEAR(x) memset(&(x), 0, sizeof(x)) 36 37 enum io_method { 38 IO_METHOD_READ, 39 IO_METHOD_MMAP, 40 IO_METHOD_USERPTR, 41 }; 42 43 struct buffer { 44 void *start; 45 size_t length; 46 }; 47 48 static char *dev_name; 49 static enum io_method io = IO_METHOD_MMAP; 50 static int fd = -1; 51 struct buffer *buffers; 52 static unsigned int n_buffers; 53 static int out_buf; 54 static int force_format; 55 static int frame_count = 70; 56 57 static void errno_exit(const char *s) 58 { 59 fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno)); 60 exit(EXIT_FAILURE); 61 } 62 63 static int xioctl(int fh, int request, void *arg) 64 { 65 int r; 66 67 do { 68 r = ioctl(fh, request, arg); 69 } while (-1 == r && EINTR == errno); 70 71 return r; 72 } 73 74 static void process_image(const void *p, int size) 75 { 76 if (out_buf) 77 fwrite(p, size, 1, stdout); 78 79 fflush(stderr); 80 fprintf(stderr, "."); 81 fflush(stdout); 82 } 83 84 static int read_frame(void) 85 { 86 struct v4l2_buffer buf; 87 unsigned int i; 88 89 switch (io) { 90 case IO_METHOD_READ: 91 if (-1 == read(fd, buffers[0].start, buffers[0].length)) { 92 switch (errno) { 93 case EAGAIN: 94 return 0; 95 96 case EIO: 97 /* Could ignore EIO, see spec. */ 98 99 /* fall through */ 100 101 default: 102 errno_exit("read"); 103 } 104 } 105 106 process_image(buffers[0].start, buffers[0].length); 107 break; 108 109 case IO_METHOD_MMAP: 110 CLEAR(buf); 111 112 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 113 buf.memory = V4L2_MEMORY_MMAP; 114 115 if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) { 116 switch (errno) { 117 case EAGAIN: 118 return 0; 119 120 case EIO: 121 /* Could ignore EIO, see spec. */ 122 123 /* fall through */ 124 125 default: 126 errno_exit("VIDIOC_DQBUF"); 127 } 128 } 129 130 assert(buf.index < n_buffers); 131 132 process_image(buffers[buf.index].start, buf.bytesused); 133 134 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) 135 errno_exit("VIDIOC_QBUF"); 136 break; 137 138 case IO_METHOD_USERPTR: 139 CLEAR(buf); 140 141 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 142 buf.memory = V4L2_MEMORY_USERPTR; 143 144 if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) { 145 switch (errno) { 146 case EAGAIN: 147 return 0; 148 149 case EIO: 150 /* Could ignore EIO, see spec. */ 151 152 /* fall through */ 153 154 default: 155 errno_exit("VIDIOC_DQBUF"); 156 } 157 } 158 159 for (i = 0; i < n_buffers; ++i) 160 if (buf.m.userptr == (unsigned long)buffers[i].start 161 && buf.length == buffers[i].length) 162 break; 163 164 assert(i < n_buffers); 165 166 process_image((void *)buf.m.userptr, buf.bytesused); 167 168 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) 169 errno_exit("VIDIOC_QBUF"); 170 break; 171 } 172 173 return 1; 174 } 175 176 static void mainloop(void) 177 { 178 unsigned int count; 179 180 count = frame_count; 181 182 while (count-- > 0) { 183 for (;;) { 184 fd_set fds; 185 struct timeval tv; 186 int r; 187 188 FD_ZERO(&fds); 189 FD_SET(fd, &fds); 190 191 /* Timeout. */ 192 tv.tv_sec = 2; 193 tv.tv_usec = 0; 194 195 r = select(fd + 1, &fds, NULL, NULL, &tv); 196 197 if (-1 == r) { 198 if (EINTR == errno) 199 continue; 200 errno_exit("select"); 201 } 202 203 if (0 == r) { 204 fprintf(stderr, "select timeout\n"); 205 exit(EXIT_FAILURE); 206 } 207 208 if (read_frame()) 209 break; 210 /* EAGAIN - continue select loop. */ 211 } 212 } 213 } 214 215 static void stop_capturing(void) 216 { 217 enum v4l2_buf_type type; 218 219 switch (io) { 220 case IO_METHOD_READ: 221 /* Nothing to do. */ 222 break; 223 224 case IO_METHOD_MMAP: 225 case IO_METHOD_USERPTR: 226 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 227 if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type)) 228 errno_exit("VIDIOC_STREAMOFF"); 229 break; 230 } 231 } 232 233 static void start_capturing(void) 234 { 235 unsigned int i; 236 enum v4l2_buf_type type; 237 238 switch (io) { 239 case IO_METHOD_READ: 240 /* Nothing to do. */ 241 break; 242 243 case IO_METHOD_MMAP: 244 for (i = 0; i < n_buffers; ++i) { 245 struct v4l2_buffer buf; 246 247 CLEAR(buf); 248 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 249 buf.memory = V4L2_MEMORY_MMAP; 250 buf.index = i; 251 252 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) 253 errno_exit("VIDIOC_QBUF"); 254 } 255 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 256 if (-1 == xioctl(fd, VIDIOC_STREAMON, &type)) 257 errno_exit("VIDIOC_STREAMON"); 258 break; 259 260 case IO_METHOD_USERPTR: 261 for (i = 0; i < n_buffers; ++i) { 262 struct v4l2_buffer buf; 263 264 CLEAR(buf); 265 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 266 buf.memory = V4L2_MEMORY_USERPTR; 267 buf.index = i; 268 buf.m.userptr = (unsigned long)buffers[i].start; 269 buf.length = buffers[i].length; 270 271 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) 272 errno_exit("VIDIOC_QBUF"); 273 } 274 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 275 if (-1 == xioctl(fd, VIDIOC_STREAMON, &type)) 276 errno_exit("VIDIOC_STREAMON"); 277 break; 278 } 279 } 280 281 static void uninit_device(void) 282 { 283 unsigned int i; 284 285 switch (io) { 286 case IO_METHOD_READ: 287 free(buffers[0].start); 288 break; 289 290 case IO_METHOD_MMAP: 291 for (i = 0; i < n_buffers; ++i) 292 if (-1 == munmap(buffers[i].start, buffers[i].length)) 293 errno_exit("munmap"); 294 break; 295 296 case IO_METHOD_USERPTR: 297 for (i = 0; i < n_buffers; ++i) 298 free(buffers[i].start); 299 break; 300 } 301 302 free(buffers); 303 } 304 305 static void init_read(unsigned int buffer_size) 306 { 307 buffers = calloc(1, sizeof(*buffers)); 308 309 if (!buffers) { 310 fprintf(stderr, "Out of memory\n"); 311 exit(EXIT_FAILURE); 312 } 313 314 buffers[0].length = buffer_size; 315 buffers[0].start = malloc(buffer_size); 316 317 if (!buffers[0].start) { 318 fprintf(stderr, "Out of memory\n"); 319 exit(EXIT_FAILURE); 320 } 321 } 322 323 static void init_mmap(void) 324 { 325 struct v4l2_requestbuffers req; 326 327 CLEAR(req); 328 329 req.count = 4; 330 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 331 req.memory = V4L2_MEMORY_MMAP; 332 333 if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) { 334 if (EINVAL == errno) { 335 fprintf(stderr, "%s does not support " 336 "memory mappingn", dev_name); 337 exit(EXIT_FAILURE); 338 } else { 339 errno_exit("VIDIOC_REQBUFS"); 340 } 341 } 342 343 if (req.count < 2) { 344 fprintf(stderr, "Insufficient buffer memory on %s\n", 345 dev_name); 346 exit(EXIT_FAILURE); 347 } 348 349 buffers = calloc(req.count, sizeof(*buffers)); 350 351 if (!buffers) { 352 fprintf(stderr, "Out of memory\n"); 353 exit(EXIT_FAILURE); 354 } 355 356 for (n_buffers = 0; n_buffers < req.count; ++n_buffers) { 357 struct v4l2_buffer buf; 358 359 CLEAR(buf); 360 361 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 362 buf.memory = V4L2_MEMORY_MMAP; 363 buf.index = n_buffers; 364 365 if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf)) 366 errno_exit("VIDIOC_QUERYBUF"); 367 368 buffers[n_buffers].length = buf.length; 369 buffers[n_buffers].start = 370 mmap(NULL /* start anywhere */, 371 buf.length, 372 PROT_READ | PROT_WRITE /* required */, 373 MAP_SHARED /* recommended */, 374 fd, buf.m.offset); 375 376 if (MAP_FAILED == buffers[n_buffers].start) 377 errno_exit("mmap"); 378 } 379 } 380 381 static void init_userp(unsigned int buffer_size) 382 { 383 struct v4l2_requestbuffers req; 384 385 CLEAR(req); 386 387 req.count = 4; 388 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 389 req.memory = V4L2_MEMORY_USERPTR; 390 391 if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) { 392 if (EINVAL == errno) { 393 fprintf(stderr, "%s does not support " 394 "user pointer i/on", dev_name); 395 exit(EXIT_FAILURE); 396 } else { 397 errno_exit("VIDIOC_REQBUFS"); 398 } 399 } 400 401 buffers = calloc(4, sizeof(*buffers)); 402 403 if (!buffers) { 404 fprintf(stderr, "Out of memory\n"); 405 exit(EXIT_FAILURE); 406 } 407 408 for (n_buffers = 0; n_buffers < 4; ++n_buffers) { 409 buffers[n_buffers].length = buffer_size; 410 buffers[n_buffers].start = malloc(buffer_size); 411 412 if (!buffers[n_buffers].start) { 413 fprintf(stderr, "Out of memory\n"); 414 exit(EXIT_FAILURE); 415 } 416 } 417 } 418 419 static void init_device(void) 420 { 421 struct v4l2_capability cap; 422 struct v4l2_cropcap cropcap; 423 struct v4l2_crop crop; 424 struct v4l2_format fmt; 425 unsigned int min; 426 427 if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) { 428 if (EINVAL == errno) { 429 fprintf(stderr, "%s is no V4L2 device\n", 430 dev_name); 431 exit(EXIT_FAILURE); 432 } else { 433 errno_exit("VIDIOC_QUERYCAP"); 434 } 435 } 436 437 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { 438 fprintf(stderr, "%s is no video capture device\n", 439 dev_name); 440 exit(EXIT_FAILURE); 441 } 442 443 switch (io) { 444 case IO_METHOD_READ: 445 if (!(cap.capabilities & V4L2_CAP_READWRITE)) { 446 fprintf(stderr, "%s does not support read i/o\n", 447 dev_name); 448 exit(EXIT_FAILURE); 449 } 450 break; 451 452 case IO_METHOD_MMAP: 453 case IO_METHOD_USERPTR: 454 if (!(cap.capabilities & V4L2_CAP_STREAMING)) { 455 fprintf(stderr, "%s does not support streaming i/o\n", 456 dev_name); 457 exit(EXIT_FAILURE); 458 } 459 break; 460 } 461 462 463 /* Select video input, video standard and tune here. */ 464 465 466 CLEAR(cropcap); 467 468 cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 469 470 if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) { 471 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 472 crop.c = cropcap.defrect; /* reset to default */ 473 474 if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) { 475 switch (errno) { 476 case EINVAL: 477 /* Cropping not supported. */ 478 break; 479 default: 480 /* Errors ignored. */ 481 break; 482 } 483 } 484 } else { 485 /* Errors ignored. */ 486 } 487 488 489 CLEAR(fmt); 490 491 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 492 if (force_format) { 493 fmt.fmt.pix.width = 640; 494 fmt.fmt.pix.height = 480; 495 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 496 fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; 497 498 if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt)) 499 errno_exit("VIDIOC_S_FMT"); 500 501 /* Note VIDIOC_S_FMT may change width and height. */ 502 } else { 503 /* Preserve original settings as set by v4l2-ctl for example */ 504 if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt)) 505 errno_exit("VIDIOC_G_FMT"); 506 } 507 508 /* Buggy driver paranoia. */ 509 min = fmt.fmt.pix.width * 2; 510 if (fmt.fmt.pix.bytesperline < min) 511 fmt.fmt.pix.bytesperline = min; 512 min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height; 513 if (fmt.fmt.pix.sizeimage < min) 514 fmt.fmt.pix.sizeimage = min; 515 516 switch (io) { 517 case IO_METHOD_READ: 518 init_read(fmt.fmt.pix.sizeimage); 519 break; 520 521 case IO_METHOD_MMAP: 522 init_mmap(); 523 break; 524 525 case IO_METHOD_USERPTR: 526 init_userp(fmt.fmt.pix.sizeimage); 527 break; 528 } 529 } 530 531 static void close_device(void) 532 { 533 if (-1 == close(fd)) 534 errno_exit("close"); 535 536 fd = -1; 537 } 538 539 static void open_device(void) 540 { 541 struct stat st; 542 543 if (-1 == stat(dev_name, &st)) { 544 fprintf(stderr, "Cannot identify '%s': %d, %s\n", 545 dev_name, errno, strerror(errno)); 546 exit(EXIT_FAILURE); 547 } 548 549 if (!S_ISCHR(st.st_mode)) { 550 fprintf(stderr, "%s is no devicen", dev_name); 551 exit(EXIT_FAILURE); 552 } 553 554 fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0); 555 556 if (-1 == fd) { 557 fprintf(stderr, "Cannot open '%s': %d, %s\n", 558 dev_name, errno, strerror(errno)); 559 exit(EXIT_FAILURE); 560 } 561 } 562 563 static void usage(FILE *fp, int argc, char **argv) 564 { 565 fprintf(fp, 566 "Usage: %s [options]\n\n" 567 "Version 1.3\n" 568 "Options:\n" 569 "-d | --device name Video device name [%s]\n" 570 "-h | --help Print this message\n" 571 "-m | --mmap Use memory mapped buffers [default]\n" 572 "-r | --read Use read() calls\n" 573 "-u | --userp Use application allocated buffers\n" 574 "-o | --output Outputs stream to stdout\n" 575 "-f | --format Force format to 640x480 YUYV\n" 576 "-c | --count Number of frames to grab [%i]\n" 577 "", 578 argv[0], dev_name, frame_count); 579 } 580 581 static const char short_options[] = "d:hmruofc:"; 582 583 static const struct option 584 long_options[] = { 585 { "device", required_argument, NULL, 'd' }, 586 { "help", no_argument, NULL, 'h' }, 587 { "mmap", no_argument, NULL, 'm' }, 588 { "read", no_argument, NULL, 'r' }, 589 { "userp", no_argument, NULL, 'u' }, 590 { "output", no_argument, NULL, 'o' }, 591 { "format", no_argument, NULL, 'f' }, 592 { "count", required_argument, NULL, 'c' }, 593 { 0, 0, 0, 0 } 594 }; 595 596 int main(int argc, char **argv) 597 { 598 dev_name = "/dev/video0"; 599 600 for (;;) { 601 int idx; 602 int c; 603 604 c = getopt_long(argc, argv, 605 short_options, long_options, &idx); 606 607 if (-1 == c) 608 break; 609 610 switch (c) { 611 case 0: /* getopt_long() flag */ 612 break; 613 614 case 'd': 615 dev_name = optarg; 616 break; 617 618 case 'h': 619 usage(stdout, argc, argv); 620 exit(EXIT_SUCCESS); 621 622 case 'm': 623 io = IO_METHOD_MMAP; 624 break; 625 626 case 'r': 627 io = IO_METHOD_READ; 628 break; 629 630 case 'u': 631 io = IO_METHOD_USERPTR; 632 break; 633 634 case 'o': 635 out_buf++; 636 break; 637 638 case 'f': 639 force_format++; 640 break; 641 642 case 'c': 643 errno = 0; 644 frame_count = strtol(optarg, NULL, 0); 645 if (errno) 646 errno_exit(optarg); 647 break; 648 649 default: 650 usage(stderr, argc, argv); 651 exit(EXIT_FAILURE); 652 } 653 } 654 655 open_device(); 656 init_device(); 657 start_capturing(); 658 mainloop(); 659 stop_capturing(); 660 uninit_device(); 661 close_device(); 662 fprintf(stderr, "\n"); 663 return 0; 664 } 665