cosmoslhf
cosmoslhf

V4L2驱动程序架构

V4L2驱动程序架构 2012-08-02 10:19:44

分类： 嵌入式

1 V4L2简介

video4linux2(V4L2)是Linux内核中关于视频设备的内核驱动，它为Linux中视频设备访问提供了通用接口，在Linux系统中，V4L2驱动的Video设备节点路径通常/dev/video/中的videoX
V4L2驱动对用户空间提供字符设备，主设备号为81，对于视频设备，其次设备号为0-63。除此之外，次设备号为64-127的Radio设备，次设备号为192-223的是Teletext设备,次设备号为224-255的是VBI设备
V4L2驱动的Video设备在用户空间通过各种ioctl调用进行控制，并且可以使用mmap进行内存映射

1.1 V4L2 驱动主要使用的 ioctl

命令值如下所示：

点击(此处)折叠或打开

  1. #define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability) /*查询能力*/
  2. #define VIDIO_G_FMT _IOWR('V', 4, struct v4l2_format) /*获得格式*/
  3. #define VIDIOC_S_FMT _IOWR('V', 5, struct v4l2_format) /*设置格式*/
  4. #define VIDIOC_REQBUFS _IOWR('V', 8, strut v4l2_requestbuffers) /*申请内存*/
  5. #define VIDIOC_G_FBUF _IOW('V', 10, struct v4l2_framebuffer) /*获得Framebuffer*/
  6. #define VIDIOC_S_BUF _IOW('V', 11, struct v4l2_framebuffer) /*设置Framebuffer*/
  7. #define VIDIOC_OVERLAY _IOW('V', 14, int) /*设置Overlay*/
  8. #define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) /*将内存加入队列*/
  9. #define VIDIOC_DQBUF _IOWR('V', 17, strut v4l2_buffer) /*从队列取出内存*/
  10. #define VIDIOC_STREAMON _IOW('V', 18, int) /*开始流*/
  11. #define VIDIOC_STREAMOFF _IOW('V', 19, int) /*停止流*/
  12. #define VIDIOC_G_CTRL _IOWR('V', 27, struct v4l2_control) /*得到控制*/
  13. #define VIDIOC_S_CTRL _IOWR('V', 28, struct v4l2_control) /*设置控制*/

1.2 重要结构

头文件 include/linux/videodev2.h

include/media/v4l2-dev.h

V4L2驱动核心实现文件：driver/media/video/v4l2-dev.c

v4l2-dev.h中定义的video_device是V4L2驱动程序的核心数据结构

  1. struct video_device
  2. {
  3. const struct v4l2_file_operations *fops;
  4. struct cdev *cdev;//字符设备
  5. struct device *parent;//父设备
  6. struct v4l2_device *v4l2_dev;//父v4l2_device
  7. char name[32];//名称
  8. int vfl_type;//类型
  9. int minor;//次设备号
  10. /*释放回调*/
  11. void (*release)(struct video_device *vdev);
  12. /*ioctl回调*/
  13. const struct v4l2_ioctl_ops *ioctl_ops;
  14. }
  15. 常用的结构
  16. 参见/include/linux/videodev2.h
  17. 1)设备能力结构
  18. struct v4l2_capability
  19. {
  20. __u8 driver[16];//驱动名
  21. __u8 card[32];//例如Hauppauge winTV
  22. __u8 bus_info[32];//PCI总线信息
  23. __u32 version;//内核版本
  24. __u32 capabilities;//设备能力
  25. __u32 reserved[4];
  26. };
  27. 2)数据格式结构
  28. struct v4l2_format
  29. {
  30. enum v4l2_buf_type type;//本结构的数据类型
  31. };
  32. 3)像素格式结构
  33. struct v4l2_pix_format
  34. {
  35. __u32 width;//宽度
  36. __u32 height;//高度
  37. }
  38. 4)请求缓冲
  39. struct v4l2_requestbuffers
  40. {
  41. __u32 count;//缓存数量
  42. enum v4l2_buf_type type;//数据流类型
  43. }
  44. 5)数据流类型包括V4L2_MEMORY_MMAP和V4L2_MEMORY_USERPTR
  45. enum v4l2_memory{
  47. };

点击(此处)折叠或打开


5)数据流类型包括V4L2_MEMORY_MMAP和V4L2_MEMORY_USERPTR enum v4l2_memory{ };

2 V4L2 驱动注册 2.1 video_register_device

video4linux2驱动程序的注册drivers/media/video

video_register_device函数用来注册一个v4l驱动程序

  1. int video_register_device(struct video_device *vdev, int type, int nr)
  2. {
  3. return __video_register_device(vdev, type, nr, 1);
  4. }
  5. 其中参数type支持的类型如下
  6. #define VFL_TYPE_GRABBER 0//视频
  7. #define VFL_TYPE_VBI 1//从视频消隐的时间取得信息的设备
  8. #define VFL_TYPE_RADIO 2 //广播
  9. #define VFL_TYPE_VTX 3//视传设备
  10. #define VFL_TYPE_MAX 4//最大值
  11. ----------------->返回调用 __video_register_device()
  12. __video_register_device 函数先检查设备类型，接下来
  13. 寻找一个可用的子设备号，最后注册相应的字符设备
  14. static int __video_register_device(struct video_device *vdev, int type, int nr, int warn_if_nr_in_use)
  15. {
  17. switch (type) {
  18. case VFL_TYPE_GRABBER:
  19. minor_offset = 0;
  20. minor_cnt = 64;
  21. break;
  22. case VFL_TYPE_RADIO:
  23. minor_offset = 64;
  24. minor_cnt = 64;
  25. break;
  26. case VFL_TYPE_VTX:
  27. minor_offset = 192;
  28. minor_cnt = 32;
  29. break;
  30. case VFL_TYPE_VBI:
  31. minor_offset = 224;
  32. minor_cnt = 32;
  33. break;
  34. nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
  35. }
  36. nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
  37. vdev->cdev->ops = &v4l2_fops;
  38. //注册字符设备
  39. ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
  40. ret = device_register(&vdev->dev);
  41. //注册完毕设备信息存储在video_device数组中
  42. mutex_lock(&videodev_lock);
  43. video_device[vdev->minor] = vdev;
  44. mutex_unlock(&videodev_lock);
  45. }
