Chinaunix首页 | 论坛 | 博客

zynq_fans的ChinaUnix博客

首页　| 　博文目录　| 　关于我

zynq_fans

  • 博客访问： 83624
  • 博文数量： 30
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 20
  • 用 户 组： 普通用户
  • 注册时间： 2016-11-04 13:04
文章分类

全部博文（30）

文章存档

2017年（6）

2016年（24）

我的朋友
最近访客
推荐博文
相关博文
V4L2采集视频利用TCP协议远程传输

分类： 嵌入式

2016-11-04 13:14:35

原文地址：V4L2采集视频利用TCP协议远程传输 作者：wangtisheng

                    V4L2采集视频利用TCP协议远程传输
开发环境
            system : ubuntu12.04
            board   : mini2440
            arm-linux-gcc : v4.3.2
        说明：该应用将V4L2视频采集和TCP网络传输结合起来，实现了实时视频传输，分为客户端client和服务器端server两部分，客服端采集视频并进行传输，服务器穿接收视频并保存成文件。 客户端编译了arm版本和x86版本，均测试正常。
       本程序仅做学习用~~~~~~~~~~
1.    v4l2_tcp_server.c

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10.   
  11. #define MAXLINE 1024
  12. #define     SERVER_PORT     3333

  14.   
  15. void usage(char *command)
  16. {
  17.     printf("usage :%s filename\n", command);
  18.     exit(0);
  19. }
  20. int main(int argc,char **argv)
  21. {
  22.     struct sockaddr_in serv_addr;
  23.     struct sockaddr_in clie_addr;
  24.     char buf[MAXLINE];
  25.     int sock_id;
  26.     int link_id;
  27.     int recv_len;
  28.     int write_leng;
  29.     int clie_addr_len;
  30.     FILE *fp;
  31.   
  32.     if (argc != 2) {
  33.         usage(argv[0]);
  34.     }
  35.     if ((fp = fopen(argv[1], "w")) == NULL) {
  36.         perror("Open file failed\n");
  37.         exit(0);
  38.     }
  39.     if ((sock_id = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  40.         perror("Create socket failed\n");
  41.         exit(0);
  42.     }
  43.     //memset(&serv_addr, 0, sizeof(serv_addr));
  44.     bzero(&serv_addr,sizeof(serv_addr));
  45.     serv_addr.sin_family = AF_INET;     //IPv4
  46.     serv_addr.sin_port = htons(SERVER_PORT);
  47.     serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  48.   
  49.     if (bind(sock_id, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0 ) {
  50.         perror("Bind socket failed\n");
  51.         exit(0);
  52.     }
  53.   
  54.     if (-1 == listen(sock_id, 10)) {
  55.         perror("Listen socket failed\n");
  56.         exit(0);
  57.     }
  58.     while (1) {
  59.         clie_addr_len = sizeof(clie_addr);
  60.         link_id = accept(sock_id, (struct sockaddr *)&clie_addr, (socklen_t *)&clie_addr_len);
  61.         if (-1 == link_id) {
  62.             perror("Accept socket failed\n");
  63.             exit(0);
  64.         }
  65.         bzero(buf, MAXLINE);
  66.         while ((recv_len = recv(link_id, buf, MAXLINE, 0)) != 0) {
  67.             if(recv_len < 0) {
  68.                 printf("Recieve Data From Server Failed!\n");
  69.                 break;
  70.             }
  71.             printf("#");
  72.             write_leng = fwrite(buf, sizeof(char), recv_len, fp);
  73.             if (write_leng < recv_len) {
  74.                 printf("Write file failed\n");
  75.                 break;
  76.             }
  77.             bzero(buf,MAXLINE);
  78.         }
  79.         printf("\nFinish Recieve\n");
  80.         fclose(fp);
  81.         close(link_id);
  82.     }
  83.     close(sock_id);
  84.     return 0;
  85. }
    Makefile 

点击(此处)折叠或打开

  1. all:v4l2_tcp_server

  3. v4l2_tcp_server:v4l2_tcp_server.c
  4.     gcc -Wall -o $@ $<

  6. clean:
  7.     rm -rf v4l2_tcp_server *.yuv
2.    v4l2_tcp_client.c

点击(此处)折叠或打开

  1. /*
  2.  * V4L2 video capture and tcp transformation example
  3.  * AUTHOT : WANGTISHENG
  4.  * DATA : 2013-12-18
  5.  */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <assert.h>
  10. #include <getopt.h> /* getopt_long() */
  11. #include <fcntl.h> /* low-level i/o */
  12. #include <unistd.h>
  13. #include <errno.h>
  14. #include <sys/stat.h>
  15. #include <sys/types.h>
  16. #include <sys/time.h>
  17. #include <sys/mman.h>
  18. #include <sys/ioctl.h>
  19. #include <sys/socket.h>
  20. #include <netinet/in.h>
  21. #include <arpa/inet.h>
  22. #include <linux/videodev2.h>



  26. #define CLEAR(x) memset(&(x), 0, sizeof(x))

  28. struct buffer {
  29.         void *start;
  30.         size_t length;
  31. };

  33. static char *dev_name;
  34. static int fd = -1;        //DEVICE NUMBER
  35. struct buffer *buffers;
  36. static unsigned int n_buffers;
  37. static int frame_count = 100;
  38. FILE *fp;                                //FILE POINTOR
  39. #define CAPTURE_FILE "./frame_test.yuv"

  41. /* variables and macros for socket */
  42. int sock_id;
  43. #define        SERVER_IP        "192.168.1.121"
  44. #define        CLIENT_PORT        3333
  45. #define     MAXLINE     1024
  46. char buf[MAXLINE];


  49. static void errno_exit(const char *s)
  50. {
  51.         fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno));
  52.         exit(EXIT_FAILURE);
  53. }

  55. static int xioctl(int fh, int request, void *arg)
  56. {
  57.         int r;
  58.         do {
  59.                 r = ioctl(fh, request, arg);
  60.         } while (-1 == r && EINTR == errno);
  61.         return r;
  62. }
  63. //处理函数
  64. static void process_image(const void *p, int size)
  65. {
  66.         int read_len;
  67.         FILE *fp_tmp;
  68.         int    send_len;
  69.     
  70.         fp_tmp = fopen(CAPTURE_FILE,"w");
  71.         fwrite(p,size, 1, fp_tmp);
  72.         fclose(fp_tmp);
  73.         //fwrite(p,size, 1, fp);
  74.         //memset(buf,0,MAXLINE);
  75.         fp_tmp = fopen(CAPTURE_FILE,"r");
  76.         while ((read_len = fread(buf, sizeof(char), MAXLINE, fp_tmp)) >0 ) {
  77.         send_len = send(sock_id, buf, read_len, 0);
  78.         if ( send_len < 0 ) {
  79.             perror("Send file failed\n");
  80.             exit(0);
  81.         }
  82.         //bzero(buf, MAXLINE);         //no use
  83.     }
  84.         fclose(fp_tmp);
  85. }

  87. static int read_frame(FILE *fp)
  88. {
  89.         struct v4l2_buffer buf;
  90.         CLEAR(buf);

  92.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  93.         buf.memory = V4L2_MEMORY_MMAP;
  94.         
  95.         if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf))
  96.                 errno_exit("VIDIOC_DQBUF");
  97.         
  98.         process_image(buffers[buf.index].start, buf.bytesused);

  100.         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
  101.             errno_exit("VIDIOC_QBUF");

  103.         return 1;
  104. }

  106. static void mainloop(void)
  107. {
  108.         unsigned int count;
  109.         count = frame_count;
  110.         while (count-- > 0) {
  111.             printf("No.%d\n",frame_count - count);        //显示当前帧数目
  112.             read_frame(fp);
  113.         }
  114.                 
  115.         printf("\nREAD AND SAVE DONE!\n");
  116. }

  118. static void stop_capturing(void)
  119. {
  120.         enum v4l2_buf_type type;

  122.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  123.         if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
  124.             errno_exit("VIDIOC_STREAMOFF");
  125. }

  127. static void start_capturing(void)
  128. {
  129.         unsigned int i;
  130.         enum v4l2_buf_type type;

  132.         for (i = 0; i < n_buffers; ++i) {
  133.                 struct v4l2_buffer buf;

  135.                 CLEAR(buf);
  136.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  137.                 buf.memory = V4L2_MEMORY_MMAP;
  138.                 buf.index = i;

  140.                 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
  141.                         errno_exit("VIDIOC_QBUF");
  142.         }
  143.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  144.         if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
  145.                 errno_exit("VIDIOC_STREAMON");
  146. }

  148. static void uninit_device(void)
  149. {
  150.         unsigned int i;

  152.         for (i = 0; i < n_buffers; ++i)
  153.                 if (-1 == munmap(buffers[i].start, buffers[i].length))
  154.                         errno_exit("munmap");

  156.         free(buffers);
  157. }



  161. static void init_mmap(void)
  162. {
  163.         struct v4l2_requestbuffers req;

  165.         CLEAR(req);

  167.         req.count = 4;
  168.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  169.         req.memory = V4L2_MEMORY_MMAP;

  171.         if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
  172.                 if (EINVAL == errno) {
  173.                         fprintf(stderr, "%s does not support "
  174.                                  "memory mapping\n", dev_name);
  175.                         exit(EXIT_FAILURE);
  176.                 } else {
  177.                         errno_exit("VIDIOC_REQBUFS");
  178.                 }
  179.         }

  181.         if (req.count < 2) {
  182.                 fprintf(stderr, "Insufficient buffer memory on %s\n",
  183.                          dev_name);
  184.                 exit(EXIT_FAILURE);
  185.         }

  187.         buffers = calloc(req.count, sizeof(*buffers));

  189.         if (!buffers) {
  190.                 fprintf(stderr, "Out of memory\n");
  191.                 exit(EXIT_FAILURE);
  192.         }

  194.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
  195.                 struct v4l2_buffer buf;

  197.                 CLEAR(buf);

  199.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  200.                 buf.memory = V4L2_MEMORY_MMAP;
  201.                 buf.index = n_buffers;

  203.                 if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
  204.                         errno_exit("VIDIOC_QUERYBUF");

  206.                 buffers[n_buffers].length = buf.length;
  207.                 buffers[n_buffers].start =
  208.                         mmap(NULL /* start anywhere */,
  209.                               buf.length,
  210.                               PROT_READ | PROT_WRITE /* required */,
  211.                               MAP_SHARED /* recommended */,
  212.                               fd, buf.m.offset);

  214.                 if (MAP_FAILED == buffers[n_buffers].start)
  215.                         errno_exit("mmap");
  216.         }
  217. }


  220. static void init_device(void)
  221. {
  222.         struct v4l2_capability cap;
  223.         struct v4l2_format fmt;

  225.         if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {        //测试参数
  226.                 if (EINVAL == errno) {
  227.                         fprintf(stderr, "%s is no V4L2 device\n",
  228.                                  dev_name);
  229.                         exit(EXIT_FAILURE);
  230.                 } else {
  231.                         errno_exit("VIDIOC_QUERYCAP");
  232.                 }
  233.         }

  235.         if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
  236.                 fprintf(stderr, "%s is no video capture device\n",
  237.                          dev_name);
  238.                 exit(EXIT_FAILURE);
  239.         }

  241.         if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
  242.                 fprintf(stderr, "%s does not support streaming i/o\n",
  243.                     dev_name);
  244.                 exit(EXIT_FAILURE);
  245.         }




  250.         CLEAR(fmt);
  251.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  252.         fmt.fmt.pix.width = 320;
  253.         fmt.fmt.pix.height = 240;
  254.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  255.         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

  257.         if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))        //设置格式
  258.                 errno_exit("VIDIOC_S_FMT");        
  259.         init_mmap();
  260. }

  262. static void close_device(void)
  263. {
  264.         if (-1 == close(fd))
  265.                 errno_exit("close");

  267.         fd = -1;
  268. }

  270. static void open_device(void)
  271. {
  272.         //加上O_NONBLOCK会出现如下错误
  273.         //VIDIOC_DQBUF error 11, Resource temporarily unavailable
  274.         fd = open(dev_name, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);

  276.         if (-1 == fd) {
  277.                 fprintf(stderr, "Cannot open '%s': %d, %s\n",
  278.                          dev_name, errno, strerror(errno));
  279.                 exit(EXIT_FAILURE);
  280.         }
  281. }

  283. /* tcp initinalization */
  284. int tcp_init(void)    
  285. {
  286.     struct sockaddr_in serv_addr;
  287.     int                  i_ret;
  288.     //sock_id = socket(AF_INET, SOCK_DGRAM, 0);
  289.     if ((sock_id = socket(AF_INET,SOCK_STREAM,0)) < 0) {
  290.         perror("Create socket failed\n");
  291.         exit(0);
  292.     }

  294.     memset(&serv_addr, 0, sizeof(serv_addr));
  295.     serv_addr.sin_family = AF_INET;
  296.     serv_addr.sin_port = htons(CLIENT_PORT);
  297.     serv_addr.sin_addr.s_addr=inet_addr(SERVER_IP);
  298.      
  299.     /* connect the server commented by guoqingbo*/
  300.     i_ret = connect(sock_id, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr));
  301.     if (-1 == i_ret) {
  302.         printf("Connect socket failed\n");
  303.        return -1;
  304.     }
  305.     printf("Socket connected!\n");
  306.     return 0;
  307. }

  309. int main(int argc, char **argv)
  310. {
  311.         dev_name = "/dev/video0";
  312.         
  313.         //if(argc != 1)
  314.         //{
  315.         //    printf("usage :%s filename\n", argv[0]);
  316.         //    exit(0);
  317.         //}
  318.         //if ((fp = fopen(argv[1], "w")) == NULL) {
  319.         //    perror("Creat file failed");
  320.         //    exit(0);
  321.         //}
  322.         tcp_init();
  323.         open_device();
  324.         init_device();
  325.         start_capturing();
  326.         mainloop();                //主要处理均在该函数中实现
  327.         //fclose(fp);
  328.         stop_capturing();
  329.         uninit_device();
  330.         close_device();
  331.         //fprintf(stderr, "\n");
  332.         return 0;
  333. }
    Makefile: 

点击(此处)折叠或打开

  1. all:v4l2_tcp_client_x86 v4l2_tcp_client_arm

  3. v4l2_tcp_client_x86:v4l2_tcp_client.c
  4.     gcc -Wall -o $@ $<
  5. v4l2_tcp_client_arm:v4l2_tcp_client.c
  6.     arm-linux-gcc -Wall -o $@ $<
  7. clean:
  8.     rm -rf v4l2_tcp_client_x86 v4l2_tcp_client_arm
3.    编译测试
    先执行服务器端程序
        # ./v4l2_tcp_server file_receive.yuv
    执行客户端程序
        # ./v4l2_tcp_client_x86 或者
        # ./v4l2_tcp_client_arm 

阅读(1678) | 评论(0) | 转发(0) |
0

上一篇：inet_ntoa函数陷阱

下一篇：基于V4L2、X264、UDP的webcam应用（本地预监）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6