Video4linux（v4l）摄像头采集jpeg图片

最新推荐文章于 2023-01-31 12:09:41 发布
最新推荐文章于 2023-01-31 12:09:41 发布
阅读量836 收藏
点赞数
分类专栏： V4L 文章标签： video linux struct components buffer audio

1、Video4linux下视频编程的流程
（1）打开视频设备：
（2） 读取设备信息
（3）更改设备当前设置（没必要的话可以不做）
（4）进行视频采集，两种方法:
        a.内存映射
        b.直接从设备读取
（5）对采集的视频进行处理
（6）关闭视频设备。

2、为程序定义的数据结构

[cpp] view plain copy print ?
  1. typedef struct v4l_struct   
  2. {  
  3.    int fd;  
  4.    struct video_capability capability;  
  5.    struct video_channel channel[4];   
  6.    struct video_picture picture;    
  7.    struct video_window window;   
  8.    struct video_capture capture;   
  9.    struct video_buffer buffer;   
  10.    struct video_mmap mmap;   
  11.    struct video_mbuf mbuf;      
  12.    unsigned char *map;  
  13.    int frame;  
  14.    int framestat[2];   
  15. }vd;  
typedef struct v4l_struct 
{
   int fd;
   struct video_capability capability;
   struct video_channel channel[4]; 
   struct video_picture picture;  
   struct video_window window; 
   struct video_capture capture; 
   struct video_buffer buffer; 
   struct video_mmap mmap; 
   struct video_mbuf mbuf;    
   unsigned char *map;
   int frame;
   int framestat[2]; 
}vd;

3、Video4linux支持的数据结构及其用途

[cpp] view plain copy print ?
  1. struct video_capability  
  2. {  
  3.  char name[32];  
  4.  int type;  
  5.  int channels; /* Num channels */  
  6.  int audios; /* Num audio devices */  
  7.  int maxwidth; /* Supported width */  
  8.  int maxheight; /* And height */  
  9.  int minwidth; /* Supported width */  
  10.  int minheight; /* And height */  
  11. };  
  12. struct video_channel  
  13. {  
  14.  int channel;  
  15.  char name[32];  
  16.  int tuners;  
  17.  __u32  flags;  
  18. #define VIDEO_VC_TUNER  1 /* Channel has a tuner */   
  19. #define VIDEO_VC_AUDIO  2 /* Channel has audio */   
  20.  __u16  type;  
  21. #define VIDEO_TYPE_TV  1   
  22. #define VIDEO_TYPE_CAMERA 2    
  23.  __u16 norm;   /* Norm set by channel */  
  24. };  
  25. struct video_picture  
  26. {  
  27.  __u16 brightness;  
  28.  __u16 hue;  
  29.  __u16 colour;  
  30.  __u16 contrast;  
  31.  __u16 whiteness; /* Black and white only */  
  32.  __u16 depth;  /* Capture depth */  
  33.  __u16   palette; /* Palette in use */  
  34. #define VIDEO_PALETTE_GREY 1 /* Linear greyscale */   
  35. #define VIDEO_PALETTE_HI240 2 /* High 240 cube (BT848) */   
  36. #define VIDEO_PALETTE_RGB565 3 /* 565 16 bit RGB */   
  37. #define VIDEO_PALETTE_RGB24 4 /* 24bit RGB */   
  38. #define VIDEO_PALETTE_RGB32 5 /* 32bit RGB */    
  39. #define VIDEO_PALETTE_RGB555 6 /* 555 15bit RGB */   
  40. #define VIDEO_PALETTE_YUV422 7 /* YUV422 capture */   
  41. #define VIDEO_PALETTE_YUYV 8   
  42. #define VIDEO_PALETTE_UYVY 9 /* The great thing about standards is ... */   
  43. #define VIDEO_PALETTE_YUV420 10   
  44. #define VIDEO_PALETTE_YUV411 11 /* YUV411 capture */   
  45. #define VIDEO_PALETTE_RAW 12 /* RAW capture (BT848) */   
  46. #define VIDEO_PALETTE_YUV422P 13 /* YUV 4:2:2 Planar */   
  47. #define VIDEO_PALETTE_YUV411P 14 /* YUV 4:1:1 Planar */   
  48. #define VIDEO_PALETTE_YUV420P 15 /* YUV 4:2:0 Planar */   
  49. #define VIDEO_PALETTE_YUV410P 16 /* YUV 4:1:0 Planar */   
  50. #define VIDEO_PALETTE_PLANAR 13 /* start of planar entries */   
  51. #define VIDEO_PALETTE_COMPONENT 7 /* start of component entries */   
  52. };  
  53. struct video_window  
  54. {  
  55.  __u32 x,y;   /* Position of window */  
  56.  __u32 width,height;  /* Its size */  
  57.  __u32 chromakey;  
  58.  __u32 flags;  
  59.  struct video_clip *clips; /* Set only */  
  60.  int clipcount;  
  61. #define VIDEO_WINDOW_INTERLACE 1   
  62. #define VIDEO_WINDOW_CHROMAKEY 16 /* Overlay by chromakey */   
  63. #define VIDEO_CLIP_BITMAP -1   
  64. /* bitmap is 1024x625, a '1' bit represents a clipped pixel */  
  65. #define VIDEO_CLIPMAP_SIZE (128 * 625)   
  66. };  
  67. struct video_capture  
  68. {  
  69.  __u32  x,y;   /* Offsets into image */  
  70.  __u32 width, height;  /* Area to capture */  
  71.  __u16 decimation;  /* Decimation divider */  
  72.  __u16 flags;   /* Flags for capture */  
  73. #define VIDEO_CAPTURE_ODD  0 /* Temporal */   
  74. #define VIDEO_CAPTURE_EVEN  1   
  75. };  
  76. struct video_buffer  
  77. {  
  78.  void *base;  
  79.  int height,width;  
  80.  int depth;  
  81.  int bytesperline;  
  82. };  
  83. struct video_mmap  
  84. {  
  85.  unsigned int frame;  /* Frame (0 - n) for double buffer */  
  86.  int  height,width;  
  87.  unsigned int format;  /* should be VIDEO_PALETTE_* */  
  88. };  
  89. #define VIDEO_MAX_FRAME  32   
  90. struct video_mbuf  
  91. {  
  92.  int size;  /* Total memory to map */  
  93.  int frames;  /* Frames */  
  94.  int offsets[VIDEO_MAX_FRAME];  
  95. };  