int video_register_device(struct video_device *vdev, int type, int nr)
{
return __video_register_device(vdev, type, nr, 1);
}
其中参数type支持的类型如下
#define VFL_TYPE_GRABBER 0//视频
#define VFL_TYPE_VBI 1//从视频消隐的时间取得信息的设备
#define VFL_TYPE_RADIO 2 //广播
#define VFL_TYPE_VTX 3//视传设备
#define VFL_TYPE_MAX 4//最大值
----------------->返回调用 __video_register_device() __video_register_device 函数先检查设备类型，接下来寻找一个可用的子设备号，
最后注册相应的字符设备

点击(此处)折叠或打开



2.2 v4l2_fops 接口

v4l2_fops为video4linux2设备提供了统一的应用层接口，v4l2_fops定义如下

  1. static const struct file_operations v4l2_fops = {
  2. .owner = THIS_MODULE,
  3. .read = v4l2_read,
  4. .write = v4l2_write,
  5. .open = v4l2_open,
  6. .get_unmapped_area = v4l2_get_unmapped_area,
  7. .mmap = v4l2_mmap,
  8. .unlocked_ioctl = v4l2_ioctl,
  9. .release = v4l2_release,
  10. .poll = v4l2_poll,
  11. .llseek = no_llseek,
  13. };
  14. v4l2_fops中的成员函数最终要调用struct video_device->fops中相应的成员
  15. struct video_device->fops是具体video4linux2摄像头驱动程序必须实现的接口
  16. static ssize_t v4l2_read(struct file *filp, char __user *buf, size_t sz, loff_t *off)
  17. {
  18. return vdev->fops->read(filp, buf, sz, off);
  19. }

2.3 /drivers/media/video/samsung/fimc/s3c_fimc_core.c

驱动探测函数s3c_fimc_probe定义

  1. static int s3c_fimc_probe(struct platform_device *dev)
  2. {
  3. ctrl = s3c_fimc_register_controller(pdev);
  5. clk_enable(ctrl->clock);//使能时钟
  6. //注册V4L2驱动
  7. ret = video_register_device(ctrl->vd, VFL_TYPE_GRABBER, ctrl->id);
  8. }
  9. s3c_fimc_register_contoller函数主要用来分配资源与申请中断
  10. static struct s3c_fimc_control *s3c_fimc_register_controller(struct platform_device *pdev)
  11. {
  12. ctrl->vd = &s3c_fimc_video_device[id];
  13. //申请中断
  14. ctrl->irq = platform_get_irq(pdev, 0);
  15. if(request_irq(ctrl->irq, s3c_fimc_irq, IRQF_DISABLED, ctrl->name, ctrl))
  16. };
  17. struct video_device s3c_fimc_video_device[S3C_FIMC_MAX_CTRLS] = {
  18. [0] = {
  19. .vfl_type = VID_TYPE_OVERLAY | VID_TYPE_CAPTURE | VID_TYPE_CLIPPING | VID_TYPE_SCALES,
  20. .fops = &s3c_fimc_fops,
  21. .ioctl_ops = &s3c_fimc_v4l2_ops,
  22. .release = s3c_fimc_vdev_release,
  24. .name = "sc3_video0",
  25. },
  26. }

s3c_fimc_v4l2_ops,是在drivers/media/video/samsung/fimc中实现的v4l2_ioctl_ops，在用户空间进行ioctl等调用时，要调用到具体实现的各个函数指针


3 V4L2 操作

3.1 s3c_fimc_open

  1. static int s3c_fimc_open(struct file *filp)
  2. {
  3. struct s3c_fimc_control *ctrl;
  4. int id, ret;
  6. id =0;
  7. ctrl = &s3c_fimc.ctrl[id];
  8. mutex_lock(&ctrl->lock);
  9. if (atomic_read(&ctrl->in_use)) {
  10. ret = -EBUSY;
  11. goto resource_busy;
  12. } else {
  13. atomic_inc(&ctrl->in_use);
  14. s3c_fimc_reset(ctrl);
  15. filp->private_data = ctrl;
  16. }
  17. mutex_unlock(&ctrl->lock);
  18. return 0;
  19. resource_busy:
  20. mutex_unlock(&ctrl->lock);
  21. return ret;
  22. }
  23. 用户空间
  24. 打开设备文件
  25. fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);
用户空间打开设备文件 fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);
3.2 获取设备的capability,查看设备有什么功能

1）结构体

  1. struct v4l2_capability cap;
  2. ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
  3. /include/linux/videodev2.h
  4. struct v4l2_capability {
  5. __u8 driver[16]; /* i.e. "bttv" */
  6. __u8 card[32]; /* i.e. "Hauppauge WinTV" */
  7. __u8 bus_info[32]; /* "PCI:" + pci_name(pci_dev) */
  8. __u32 version; /* should use KERNEL_VERSION() */
  9. __u32 capabilities; /* Device capabilities */
  10. __u32 reserved[4];
  11. };
  12. 驱动实现
  14. static int s3c_fimc_v4l2_querycap(struct file *filp, void *fh,
  15. struct v4l2_capability *cap)
  16. {
  17. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  18. strcpy(cap->driver, "Samsung FIMC Driver");
  19. strlcpy(cap->card, ctrl->vd->name, sizeof(cap->card));
  20. sprintf(cap->bus_info, "FIMC AHB-bus");
  21. cap->version = 0;
  22. cap->capabilities = (V4L2_CAP_VIDEO_OVERLAY | \
  23. V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING);
  24. return 0;
  25. }
  26. 应用层调用
  27. static int video_capability(int fd)
  28. {
  29. int ret = 0;
  30. /***********get the device capability********/
  31. struct v4l2_capability cap;
  32. ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
  33. if (ret < 0) {
  34. perror("VIDIOC_QUERYCAP failed ");
  35. return ret;
  36. }
  38. printf("\n****Capability informations****\n");
  39. printf("driver: %s\n", cap.driver);
  41. if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)
  42. printf("Capture capability is supported\n");
  44. if (cap.capabilities & V4L2_CAP_STREAMING)
  45. printf("Streaming capability is supported\n");
  47. if (cap.capabilities & V4L2_CAP_VIDEO_OVERLAY)
  48. printf("Overlay capability is supported\n");
  50. return 0;
  51. }

3.3 选择视频输入，一个视频设备可以有多个视频输入
  1. 结构体
  2. struct v4l2_input input;
  3. int index;
  4. 得到INPUT
  5. ret = ioctl(fd, VIDIOC_G_INPUT, &index);
  6. input.index = index;
  7. 列举INPUT
  8. ret = ioctl(fd, VIDIOC_ENUMINPUT, &input);
  9. 设置INPUT
  10. ret = ioctl(fd, VIDIOC_S_INPUT, &index);
  12. struct v4l2_input {
  13. __u32 index; /* Which input */
  14. __u8 name[32]; /* Label */
  15. __u32 type; /* Type of input */
  16. __u32 audioset; /* Associated audios (bitfield) */
  17. __u32 tuner; /* Associated tuner */
  18. v4l2_std_id std;
  19. __u32 status;
  20. __u32 capabilities;
  21. __u32 reserved[3];
  22. };
  24. Ioctl: VIDIOC_S_INPUT This IOCTL takes pointer to integer containing index of the input which has to be set. Application will provide the index number as an argument.
  25. 0 - Composite input,
  26. 1 - S-Video input.
  27. 驱动
  28. static int s3c_fimc_v4l2_s_input(struct file *filp, void *fh,
  29. unsigned int i)
  30. {
  31. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  33. if (i >= S3C_FIMC_MAX_INPUT_TYPES)
  34. return -EINVAL;
  36. ctrl->v4l2.input = &s3c_fimc_input_types[i];
  38. if (s3c_fimc_input_types[i].type == V4L2_INPUT_TYPE_CAMERA)
  39. ctrl->in_type = PATH_IN_ITU_CAMERA;
  40. else
  41. ctrl->in_type = PATH_IN_DMA;
  43. return 0;
  44. }
  45. static struct v4l2_input s3c_fimc_input_types[] = {
  46. {
  47. .index = 0,
  48. .name = "External Camera Input",
  49. .type = V4L2_INPUT_TYPE_CAMERA,
  50. .audioset = 1,
  51. .tuner = 0,
  52. .std = V4L2_STD_PAL_BG | V4L2_STD_NTSC_M,
  53. .status = 0,
  54. },
  55. {
  56. .index = 1,
  57. .name = "Memory Input",
  58. .type = V4L2_INPUT_TYPE_MEMORY,
  59. .audioset = 2,
  60. .tuner = 0,
  61. .std = V4L2_STD_PAL_BG | V4L2_STD_NTSC_M,
  62. .status = 0,
  63. }
  64. };
  65. static int s3c_fimc_v4l2_enum_input(struct file *filp, void *fh,
  66. struct v4l2_input *i)
  67. {
  68. if (i->index >= S3C_FIMC_MAX_INPUT_TYPES)
  69. return -EINVAL;
  71. memcpy(i, &s3c_fimc_input_types[i->index], sizeof(struct v4l2_input));
  73. return 0;
  74. }
  75. 应用
  76. static int video_input(int fd)
  77. {
  78. /***********get and set the VIDIO INPUT********/
  79. int ret = 0;
  80. struct v4l2_input input;//视频输入信息，对应命令VIDIOC_ENUMINPUT
  81. int index;
  82. index = 0; //0 - Composite input, 1 - S-Video input.
  84. ret = ioctl (fd, VIDIOC_S_INPUT, &index);
  85. if (ret < 0) {
  86. perror ("VIDIOC_S_INPUT");
  87. return ret;
  88. }
  90. input.index = index;
  91. ret = ioctl (fd, VIDIOC_ENUMINPUT, &input);
  92. if (ret < 0){
  93. perror ("VIDIOC_ENUMINPUT");
  94. return ret;
  95. }
  96. printf("\n****input informations****\n");
  97. printf("name of the input = %s\n", input.name);
  98. return 0;
  99. }
3.4 遍历所有视频格式,查询驱动所支持的格式
  1. 结构
  2. struct v4l2_fmtdes fmtdes;
  3. ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);
  4. struct v4l2_fmtdesc {
  5. __u32 index; /* Format number */
  6. enum v4l2_buf_type type; /* buffer type */
  7. __u32 flags;
  8. __u8 description[32]; /* Description string */
  9. __u32 pixelformat; /* Format fourcc */
  10. __u32 reserved[4];
  11. };
  12. 驱动
  13. static int s3c_fimc_v4l2_enum_fmt_vid_cap(struct file *filp, void *fh,
  14. struct v4l2_fmtdesc *f)
  15. {
  16. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  17. int index = f->index;
  19. if (index >= S3C_FIMC_MAX_CAPTURE_FORMATS)
  20. return -EINVAL;
  22. memset(f, 0, sizeof(*f));
  23. memcpy(f, ctrl->v4l2.fmtdesc + index, sizeof(*f));
  25. return 0;
  26. }
  27. #define S3C_FIMC_MAX_CAPTURE_FORMATS ARRAY_SIZE(s3c_fimc_capture_formats)
  28. const static struct v4l2_fmtdesc s3c_fimc_capture_formats[] = {
  29. {
  30. .index = 0,
  31. .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  32. .flags = FORMAT_FLAGS_PLANAR,
  33. .description = "4:2:0, planar, Y-Cb-Cr",
  34. .pixelformat = V4L2_PIX_FMT_YUV420,
  35. },
  36. {
  37. .index = 1,
  38. .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  39. .flags = FORMAT_FLAGS_PLANAR,
  40. .description = "4:2:2, planar, Y-Cb-Cr",
  41. .pixelformat = V4L2_PIX_FMT_YUV422P,
  43. },
  44. {
  45. .index = 2,
  46. .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  47. .flags = FORMAT_FLAGS_PACKED,
  48. .description = "4:2:2, packed, YCBYCR",
  49. .pixelformat = V4L2_PIX_FMT_YUYV,
  50. },
  51. {
  52. .index = 3,
  53. .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  54. .flags = FORMAT_FLAGS_PACKED,
  55. .description = "4:2:2, packed, CBYCRY",
  56. .pixelformat = V4L2_PIX_FMT_UYVY,
  57. }
  58. };
  59. const static struct v4l2_fmtdesc s3c_fimc_overlay_formats[] = {
  60. {
  61. .index = 0,
  62. .type = V4L2_BUF_TYPE_VIDEO_OVERLAY,
  63. .flags = FORMAT_FLAGS_PACKED,
  64. .description = "16 bpp RGB, le",
  65. .pixelformat = V4L2_PIX_FMT_RGB565,
  66. },
  67. {
  68. .index = 1,
  69. .type = V4L2_BUF_TYPE_VIDEO_OVERLAY,
  70. .flags = FORMAT_FLAGS_PACKED,
  71. .description = "24 bpp RGB, le",
  72. .pixelformat = V4L2_PIX_FMT_RGB24,
  73. },
  74. };
  75. 应用层
  76. static int video_fmtdesc(int fd)
  77. {
  78. /***********Format Enumeration************/
  79. int ret = 0;
  80. struct v4l2_fmtdesc fmtdes;
  81. CLEAR(fmtdes);
  82. fmtdes.index = 0;
  83. fmtdes.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  84. printf("\n**********vidioc enumeration stream format informations:****\n");
  85. while (1) {
  87. ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);
  88. if (ret < 0)
  89. break;
  91. printf("{ pixelformat = %c%c%c%c, description = %s }\n",
  92. (fmtdes.pixelformat & 0xFF),
  93. (fmtdes.pixelformat >> 8) & 0xFF,
  94. (fmtdes.pixelformat >> 16) & 0xFF,
  95. (fmtdes.pixelformat >> 24) & 0xFF,
  96. fmtdes.description);
  98. if (fmtdes.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
  99. printf("video capture type:\n");
  100. if (fmtdes.pixelformat == V4L2_PIX_FMT_YUYV)
  101. printf("V4L2_PIX_FMT_YUYV\n");
  102. fmtdes.index++;
  103. }
  104. return 0;
  105. }