struct video_capability
{
 char name[32];
 int type;
 int channels; /* Num channels */
 int audios; /* Num audio devices */
 int maxwidth; /* Supported width */
 int maxheight; /* And height */
 int minwidth; /* Supported width */
 int minheight; /* And height */
};
struct video_channel
{
 int channel;
 char name[32];
 int tuners;
 __u32  flags;
#define VIDEO_VC_TUNER  1 /* Channel has a tuner */
#define VIDEO_VC_AUDIO  2 /* Channel has audio */
 __u16  type;
#define VIDEO_TYPE_TV  1
#define VIDEO_TYPE_CAMERA 2 
 __u16 norm;   /* Norm set by channel */
};
struct video_picture
{
 __u16 brightness;
 __u16 hue;
 __u16 colour;
 __u16 contrast;
 __u16 whiteness; /* Black and white only */
 __u16 depth;  /* Capture depth */
 __u16   palette; /* Palette in use */
#define VIDEO_PALETTE_GREY 1 /* Linear greyscale */
#define VIDEO_PALETTE_HI240 2 /* High 240 cube (BT848) */
#define VIDEO_PALETTE_RGB565 3 /* 565 16 bit RGB */
#define VIDEO_PALETTE_RGB24 4 /* 24bit RGB */
#define VIDEO_PALETTE_RGB32 5 /* 32bit RGB */ 
#define VIDEO_PALETTE_RGB555 6 /* 555 15bit RGB */
#define VIDEO_PALETTE_YUV422 7 /* YUV422 capture */
#define VIDEO_PALETTE_YUYV 8
#define VIDEO_PALETTE_UYVY 9 /* The great thing about standards is ... */
#define VIDEO_PALETTE_YUV420 10
#define VIDEO_PALETTE_YUV411 11 /* YUV411 capture */
#define VIDEO_PALETTE_RAW 12 /* RAW capture (BT848) */
#define VIDEO_PALETTE_YUV422P 13 /* YUV 4:2:2 Planar */
#define VIDEO_PALETTE_YUV411P 14 /* YUV 4:1:1 Planar */
#define VIDEO_PALETTE_YUV420P 15 /* YUV 4:2:0 Planar */
#define VIDEO_PALETTE_YUV410P 16 /* YUV 4:1:0 Planar */
#define VIDEO_PALETTE_PLANAR 13 /* start of planar entries */
#define VIDEO_PALETTE_COMPONENT 7 /* start of component entries */
};
struct video_window
{
 __u32 x,y;   /* Position of window */
 __u32 width,height;  /* Its size */
 __u32 chromakey;
 __u32 flags;
 struct video_clip *clips; /* Set only */
 int clipcount;
#define VIDEO_WINDOW_INTERLACE 1
#define VIDEO_WINDOW_CHROMAKEY 16 /* Overlay by chromakey */
#define VIDEO_CLIP_BITMAP -1
/* bitmap is 1024x625, a '1' bit represents a clipped pixel */
#define VIDEO_CLIPMAP_SIZE (128 * 625)
};
struct video_capture
{
 __u32  x,y;   /* Offsets into image */
 __u32 width, height;  /* Area to capture */
 __u16 decimation;  /* Decimation divider */
 __u16 flags;   /* Flags for capture */
#define VIDEO_CAPTURE_ODD  0 /* Temporal */
#define VIDEO_CAPTURE_EVEN  1
};
struct video_buffer
{
 void *base;
 int height,width;
 int depth;
 int bytesperline;
};
struct video_mmap
{
 unsigned int frame;  /* Frame (0 - n) for double buffer */
 int  height,width;
 unsigned int format;  /* should be VIDEO_PALETTE_* */
};
#define VIDEO_MAX_FRAME  32
struct video_mbuf
{
 int size;  /* Total memory to map */
 int frames;  /* Frames */
 int offsets[VIDEO_MAX_FRAME];
};