3.5 设置视频捕获格式 （重要）
  1. 结构体
  2. 帧格式包括宽度和高度
  3. struct v4l2_format fmt;
  4. ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
  5. struct v4l2_format {
  6. enum v4l2_buf_type type;//数据流类型，必须是V4L2_BUF_TYPE_VIDEO_CAPTURE
  7. union {
  8. struct v4l2_pix_format pix; /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
  9. struct v4l2_window win; /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
  10. struct v4l2_vbi_format vbi; /* V4L2_BUF_TYPE_VBI_CAPTURE */
  11. struct v4l2_sliced_vbi_format sliced; /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
  12. __u8 raw_data[200]; /* user-defined */
  13. } fmt;
  14. };
  15. struct v4l2_pix_format {
  16. __u32 pixelformat;//视频数据存储类型，例如是YUV4:2:2还是RGB
  17. }
  18. 驱动
  19. static int s3c_fimc_v4l2_s_fmt_vid_cap(struct file *filp, void *fh,
  20. struct v4l2_format *f)
  21. {
  23. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  24. ctrl->v4l2.frmbuf.fmt = f->fmt.pix;
  26. if (f->fmt.pix.priv == V4L2_FMT_IN)
  27. s3c_fimc_set_input_frame(ctrl, &f->fmt.pix);
  28. else
  29. s3c_fimc_set_output_frame(ctrl, &f->fmt.pix);
  31. return 0;
  32. }
  33. int s3c_fimc_set_input_frame(struct s3c_fimc_control *ctrl,
  34. struct v4l2_pix_format *fmt)
  35. {
  36. s3c_fimc_set_input_format(ctrl, fmt);
  38. return 0;
  39. }
  41. static void s3c_fimc_set_input_format(struct s3c_fimc_control *ctrl,
  42. struct v4l2_pix_format *fmt)
  43. {
  44. struct s3c_fimc_in_frame *frame = &ctrl->in_frame;
  46. frame->width = fmt->width;
  47. frame->height = fmt->height;
  49. switch (fmt->pixelformat) {
  50. case V4L2_PIX_FMT_RGB565:
  51. frame->format = FORMAT_RGB565;
  52. frame->planes = 1;
  53. break;
  55. case V4L2_PIX_FMT_RGB24:
  56. frame->format = FORMAT_RGB888;
  57. frame->planes = 1;
  58. break;
  60. case V4L2_PIX_FMT_NV12:
  61. frame->format = FORMAT_YCBCR420;
  62. frame->planes = 2;
  63. frame->order_2p = LSB_CBCR;
  64. break;
  66. case V4L2_PIX_FMT_NV21:
  67. frame->format = FORMAT_YCBCR420;
  68. frame->planes = 2;
  69. frame->order_2p = LSB_CRCB;
  70. break;
  72. case V4L2_PIX_FMT_NV12X:
  73. frame->format = FORMAT_YCBCR420;
  74. frame->planes = 2;
  75. frame->order_2p = MSB_CBCR;
  76. break;
  78. case V4L2_PIX_FMT_NV21X:
  79. frame->format = FORMAT_YCBCR420;
  80. frame->planes = 2;
  81. frame->order_2p = MSB_CRCB;
  82. break;
  84. case V4L2_PIX_FMT_YUV420:
  85. frame->format = FORMAT_YCBCR420;
  86. frame->planes = 3;
  87. break;
  89. case V4L2_PIX_FMT_YUYV:
  90. frame->format = FORMAT_YCBCR422;
  91. frame->planes = 1;
  92. frame->order_1p = IN_ORDER422_YCBYCR;
  93. break;
  95. case V4L2_PIX_FMT_YVYU:
  96. frame->format = FORMAT_YCBCR422;
  97. frame->planes = 1;
  98. frame->order_1p = IN_ORDER422_YCRYCB;
  99. break;
  101. case V4L2_PIX_FMT_UYVY:
  102. frame->format = FORMAT_YCBCR422;
  103. frame->planes = 1;
  104. frame->order_1p = IN_ORDER422_CBYCRY;
  105. break;
  107. case V4L2_PIX_FMT_VYUY:
  108. frame->format = FORMAT_YCBCR422;
  109. frame->planes = 1;
  110. frame->order_1p = IN_ORDER422_CRYCBY;
  111. break;
  113. case V4L2_PIX_FMT_NV16:
  114. frame->format = FORMAT_YCBCR422;
  115. frame->planes = 2;
  116. frame->order_1p = LSB_CBCR;
  117. break;
  119. case V4L2_PIX_FMT_NV61:
  120. frame->format = FORMAT_YCBCR422;
  121. frame->planes = 2;
  122. frame->order_1p = LSB_CRCB;
  123. break;
  125. case V4L2_PIX_FMT_NV16X:
  126. frame->format = FORMAT_YCBCR422;
  127. frame->planes = 2;
  128. frame->order_1p = MSB_CBCR;
  129. break;
  131. case V4L2_PIX_FMT_NV61X:
  132. frame->format = FORMAT_YCBCR422;
  133. frame->planes = 2;
  134. frame->order_1p = MSB_CRCB;
  135. break;
  137. case V4L2_PIX_FMT_YUV422P:
  138. frame->format = FORMAT_YCBCR422;
  139. frame->planes = 3;
  140. break;
  141. }
  142. }
  143. 应用层
  144. static int video_setfmt(int fd)
  145. {
  146. /***********set Stream data format********/
  147. int ret = 0;
  148. struct v4l2_format fmt;
  149. CLEAR(fmt);
  150. fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  151. fmt.fmt.pix.width = 640;
  152. fmt.fmt.pix.height = 480;
  153. fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;//for PAL
  154. fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
  156. ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
  157. if (ret < 0) {
  158. perror("VIDIOC_S_FMT");
  159. return ret;
  160. }
  162. return 0;
  163. }

3.6 视频格式查询

在v4l2中，有两种查询视频格式的方法，一个是遍历所有视频格式的

一个是查询出一种格式的

/*查询出一种格式*/

ret = ioctl(fd, VIDIOC_G_FMT, &fmt);

/*遍历所有视频格式,查询驱动所支持的格式*/

VIDIOC_ENUM_FMT

  1. 驱动
  2. static int s3c_fimc_v4l2_g_fmt_vid_cap(struct file *filp, void *fh,
  3. struct v4l2_format *f)
  4. {
  5. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  6. int size = sizeof(struct v4l2_pix_format);
  8. memset(&f->fmt.pix, 0, size);
  9. memcpy(&f->fmt.pix, &(ctrl->v4l2.frmbuf.fmt), size);
  11. return 0;
  12. }
  13. 应用
  14. static int video_getfmt(int fd)
  15. {
  16. /***********get Stream data format********/
  17. int ret= 0;
  18. struct v4l2_format fmt;
  19. CLEAR(fmt);
  20. fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  21. ret = ioctl(fd, VIDIOC_G_FMT, &fmt);
  22. if (ret < 0) {
  23. perror("VIDIOC_G_FMT");
  24. return ret;
  25. }
  26. printf("/n**********vidioc get stream format informations:****\n");
  27. if (fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
  28. printf("8-bit YUYVV pixel format\n");
  29. printf("Size of the buffer = %d\n", fmt.fmt.pix.sizeimage);
  30. printf("Line offset = %d\n", fmt.fmt.pix.bytesperline);
  31. if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED)
  32. printf("Storate format is interlaced frame format\n");
  34. return 0;
  35. }
    3.7 向驱动申请帧缓冲，内存，一般不超过5个,帧缓冲管理
  1. 结构体
  2. struct v4l2_requestbuffers req;
  3. ret = ioctl(fd, VIDIOC_REQBUFS, &req);
  4. ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);//读取缓存
  6. struct v4l2_requestbuffers {
  7. __u32 count;
  8. enum v4l2_buf_type type;
  9. enum v4l2_memory memory;
  10. __u32 reserved[2];
  11. };
  13. struct v4l2_buffer {
  14. __u32 index;
  15. enum v4l2_buf_type type;
  16. __u32 bytesused;
  17. __u32 flags;
  18. enum v4l2_field field;
  19. struct timeval timestamp;
  20. struct v4l2_timecode timecode;
  21. __u32 sequence;
  23. /* memory location */
  24. enum v4l2_memory memory;
  25. union {
  26. __u32 offset;
  27. unsigned long userptr;
  28. } m;
  29. __u32 length;
  30. __u32 input;
  31. __u32 reserved;
  32. };
  33. 使用VIDIOC_REQBUFS 我们获取了req.count个缓存，下一步通过
  34. 调用VIDIOC_QUERYBUF 命令来获取这些缓存的地址，然后使用
  35. mmap函数转换成应用程序中的绝对地址，最后把这些缓存放入
  36. 缓存队列。
  37. The main steps that the application must perform for buffer allocation are:
  38. Allocating Memory
  39. Getting Physical Address
  40. Mapping Kernel Space Address to User Space
  41. 驱动支持
  43. static int s3c_fimc_v4l2_reqbufs(struct file *filp, void *fh,
  44. struct v4l2_requestbuffers *b)
  45. {
  46. if (b->memory != V4L2_MEMORY_MMAP) {
  47. err("V4L2_MEMORY_MMAP is only supported\n");
  48. return -EINVAL;
  49. }
  51. /* control user input */
  52. if (b->count > 4)
  53. b->count = 4;
  54. else if (b->count < 1)
  55. b->count = 1;
  57. return 0;
  58. }
  59. static int s3c_fimc_v4l2_querybuf(struct file *filp, void *fh,
  60. struct v4l2_buffer *b)
  61. {
  62. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  64. if (b->type != V4L2_BUF_TYPE_VIDEO_OVERLAY && \
  65. b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  66. return -EINVAL;
  68. if (b->memory != V4L2_MEMORY_MMAP)
  69. return -EINVAL;
  71. b->length = ctrl->out_frame.buf_size;
  73. /*
  74. * NOTE: we use the m.offset as an index for multiple frames out.
  75. * Because all frames are not contiguous, we cannot use it as
  76. * original purpose.
  77. * The index value used to find out which frame user wants to mmap.
  78. */
  79. b->m.offset = b->index * PAGE_SIZE;
  81. return 0;
  82. }
  83. static int s3c_fimc_v4l2_qbuf(struct file *filp, void *fh,
  84. struct v4l2_buffer *b)
  85. {
  86. return 0;
  87. }
  88. 应用层
  89. static int video_mmap(int fd)
  90. {
  91. /*******step 1*****requestbuffers Allocating Memory *******/
  92. int ret = 0;
  93. struct v4l2_requestbuffers req;
  94. CLEAR(req);
  95. req.count = 4;
  96. req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  97. req.memory = V4L2_MEMORY_MMAP;
  99. ret = ioctl(fd, VIDIOC_REQBUFS, &req);
  100. if (ret < 0) {
  101. perror("VIDIOC_REQBUFS");
  102. return ret;
  103. }
  105. if (req.count < 2)
  106. printf("insufficient buffer memory\n");
  107. printf("Number of buffers allocated = %d\n", req.count);
  109. /*******step 2*****Getting Physical Address *******/
  110. buffers = calloc(req.count, sizeof(*buffers));
  111. for (n_buffers = 0; n_buffers < req.count; ++n_buffers)
  112. {
  113. struct v4l2_buffer buf;//驱动中的一帧
  114. CLEAR(buf);
  115. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  116. buf.memory = V4L2_MEMORY_MMAP;
  117. buf.index = n_buffers;
  119. ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);
  120. if (ret < 0) {
  121. perror("VIDIOC_QUERYBUF");
  122. return ret;
  123. }
  125. /*******step 3*****Mapping Kernel Space Address to User Space*******/
  126. buffers[n_buffers].length = buf.length;
  127. buffers[n_buffers].start =
  128. mmap(NULL,
  129. buf.length,
  130. PROT_READ | PROT_WRITE,
  131. MAP_SHARED,
  132. fd,
  133. buf.m.offset);
  135. //if (MAP_FAILED == buffers[n_buffers].start)
  136. //perror("mmap failed \n");
  137. }
  139. /************requestbuffers in queue***********/
  140. for (i = 0; i < n_buffers; ++i) {
  141. struct v4l2_buffer buf;
  142. CLEAR(buf);
  144. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  145. buf.memory = V4L2_MEMORY_MMAP;
  146. buf.index = i;
  148. ret = ioctl(fd, VIDIOC_QBUF, &buf);//申请的缓冲进入队列
  149. if (ret < 0) {
  150. perror("VIDIOC_QBUF");
  151. return ret;
  152. }
  153. }
  155. return 0;
  156. }