这些struct都来自videodev.h

4、安装libjpeg
官方网站：http://www.ijg.org/
下载地址：http://www.ijg.org/files/

5、使用v4l的摄像头采集jpeg图像的代码：

[cpp] view plain copy print ?
  1. #include <stdio.h>   
  2. #include <stdlib.h>   
  3. #include <sys/types.h>   
  4. #include <sys/stat.h>   
  5. #include <sys/ioctl.h>   
  6. #include <sys/mman.h>   
  7. #include <fcntl.h>   
  8. #include <errno.h>   
  9. #include <linux/videodev.h>   
  10. #include <jpeglib.h>   
  11. #define WIDTH  320   
  12. #define HEIGHT 240   
  13. #define V4L_DEVICE "/dev/video0"   
  14. int write_jpeg(char *filename,unsigned char *buf,int quality,int width, int height, int gray)  
  15. {  
  16.     struct jpeg_compress_struct cinfo;  
  17.     struct jpeg_error_mgr jerr;  
  18.     FILE *fp;  
  19.     int i;  
  20.     unsigned char *line;  
  21.     int line_length;  
  22.     if (NULL == (fp = fopen(filename,"w")))  
  23.     {  
  24.           fprintf(stderr,"grab: can't open %s: %s\n", filename, strerror(errno));  
  25.           return -1;  
  26.     }  
  27.     cinfo.err = jpeg_std_error(&jerr);  
  28.     jpeg_create_compress(&cinfo);  
  29.     jpeg_stdio_dest(&cinfo, fp);  
  30.     cinfo.image_width  = width;  
  31.     cinfo.image_height = height;  
  32.     cinfo.input_components = gray ? 1: 3;  
  33.     cinfo.in_color_space = gray ? JCS_GRAYSCALE: JCS_RGB;  
  34.     jpeg_set_defaults(&cinfo);  
  35.     jpeg_set_quality(&cinfo, quality, TRUE);  
  36.     jpeg_start_compress(&cinfo, TRUE);  
  37.     line_length = gray ? width : width * 3;  
  38.     for (i = 0, line = buf; i < height; i++, line += line_length)  
  39.         jpeg_write_scanlines(&cinfo, &line, 1);  
  40.     jpeg_finish_compress(&(cinfo));  
  41.     jpeg_destroy_compress(&(cinfo));  
  42.     fclose(fp);  
  43.     return 0;  
  44. }  
  45. int main()  
  46. {  
  47.    unsigned char* buf;  
  48.    int i,j;  
  49.    int fd;  
  50.    int re;  
  51.    struct video_capability vcap;  
  52.    struct video_channel   vc;  
  53.    struct video_mbuf     mbuf;  
  54.    struct video_mmap    map;  
  55.    fd = open(V4L_DEVICE, O_RDWR);  
  56.    if(fd<=0)  
  57.    {  
  58.        perror("open");  
  59.        exit(1);  
  60.    }  
  61.    if(ioctl(fd, VIDIOCGCAP, &vcap)<0)  
  62.    {  
  63.        perror("VIDIOCGCAP");  
  64.        exit(1);  
  65.    }  
  66.    printf("Video Capture Device Name : %s\n",vcap.name);  
  67.    for(i=0;i<vcap.channels;i++)  
  68.    {  
  69.        vc.channel = i;  
  70.        if(ioctl(fd, VIDIOCGCHAN, &vc)<0)  
  71.        {  
  72.            perror("VIDIOCGCHAN");  
  73.            exit(1);  
  74.        }  
  75.        printf("Video Source (%d) Name : %s\n",i, vc.name);  
  76.    }  
  77.    vc.channel=0;  
  78.    if(ioctl(fd, VIDIOCSCHAN, &vc) < 0)  
  79.    {  
  80.        perror("VIDIOCSCHAN");  
  81.        exit(1);  
  82.    }  
  83.    if(ioctl(fd, VIDIOCGMBUF, &mbuf) < 0)  
  84.    {  
  85.        perror("VIDIOCGMBUF");  
  86.        exit(1);  
  87.    }  
  88.    buf=(unsigned char *)mmap(0,mbuf.size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);  
  89.    if((int)buf < 0)  
  90.    {  
  91.        perror("mmap");  
  92.        exit(1);  
  93.    }  
  94.      
  95.    map.frame  = 0;  
  96.    map.height = HEIGHT;  
  97.    map.width  = WIDTH;  
  98.    map.format = VIDEO_PALETTE_RGB24;  
  99.    if(ioctl(fd, VIDIOCMCAPTURE, &map)<0)  
  100.    {  
  101.        perror("VIDIOCMCAPTURE");  
  102.        exit(1);  
  103.    }  
  104.    if(ioctl(fd, VIDIOCSYNC, &map.frame)<0)  
  105.    {  
  106.        perror("VIDIOCSYNC");  
  107.        exit(1);  
  108.    }  
  109.    if(-1==(write_jpeg("./pic001.jpeg",buf,75,WIDTH,HEIGHT,0)))  
  110.    {  
  111.         printf("write_jpeg error\n");  
  112.         exit(1);  
  113.    }  
  114.    munmap(buf,mbuf.size);  
  115.    close(fd);  
  116.    return 0;  
  117. }  
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <errno.h>
#include <linux/videodev.h>
#include <jpeglib.h>
#define WIDTH  320
#define HEIGHT 240
#define V4L_DEVICE "/dev/video0"
int write_jpeg(char *filename,unsigned char *buf,int quality,int width, int height, int gray)
{
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    FILE *fp;
    int i;
    unsigned char *line;
    int line_length;
    if (NULL == (fp = fopen(filename,"w")))
    {
          fprintf(stderr,"grab: can't open %s: %s\n", filename, strerror(errno));
          return -1;
    }
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_stdio_dest(&cinfo, fp);
    cinfo.image_width  = width;
    cinfo.image_height = height;
    cinfo.input_components = gray ? 1: 3;
    cinfo.in_color_space = gray ? JCS_GRAYSCALE: JCS_RGB;
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, quality, TRUE);
    jpeg_start_compress(&cinfo, TRUE);
    line_length = gray ? width : width * 3;
    for (i = 0, line = buf; i < height; i++, line += line_length)
        jpeg_write_scanlines(&cinfo, &line, 1);
    jpeg_finish_compress(&(cinfo));
    jpeg_destroy_compress(&(cinfo));
    fclose(fp);
    return 0;
}
int main()
{
   unsigned char* buf;
   int i,j;
   int fd;
   int re;
   struct video_capability vcap;
   struct video_channel   vc;
   struct video_mbuf     mbuf;
   struct video_mmap    map;
   fd = open(V4L_DEVICE, O_RDWR);
   if(fd<=0)
   {
       perror("open");
       exit(1);
   }
   if(ioctl(fd, VIDIOCGCAP, &vcap)<0)
   {
       perror("VIDIOCGCAP");
       exit(1);
   }
   printf("Video Capture Device Name : %s\n",vcap.name);
   for(i=0;i<vcap.channels;i++)
   {
       vc.channel = i;
       if(ioctl(fd, VIDIOCGCHAN, &vc)<0)
       {
           perror("VIDIOCGCHAN");
           exit(1);
       }
       printf("Video Source (%d) Name : %s\n",i, vc.name);
   }
   vc.channel=0;
   if(ioctl(fd, VIDIOCSCHAN, &vc) < 0)
   {
       perror("VIDIOCSCHAN");
       exit(1);
   }
   if(ioctl(fd, VIDIOCGMBUF, &mbuf) < 0)
   {
       perror("VIDIOCGMBUF");
       exit(1);
   }
   buf=(unsigned char *)mmap(0,mbuf.size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
   if((int)buf < 0)
   {
       perror("mmap");
       exit(1);
   }
   
   map.frame  = 0;
   map.height = HEIGHT;
   map.width  = WIDTH;
   map.format = VIDEO_PALETTE_RGB24;
   if(ioctl(fd, VIDIOCMCAPTURE, &map)<0)
   {
       perror("VIDIOCMCAPTURE");
       exit(1);
   }
   if(ioctl(fd, VIDIOCSYNC, &map.frame)<0)
   {
       perror("VIDIOCSYNC");
       exit(1);
   }
   if(-1==(write_jpeg("./pic001.jpeg",buf,75,WIDTH,HEIGHT,0)))
   {
        printf("write_jpeg error\n");
        exit(1);
   }
   munmap(buf,mbuf.size);
   close(fd);
   return 0;
}

v4l编程的详细介绍：http://blog.youkuaiyun.com/luxiaoxun/archive/2011/05/27/6450783.aspx

在Linux控制台下显示JPEG图像
09-05 1061
/************1、引言通常情况下，在Linux控制台下是无法查看图像文件的，要想查看图像文件，比如要查看JPEG格式的图像文件，可能必须启动X-Windows，通过GNOME或者KDE之类的桌面管理器提供的图像查看工具查看图片内容。那么，能不能有办法在控制台下面简单地浏览图像内容呢。实际上，这是完全可以的。在Linux下有一个名为zgv的看图软件就是工作在控制台下的。不过，由于它所
实验七、Linux V4L摄像头图片捕获实验
最新发布
m0_73939014的博客
01-09 1086
2、配置Ubuntu12.04 Linux虚拟机连接上网，通过apt-get安装v4l-utils工具包，并测试图片显示工具display、gpicview图片查看工具命令的使用，如果缺少gpicview命令，可以通过apt安装gpicview包、4、使用gcc编译v4l2-yuyv-nmap、v4l2-mjpeg-nmap两份代码，阅读并查看代码，使用代码比较软件”Beyond Compare”尝试比较两个代码的区别，了解V4L接口读取图片的两种不同格式代码的调用方法。（描述实验步骤及中间的结果或现象。
v4l采集一帧图像并保存（基于logitech C270）
10-16
vfl采集一帧图像并保存（基于logitech C270），能在s3c6410,s3c2440,s3c2410等多个不同的开发板下运行。
V4L图像采集总结
beyonddream2008的专栏
05-20 7555
 采用中星微ZC301摄像头的V4L图像采集/**********v4l.h*******************/*name :v4l.h  date:2009-5-20  author:kevin  copyright:all is reserved**************************/#ifndef _V4L_H_#define _V4L_
video4linux(v4l)使用摄像头的实例基础教程与体会
嵌入精灵
05-26 1284
作者：d_southd_south@163.com>Blog：http://hi.baidu.com/d_south写作日期：2009前言.写这篇文章的想法和思路由于毕业设计的关系，本人要做一下在linux系统中视频的相关工作比如采集和传输。由于本人是菜鸟一个，所以是需要上网搜一搜看大家都是如何做的，当然开始都是理不出一个头绪，但是很多文章都提到了video4linux(v4l)，
linux 从摄像头采集一帧 jpg,Linux下使用V4L2读取获取拍照（获取静态图像）
weixin_36044132的博客
05-16 933
#include 1. 打开设备intfd=open("/dev/video0",O_RDWR);2. 查询设备属性structv4l2_capabilitycap;ioctl(fd,VIDIOC_QUERYCAP,&cap);3. 设置图像帧格式和像素大小structv4l2_formatfmt;fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTU...
LINUX下采集V4L2摄像头数据源码
11-06
在Linux操作系统中，V4L2（Video for Linux Two）是一个接口层，它允许应用程序访问视频设备，如摄像头。V4L2不仅支持模拟视频，还涵盖了数字视频、JPEG编码/解码、MPEG编码/解码等多种功能，是Linux系统中进行视频...
使用Linux的V4L2读取摄像头数据+Opencv图像处理
11-28
在本文中，我们将深入探讨如何在Linux环境下利用Video4Linux2（V4L2）接口读取摄像头数据，并结合OpenCV库进行图像处理。V4L2是Linux内核提供的一种标准接口，用于与视频捕获设备（如摄像头）进行交互。我们将详细...
采集一张JPEG图片的完整程序.rar_6410开发板_摄像头_采集一张JPEG图片的完整程序
09-21
在采集JPEG图片的过程中，我们需要使用V4L2的缓冲区机制。通过设置捕获模式为JPEG，我们可以直接从摄像头获取压缩后的JPEG图像，而无需经过解码再编码的过程，这有助于提高效率。以下是一个简单的步骤概览： 1. ...
V4L2框架摄像头采集源码.rar
09-04
在这个“V4L2框架摄像头采集源码.rar”压缩包中，包含的“cameratest”文件很可能是C语言编写的示例代码，用于演示如何利用V4L2接口进行摄像头数据的抓取。 V4L2框架主要包含以下几个核心概念： 1. **设备文件**：...
linux-v4l视频采集源码
06-11
本程序是linux下采集视频源码程序，可用于PC上和嵌入式操作系统linux上，经过简单修改即可使用，欢迎下载
v4l2抓取图像并保存到当地
09-12
v4l2编程抓取摄像头yuv数据，并将该yuv数据转换为rgb，rgb再转换为bmp图像保存到本地，并保存yuv数据，可通过tuvtools工具查看
基于v4l的视频采集显示程序。外加QT界面
08-17
Linux下的v4l视频采集播放程序，外加QT界面，可用于视频检控官及安防系统
基于v4l2的摄像头抓图程序,简单的从yuv到bmp转化-v4l2,video to bmp.zip
09-25
基于v4l2的摄像头抓图程序,简单的从yuv到bmp转化-v4l2,video to bmp.zip
linux下V4L视频采集总结
奔跑
06-01 7647
视频采集，调用V4L模块参数进行视频原始数据的采集。熟悉/include/linux/videodev.h，根据这个头文件来定义自己的video device的数据结构，下面是几个重要的数据结构，定义在videodev.h里    struct video_mmap vmmap;struct video_capability videocap;struct video_mbuf videombuf
嵌入式linux采用v4l采集视频源码
yudatun的专栏
05-20 1088
#ifndef LMH_ERR_H#define LMH_ERR_H#include #include #include #include #include #define MAXLINE      4096/*==================================出错处理函数==============================
使用V4L进行简单视频捕捉的基本步骤
嵌入精灵
05-18 1409
1、open the VFL deviceint deviceHandle;char *devicename="/dev/video0";deviceHandle=open(devicename,O_RDWR);if(deviceHandle==-1){//fail to open device}调用成功，返回一个文件标示符；调用失败，返回-1。2、查询设备属性(optional)这一步可以省略，
linux 下V4L的使用例子
jaylin2013的专栏
07-01 1326
<br />#include <stdio.h><br /> #include <string.h><br /> #include <errno.h><br /> #include <fcntl.h><br /> #include <sys/mman.h><br /> #include <linux/videodev.h><br /> #include<sys/types.h><br /> #define VIDEO_PALETTE_RAW_JPEG 20<br /> #define VI
基于Linux系统mjpg_streamer流媒体移植（摄像头驱动移植）
nz189701的博客
01-31 1872
基于Linux系统mjpeg_streamer流媒体移植（摄像头驱动移植）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值