3.8 开始捕捉图像数据 (重要)
  1. <PRE class=csharp name="code">

    结构体

    <PRE class=csharp name="code">enum v4l2_buf_type type;//开始捕捉图像数据
  2. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  3. ret = ioctl(fd, VIDIOC_STREAMON, &type);
  5. enum v4l2_buf_type {
  6. V4L2_BUF_TYPE_VIDEO_CAPTURE = 1,
  7. V4L2_BUF_TYPE_VIDEO_OUTPUT = 2,
  8. V4L2_BUF_TYPE_VIDEO_OVERLAY = 3,
  9. V4L2_BUF_TYPE_VBI_CAPTURE = 4,
  10. V4L2_BUF_TYPE_VBI_OUTPUT = 5,
  11. V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6,
  12. V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7,
  13. #if 1
  14. /* Experimental */
  15. V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
  16. #endif
  17. V4L2_BUF_TYPE_PRIVATE = 0x80,
  18. };
  20. 驱动
  22. static int s3c_fimc_v4l2_streamon(struct file *filp, void *fh,
  23. enum v4l2_buf_type i)
  24. {
  25. struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;
  26. if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  27. return -EINVAL;
  28. printk("s3c_fimc_v4l2_streamon is called\n");
  29. if (ctrl->in_type != PATH_IN_DMA)
  30. s3c_fimc_init_camera(ctrl);
  32. ctrl->out_frame.skip_frames = 0;
  33. FSET_CAPTURE(ctrl);
  34. FSET_IRQ_NORMAL(ctrl);
  35. s3c_fimc_start_dma(ctrl);
  37. return 0;
  38. }
  39. 硬件控制寄存器的配置
  40. 应用层
  41. static int video_streamon(int fd)
  42. {
  43. int ret = 0;
  45. /************start stream on***********/
  47. enum v4l2_buf_type types;//开始捕捉图像数据
  48. types = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  49. ret = ioctl(fd, VIDIOC_STREAMON, &types);
  50. if (ret < 0) {
  51. perror("VIDIOC_STREAMON");
  52. return ret;
  53. }
  55. return 0;
  56. }

你可能感兴趣的:(V4L2驱动程序架构)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • 学写作的第四天 石声藤
    第四节如何坚持长期写下去？①摘要学好写作，重要的是持续性。如何坚持，就从淡化“坚持”这个词开始。做很多事，根本不是用坚持来驱动的，而是你清晰的认识，这件事很重要，你才坚持。②从本质认识写作的重要性意识决定人的行动。如果你从本质认识到某件事的重要性，即使没人逼你，你也会去坚持做，比如赚钱。认识写作的重要性，不认识，重新多学几遍第一节。③要让自己不断从写作中收益一件事能不断给你带来回报，是驱动你坚持做
  • 以研发创新为驱动力，黄山谷捷助力新能源汽车产业高质量发展 L913197600 黄山谷捷制造科技
    在新能源汽车产业蓬勃发展的浪潮中，车规级功率半导体作为驱动电机控制系统的核心部件，其性能与稳定性直接关系到汽车的动力输出、能效转化及安全性能。在这一关键领域，黄山谷捷股份有限公司（以下简称“黄山谷捷”或“公司”）以卓越的研发实力、精湛的生产工艺和严格的质量控制体系，成为行业内的佼佼者，特别是在功率半导体散热基板领域，更是树立了新的标杆。自2012年成立以来，黄山谷捷便深谙“科技是第一生产力”的真谛
  • 《算法》四学习——1.1节 进阶的Farmer 算法算法笔记
    前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
  • macOs mojave 添加hp laserjet 1020 打印机方法。 Coder_Zh
    1.设置--》打印机与扫描仪。2.点击“+”选择IP3.输入地址：（写网络IP），协议选择：hpjetdirect-socket4.使用选项：选择hplaserjet10221.6（没有1020的驱动，但是1022的驱动兼容1020可以使用。）测试OK，可以使用。
  • 《刘润商业洞察力》：结构性张力 飘皓宇
    结构性张力是发现理想与现实的差距后忍不住缩小期望与现实之间差距的力量，它是增强回路系统里的“元动力”。这个原动力通常要靠我们自己的努力和奋斗来填平，也就是自驱动。自驱动除了使命以外，还可以靠外力吗？按照弗鲁姆的“期望理论”是可以建立员工个体的自驱力的。如果你用找“结构性张力”的视角找“元动力”，世界就不一样了。比如，美丽，是女孩子买漂亮衣服的元动力吗？准确地说，不是。和美丽之间的“差距”，才是。成
  • 目标和问题驱动 blue_panda
    持续成长，实践起来会有各种坑，虽然目标是很好的，但执行的过程中，确会有这样和那样的问题，现在就碰到了一些问题，目标，起点和路径不是那么清晰。出了问题，不怕。只要能发现问题，分析问题，制定方案，再执行对照目标和结果的偏差，肯定能够逐步的去解决的。
  • 究竟是什么决定了你的自驱动力 Aichris
    人所拥有的任何东西，都可以被剥夺，唯独人性最后的自由——也就是在任何境遇中选择一己态度和生活方式的自由——不能被剥夺。奥地利维克多-弗兰克你现在的状况，是由你之前的每一次选择和历史的积累决定的。我很相信这点，每次遇到事情不开心的时候，看看弗兰克这段话，深呼吸，让自己平静下来。昨天早上做飞机回上海开会，旁边做了一个外国妹子，很想和她沟通一下，但是不是很自信。她和同伴沟通的时候，我尝试听了一下，还是能
  • 24营2组锋妈11月13日作业及阅读笔记 锋妈
    第一部分，听课心得在《时间管理目标模型课程》中，主要学到了如下四点：一、为什么要制定目标二、怎么样制定目标三、制定目标后要做些什么四、立刻行动起来听完后，对照讲课提纲，是自身的存在的弱点，觉着最大的绊脚石是第四点立刻行动起来。因为再宏伟的目标，再强大的驱动力下，如果没有行动去执行，一切都是空谈。为了避免执行力弱化，结合自己目前实际情况，觉着尽量把目标制定的简单明了、可执行、可衡量、可反馈回顾的。只
  • 深入理解AOP（面向切面编程）及其应用 自身就是太阳 java开发语言spring
    目录AOP的核心概念AOP的实现方式1.定义DAO接口和实现类2.定义通知类3.开启AOP注解驱动切入点表达式通配符的使用：AOP通知类型案例分析：测量业务层接口的执行效率结论概述：AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，主要用于将共性功能从具体的业务逻辑中分离出来，实现松耦合的代码设计。其作用是在不修改原始代码的情况下，对现有方法进行增强，广泛
  • 我们在读书会尝试OKR，结果成了PDCA 湖边的阿曦
    “读书要玩味，好玩又有味。”前面有了不成熟的理解——《OKR的优势是什么？它的实践原则有哪些？》，现在又有了不成熟的实践——在读书会尝试OKR。我们的现状我们读书会是个小组织，每个月一次线下活动，每次参加人数在10位左右。也是个自组织，没有管理员，没有固定组织者，只有每次活动时的临时主持者。我们也没有任何规定，一切基于个人的自我驱动及相互尊重。活动的内容，可能是一本书，也可能是一个主题。在活动前，
  • 【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信 月夜星辉雪 rabbitmq网络分布式c++后端服务器linux
    一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
  • Linux驱动-字符设备驱动 Vis-Lin Linux驱动linux驱动开发运维单片机物联网
    Linux驱动-字符设备驱动前言一、预备知识1、file_operations结构体2、地址映射二、涉及的API函数1、字符设备驱动1.1、设备号1.1.1、register_chrdev_region函数1.1.2、alloc_chrdev_region函数1.1.3、unregister_chrdev_region函数1.2、字符设备1.2.1、cdev_init函数1.2.2、dev_add
  • Linux驱动开发-字符设备驱动开发 可能只会写BUG linuxlinux驱动开发c语言linux驱动开发运维
    linux驱动开发1.驱动程序的类型2.驱动开发流程字符设备驱动1.基本概念2.字符设备驱动的基本结构架构字符设备驱动开发中常用的API示例以下代码加入了设备类和设备实例的创建linux驱动开发1.驱动程序的类型在Linux中，驱动程序主要有以下几种类型：字符设备驱动：处理字节流的设备，如串口、键盘等。它们通过字符设备接口（如/dev/tty）与用户空间进行交互。块设备驱动：处理块存储设备，如硬盘
  • 全面指南：用户行为从前端数据采集到实时处理的最佳实践 数字沉思 营销流量运营系统架构前端内容运营大数据
    引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
  • 如何搭建一个ip池用来做数据抓取用 KookeeyLena4 tcp/ip网络服务器
    在当今的数据驱动时代，数据抓取成为了获取网络信息的重要手段。然而，频繁的数据抓取活动可能会触发网站的安全机制，导致IP被封禁。为了维持数据抓取的持续性和稳定性，构建一个有效的IP池变得至关重要。本文将详细介绍如何搭建一个用于数据抓取的IP池，以及相关的策略和最佳实践。一、IP池的概念IP池是一个包含多个IP地址的集合，这些IP地址可以是动态的，也可以是静态的，用于在数据抓取过程中轮换使用，以避免因
  • [RS] 制作问题记录 _Walker__
    1、时间冻结遇上卡顿，战斗表现与逻辑脱节1.1做法设定时间冻结：Time.timeScale=0冻结与恢复的控制：用UnScaledFrameTimer执行战斗逻辑：用ScaledFrameTimer驱动冻结效果：当前施法的单位正常行动，其他单位冻结逻辑与表现匹配方式：完整的逻辑帧中减去冻结的帧数，当前表现的TML忽略TimeScale正常播放TML基于时间播放：其本身有追帧效果1.2脱节问题点与
  • 马可·奥勒留·安东尼丨帝王日课 D 214 丨张伟丨
    帝王日课丨文/张伟乐之写作工作坊这是椰子私塾第1918篇原创输出每天审视生活。D214D214我在哪里可以找到自信？一直想写小说，一直没有开始写。这大概就是缺少自信的表现吧。一直想学弹吉他，一直没有学会，这也是缺少自信吧。自信很重要，是做事最强大的驱动力，如何建立自信呢？从网上看了一些书，介绍了很多建立自信的方法。我得到一个结论——自信只有靠自己找，别人的方法并不一定适合你，不过我们可以从中找到一
  • 数字化智能工厂数字化供应链架构、全景管理、全流程贯通方案 数字化建设方案 智能制造数字工厂制造业数字化转型工业互联网架构
    随着信息技术的飞速发展，数字化转型已成为制造企业提升竞争力的关键途径。数字化智能工厂通过集成先进的物联网(IoT)、大数据、云计算、人工智能(AI)等技术，实现了生产过程的智能化、供应链管理的精准化及决策的科学化。本方案旨在构建一套完善的数字化供应链架构，实现全景管理、全流程贯通、智慧化升级，以数据为驱动，强化技术支撑与安全管理体系，推动企业向智能制造迈进。一、数字化供应链架构1.**集成化平台构
  • 系统架构师软考历年论文题目（2009-2024年）及分析 pccai-vip 系统架构师系统架构
    时间题目20091.论基于DSSA的软件架构设计与应用；2.论信息系统建模方法；3.论基于REST服务的Web应用系统设计；4.论软件可靠性设计与应用20101.论软件的静态演化和动态演化及其应用；2.论数据挖掘技术的应用；3.论大规模分布式系统缓存设计策略；4.论软件可靠性评价20111.论模型驱动架构在系统开发中的应用；2.论企业集成平台的架构设计；3.论企业架构管理与应用；4.论软件需求获取
  • 北斗赋能万物互联：新质生产力的强劲驱动力 GeoSaaS 地理信息智慧城市机器人物联网人工智能无人机
    在数字化转型的大潮中，中国自主研制的北斗卫星导航系统，作为国家重大空间基础设施，正以前所未有的力量推动着万物互联时代的到来，成为新质生产力发展的重要基石。本文将深入剖析北斗系统如何以其独特的技术优势和广泛应用场景，为各行业注入新的活力，加速经济社会的智能化升级。一、北斗系统的战略地位与技术演进自2000年第一颗北斗导航卫星成功发射以来，北斗系统经历了从试验系统到全球组网的历史性跨越，如今已成为与G
  • 学会提问很重要 Jerusalem4
    最近有一点很深的感触：学会提问很重要。为什么这么说？有两点现状正在驱动并让我意识到这一点。1.跟人聊天，需要有自己的想法，想法从哪里来？从独立思考里来，思考就需要多问问题，而学会提问是独立思考中很重要的一步。2.我现在开始做一些管理上的事情，管理中，有很多内容，需要我去思考去指导的，包括这个任务客户希望达到一个怎样的效果/结果？为了达成这个结果，我们需要怎样去做，去拆解任务？拆解任务之后，如何去把
  • Java 并发包之线程池和原子计数 lijingyao8206 Java计数ThreadPool并发包java线程池
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。     这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
  • java编程思想 抽象类和接口 百合不是茶 java抽象类接口
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持   1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错)   抽象方法 : 在方法中仅有声明而没有方法体    package com.wj.Interface;
  • [房地产与大数据]房地产数据挖掘系统 comsci 数据挖掘
           随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间...        所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产     &nb
  • 数组队列总结 沐刃青蛟 数组队列
          数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。      以下是数组队列的功能实现代码：   import List.Student; public class
  • Oracle存储过程无法编译的解决方法 IT独行者 oracle存储过程　
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。   1.     查看无效对象 XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
  • 重装系统之后oracle恢复 文强chu oracle
    前几天正在使用电脑，没有暂停oracle的各种服务。 突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 直接把我的c盘给格式化了 并且清理了注册表，再装系统。 然后的结果就是我的oracl
  • python学习二（ 一些基础语法） 小桔子 pthon基础语法
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 1.ptyhon的源文件以UTF-8编码格式 2. /   除 结果浮点型 //  除 结果整形 %   除 取余数 *   乘 **  乘方 eg 5**2 结果是5的2次方25 _&
  • svn 常用命令 aichenglong SVN版本回退
    1 svn回退版本   1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 两者的区别:   revert this version:表示回退到当前版本(该版本后的版本全部作废)   revert chanages from this versio
  • 某小公司面试归来 alafqq 面试
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 老拿这些对付毕业生的东东来吓唬我。。 面试官很刁难，问了几个问题，记录下； 1，包的范围。。。public,private,protect. --悲剧了 2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 4，stru
  • 动态数组的存储速度比较 集合框架 百合不是茶 集合框架
    集合框架： 自定义数据结构(增删改查等) package 数组; /** * 创建动态数组 * @author 百合 * */ public class ArrayDemo{ //定义一个数组来存放数据 String[] src = new String[0]; /** * 增加元素加入容器 * @param s要加入容器
  • 用JS实现一个JS对象，对象里有两个属性一个方法 bijian1013 js对象
    <html> <head> </head> <body> 用js代码实现一个js对象，对象里有两个属性，一个方法 </body> <script> var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){
  • 探索JUnit4扩展：使用Rule bijian1013 java单元测试JUnitRule
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 1. Rule       &n
  • [Gson一]非泛型POJO对象的反序列化 bit1129 POJO
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 1. POJO对象不包含任何泛型的字段 2. POJO对象包含泛型字段，例如泛型集合或者泛型类 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO    
  • 【Kakfa五】Kafka Producer和Consumer基本使用 bit1129 kafka
    0.Kafka服务器的配置 一个Broker， 一个Topic Topic中只有一个Partition（）   1. Producer： package kafka.examples.producers; import kafka.producer.KeyedMessage; import kafka.javaapi.producer.Producer; impor
  • lsyncd实时同步搭建指南——取代rsync+inotify ronin47
    1. 几大实时同步工具比较 1.1 inotify + rsync 最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果 bylijinnan java
    public class IsBinTreePostTraverse{ static boolean isBSTPostOrder(int[] a){ if(a==null){ return false; } /*1.只有一个结点时，肯定是查找树 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是 6 {6,5}对应的BST是
  • MySQL的sum函数返回的类型 bylijinnan javaspringsqlmysqljdbc
    今天项目切换数据库时，出错 访问数据库的代码大概是这样： String sql = "select sum(number) as sumNumberOfOneDay from tableName"; List<Map> rows = getJdbcTemplate().queryForList(sql); for (Map row : rows
  • java设计模式之单例模式 chicony java设计模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的结构 　　单例模式的特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 　　饿汉式单例类   publ
  • javascript取当月最后一天 ctrain JavaScript
    <!--javascript取当月最后一天--> <script language=javascript> var current = new Date(); var year = current.getYear(); var month = current.getMonth(); showMonthLastDay(year, mont
  • linux tune2fs命令详解 daizj linuxtune2fs查看系统文件块信息
    一.简介： tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 二.用法： Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
  • 做有中国特色的程序员 dcj3sjt126com 程序员
      从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
  • Android：TextView属性大全 dcj3sjt126com textview
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
  • tomcat虚拟目录安装及其配置 eksliang tomcat配置说明tomca部署web应用tomcat虚拟目录安装
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 1.-------------------------------------------tomcat  目录结构 config：存放tomcat的配置文件 temp  ：存放tomcat跑起来后存放临时文件用的 work   ： 当第一次访问应用中的jsp
  • 浅谈：APP有哪些常被黑客利用的安全漏洞 gg163 APP
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 1. 应用反编译漏洞：APK 包非常容易被反编译成可读
  • C#根据网址生成静态页面 hvt Web.netC#asp.nethovertree
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法：   bool CreateHtmlFile(string url, string path) { //http://keleyi.com/a/bjae/3d10wfax.htm stri
  • SVG 教程 （一） 天梯梦 svg
    SVG 简介 SVG 是使用 XML 来描述二维图形和绘图程序的语言。 学习之前应具备的基础知识： 继续学习之前，你应该对以下内容有基本的了解： HTML XML 基础 如果希望首先学习这些内容，请在本站的首页选择相应的教程。 什么是SVG？ SVG 指可伸缩矢量图形 (Scalable Vector Graphics) SVG 用来定义用于网络的基于矢量
  • 一个简单的java栈 luyulong java数据结构栈
    public class MyStack { private long[] arr; private int top; public MyStack() { arr = new long[10]; top = -1; } public MyStack(int maxsize) { arr = new long[maxsize]; top
  • 基础数据结构和算法八：Binary search sunwinner AlgorithmBinary search
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 刘星宇 c面试
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 1.gets()函数 问：请找出下面代码里的问题： #include<stdio.h> int main(void) {     char buff[10];     memset(buff,0,sizeof(buff));
  • ITeye 7月技术图书有奖试读获奖名单公布 ITeye管理员 活动ITeye试读
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 7月试读活动回顾： http://webmaster.iteye.com/blog/2092746 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《Java性能优化权威指南》
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他