linux camera程序,V4L2 Camera 驱动 Capture测试程序

最新推荐文章于 2023-08-15 10:11:46 发布
最新推荐文章于 2023-08-15 10:11:46 发布
阅读量640 收藏
点赞数
文章标签： linux camera程序

在网上找了一个测试程序， 看了看，是根据capture.c修改的。测试步骤如下

1. gcc -o capture_image capture_image.c

2. ctrl+alt+f1 切换到Ubuntu的控制台，切换到控制台模式是因为在图形模式下看不到测试图形，这可能和framebuffer的设置有关

3. sudo modprobe vivi

4. sudo ./capture_image -d /dev/video0

这时可以看到在屏幕左上角有一个640x480大小窗口，内容是彩色条格，彩色条格不停的移动，持续时间5秒

在ubuntu下还可以使用cheese测试

1.  sudo apt-get install cheese

2. sudo modprobe vivi

2. 启动 cheese后，就可以看到滚动的彩色条格

附上测试程序

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

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

struct buffer {

void * start;

size_t length;

};

static char * dev_name = NULL;

static int fd = -1;

struct buffer * buffers = NULL;

static unsigned int n_buffers = 0;

static int time_in_sec_capture=5;

static int fbfd = -1;

static struct fb_var_screeninfo vinfo;

static struct fb_fix_screeninfo finfo;

static char *fbp=NULL;

static long screensize=0;

static void errno_exit (const char * s)

{

fprintf (stderr, "%s error %d, %s/n",s, errno, strerror (errno));

exit (EXIT_FAILURE);

}

static int xioctl (int fd,int request,void * arg)

{

int r;

do r = ioctl (fd, request, arg);

while (-1 == r && EINTR == errno);

return r;

}

inline int clip(int value, int min, int max) {

return (value > max ? max : value < min ? min : value);

}

static void process_image (const void * p){

//ConvertYUVToRGB32

1;

unsigned char* in=(char*)p;

int width=640;

int height=480;

int istride=1280;

int x,y,j;

int y0,u,y1,v,r,g,b;

long location=0;

for ( y = 100; y < height + 100; ++y) {

for (j = 0, x=100; j < width * 2 ; j += 4,x +=2) {

location = (x+vinfo.xoffset) * (vinfo.bits_per_pixel/8) +

(y+vinfo.yoffset) * finfo.line_length;

y0 = in[j];

u = in[j + 1] - 128;

y1 = in[j + 2];

v = in[j + 3] - 128;

r = (298 * y0 + 409 * v + 128) >> 8;

g = (298 * y0 - 100 * u - 208 * v + 128) >> 8;

b = (298 * y0 + 516 * u + 128) >> 8;

fbp[ location + 0] = clip(b, 0, 255);

fbp[ location + 1] = clip(g, 0, 255);

fbp[ location + 2] = clip(r, 0, 255);

fbp[ location + 3] = 255;

r = (298 * y1 + 409 * v + 128) >> 8;

g = (298 * y1 - 100 * u - 208 * v + 128) >> 8;

b = (298 * y1 + 516 * u + 128) >> 8;

fbp[ location + 4] = clip(b, 0, 255);

fbp[ location + 5] = clip(g, 0, 255);

fbp[ location + 6] = clip(r, 0, 255);

fbp[ location + 7] = 255;

}

in +=istride;

}

}

static int read_frame (void)

{

struct v4l2_buffer buf;

unsigned int i;

CLEAR (buf);

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {

switch (errno) {

case EAGAIN:

return 0;

case EIO:

default:

errno_exit ("VIDIOC_DQBUF");

}

}

assert (buf.index < n_buffers);

printf("v4l2_pix_format->field(%d)/n", buf.field);

//assert (buf.field ==V4L2_FIELD_NONE);

process_image (buffers[buf.index].start);

if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))

errno_exit ("VIDIOC_QBUF");

return 1;

}

static void run (void)

{

unsigned int count;

int frames;

frames = 30 * time_in_sec_capture;

while (frames-- > 0) {

for (;;) {

fd_set fds;

struct timeval tv;

int r;

FD_ZERO (&fds);

FD_SET (fd, &fds);

tv.tv_sec = 2;

tv.tv_usec = 0;

r = select (fd + 1, &fds, NULL, NULL, &tv);

if (-1 == r) {

if (EINTR == errno)

continue;

errno_exit ("select");

}

if (0 == r) {

fprintf (stderr, "select timeout/n");

exit (EXIT_FAILURE);

}

if (read_frame ())

break;

}

}

}

static void stop_capturing (void)

{

enum v4l2_buf_type type;

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))

errno_exit ("VIDIOC_STREAMOFF");

}

static void start_capturing (void)

{

unsigned int i;

enum v4l2_buf_type type;

for (i = 0; i < n_buffers; ++i) {

struct v4l2_buffer buf;

CLEAR (buf);

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = i;

if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))

errno_exit ("VIDIOC_QBUF");

}

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))

errno_exit ("VIDIOC_STREAMON");

}

static void uninit_device (void)

{

unsigned int i;

for (i = 0; i < n_buffers; ++i)

if (-1 == munmap (buffers[i].start, buffers[i].length))

errno_exit ("munmap");

if (-1 == munmap(fbp, screensize)) {

printf(" Error: framebuffer device munmap() failed./n");

exit (EXIT_FAILURE) ;

}

free (buffers);

}

static void init_mmap (void)

{

struct v4l2_requestbuffers req;

//mmap framebuffer

fbp = (char *)mmap(NULL,screensize,PROT_READ | PROT_WRITE,MAP_SHARED ,fbfd, 0);

if ((int)fbp == -1) {

printf("Error: failed to map framebuffer device to memory./n");

exit (EXIT_FAILURE) ;

}

memset(fbp, 0, screensize);

CLEAR (req);

req.count = 4;

req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

req.memory = V4L2_MEMORY_MMAP;

if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {

if (EINVAL == errno) {

fprintf (stderr, "%s does not support memory mapping/n", dev_name);

exit (EXIT_FAILURE);

} else {

errno_exit ("VIDIOC_REQBUFS");

}

}

if (req.count < 4) {    //if (req.count < 2)

fprintf (stderr, "Insufficient buffer memory on %s/n",dev_name);

exit (EXIT_FAILURE);

}

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

if (!buffers) {

fprintf (stderr, "Out of memory/n");

exit (EXIT_FAILURE);

}

for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {

struct v4l2_buffer buf;

CLEAR (buf);

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))

errno_exit ("VIDIOC_QUERYBUF");

buffers[n_buffers].length = buf.length;

buffers[n_buffers].start =mmap (NULL,buf.length,PROT_READ | PROT_WRITE ,MAP_SHARED,fd, buf.m.offset);

if (MAP_FAILED == buffers[n_buffers].start)

errno_exit ("mmap");

}

}

static void init_device (void)

{

struct v4l2_capability cap;

struct v4l2_cropcap cropcap;

struct v4l2_crop crop;

struct v4l2_format fmt;

unsigned int min;

// Get fixed screen information

if (-1==xioctl(fbfd, FBIOGET_FSCREENINFO, &finfo)) {

printf("Error reading fixed information./n");

exit (EXIT_FAILURE);

}

// Get variable screen information

if (-1==xioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) {

printf("Error reading variable information./n");

exit (EXIT_FAILURE);

}

screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8;

if (-1 == xioctl (fd, VIDIOC_QUERYCAP, ∩)) {

if (EINVAL == errno) {

fprintf (stderr, "%s is no V4L2 device/n",dev_name);

exit (EXIT_FAILURE);

} else {

errno_exit ("VIDIOC_QUERYCAP");

}

}

if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {

fprintf (stderr, "%s is no video capture device/n",dev_name);

exit (EXIT_FAILURE);

}

if (!(cap.capabilities & V4L2_CAP_STREAMING)) {

fprintf (stderr, "%s does not support streaming i/o/n",dev_name);

exit (EXIT_FAILURE);

}

CLEAR (cropcap);

cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {

crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

crop.c = cropcap.defrect;

if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {

switch (errno) {

case EINVAL:

break;

default:

break;

}

}

}else {    }

CLEAR (fmt);

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

fmt.fmt.pix.width = 640;

fmt.fmt.pix.height = 480;

fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))

errno_exit ("VIDIOC_S_FMT");

init_mmap ();

}

static void close_device (void)

{

if (-1 == close (fd))

errno_exit ("close");

fd = -1;

close(fbfd);

}

static void open_device (void)

{

struct stat st;

if (-1 == stat (dev_name, &st)) {

fprintf (stderr, "Cannot identify '%s': %d, %s/n",dev_name, errno, strerror (errno));

exit (EXIT_FAILURE);

}

if (!S_ISCHR (st.st_mode)) {

fprintf (stderr, "%s is no device/n", dev_name);

exit (EXIT_FAILURE);

}

//open framebuffer

fbfd = open("/dev/fb0", O_RDWR);

if (fbfd==-1) {

printf("Error: cannot open framebuffer device./n");

exit (EXIT_FAILURE);

}

//open camera

fd = open (dev_name, O_RDWR| O_NONBLOCK, 0);

if (-1 == fd) {

fprintf (stderr, "Cannot open '%s': %d, %s/n",dev_name, errno, strerror (errno));

exit (EXIT_FAILURE);

}

}

static void usage (FILE * fp,int argc,char ** argv)

{

fprintf (fp,

"Usage: %s [options]/n/n"

"Options:/n"

"-d | --device name Video device name [/dev/video]/n"

"-h | --help Print this message/n"

"-t | --how long will display in seconds/n"

"",

argv[0]);

}

static const char short_options [] = "d:ht:";

static const struct option long_options [] = {

{ "device", required_argument, NULL, 'd' },

{ "help", no_argument, NULL, 'h' },

{ "time", no_argument, NULL, 't' },

{ 0, 0, 0, 0 }

};

int main (int argc,char ** argv)

{

dev_name = "/dev/video0";

for (;;)

{

int index;

int c;

c = getopt_long (argc, argv,short_options, long_options,&index);

if (-1 == c)

break;

switch (c) {

case 0:

break;

case 'd':

dev_name = optarg;

break;

case 'h':

usage (stdout, argc, argv);

exit (EXIT_SUCCESS);

case 't':

time_in_sec_capture = atoi(optarg);

break;

default:

usage (stderr, argc, argv);

exit (EXIT_FAILURE);

}

}

open_device ();

init_device ();

start_capturing ();

run ();

stop_capturing ();

uninit_device ();

close_device ();

exit (EXIT_SUCCESS);

return 0;

}

这个测试程序是根据vivi驱动hard code的， 并不一定适合其他的camera驱动

比如，我手头上的logitech stv06xx usb camera, 因为不支持640x480模式，参见代码59 60行，

代码348行 if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt)) 应该是个协商的过程，

343  fmt.fmt.pix.width = 640;

344  fmt.fmt.pix.height = 480;

345  fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

346  fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

这几行只是应用的期望格式，驱动会根据这个格式选择一个相近的格式返回，应用最后的显示处理要根据返回的格式进行处理，即process_image要做相应修改0b1331709591d260c1c78e86d0c51c18.png

蒋大钳
关注
CamDetect（Linux下摄像头检测程序）
05-28
arm9 Linux下基于摄像头的物体移动检测程序,可以用在门禁上,当有人经过时,自动通过基于video4linux的摄像头检测到物体
linux v4l2 camera capture
07-28
v4l2接口，camera capture实例，合法合规！
android摄像头(camera)之 v4l2的c测试代码
ldswfun的专栏
04-01 3028
在移植android hal的过程中，移植的首要任务是要确保驱动完好，camera是属于字符设备，但是对于其测试代码的编写就不像一般的驱动那么简单啦，因为camera的测试代码一定是要用v4l2 api，所以接下来就是介绍我们写camera的测试代码的流程。 1，打开设备 static int open_device(char *dev_name) { assert(dev_name);
linux下摄像头的测试程序,友善之臂的摄像头测试程序
weixin_42718924的博客
05-01 455
%:include class TError public:TError(const char *msg) this->msg = msg;%>TError(const TError bitand e) msg = e.msg;%>void Output() std::cerr &lt...
linux - camera capture
weixin_33895695的博客
08-17 91
//cut a picture#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;string.h&gt;#include &lt;assert.h&gt; #include &lt;getopt.h&gt;            #include &lt;fcntl.h&gt;            #include &lt...
linux v4l2 camera 测试程序(android)
mark_80的专栏
12-05 1790
从网上的代码修改，编译可以通过，基本可以使用，稍有问题的是用yuv拍照的颜色还有问题，待解！ c代码 /*  *  V4L2 video capture example  *  *  This program can be used and distributed without restrictions.  */   #include #include #i
V4L2 camera 驱动 capture测试程序
热门推荐
kickxxx的专栏
04-20 1万+
在网上找了一个测试程序， 看了看，是根据capture.c修改的。测试步骤如下 1. gcc -o capture_image capture_image.c 2. ctrl+alt+f1 切换到ubuntu的控制台，切换到控制台模式是因为在图形模式下看不到测试图形，这可能和framebuffer的设置有关 3. sudo modprobe vivi 4. sudo ./capture_i
camera_client.rar_camera capture v4l2
09-21
标题中的"camera_client.rar_camera capture v4l2"暗示了这是一个关于Linux环境下使用V4L2（Video for Linux Two）接口来捕获和处理摄像头图像的项目。V4L2是Linux内核的一部分，提供了与视频捕获设备交互的API，...
camera的v4l2测试代码
04-01
在Android系统中，Camera模块与硬件交互的重要部分就是V4L2驱动，它允许应用程序通过标准的Linux文件系统操作来访问摄像头硬件。本篇文章将深入探讨如何使用V4L2进行相机测试，以及在Android HAL（硬件抽象层）中的...
python-v4l2capture-master.zip_Camera SDK_python_python v4l2_pyth
07-15
Python版本的V4L2，适用于摄像头开发
ldd.tar.gz_V4L2 for linux_camera_individualrj9
09-23
标题 "ldd.tar.gz_V4L2 for linux_camera_individualrj9" 提示我们这是一个与Linux平台上的相机捕获相关的软件包，其中包含了V4L2（Video for Linux Two）接口。V4L2是Linux内核中的一个API，用于支持视频捕获、视频...
v4l2 camera capture and config
08-17
本文将深入探讨`v4l2`相机捕获和配置的相关知识点，结合`camera_capture.c`和`camera_config.c`两个示例程序进行详细解释。 1. **V4L2简介** `v4l2`是Linux内核的一部分，提供了一个统一的API，用于访问和控制各种...
Linux系统USB摄像头测试程序（二）_读取配置
最新发布
donghailin的专栏
08-15 744
查询USB摄像头配置信息
linux camera获取单帧jpeg图像测试
11-20
应用层camera抓取单帧图像，当pixelformat设置为V4L2_PIX_FMT_YUYV时，可以通过write_jpeg将捕获的单帧原始图像转换为灰度jpeg图像在屏幕显示出来（代码中使用fbv显示）; 当pixelformat = V4L2_PIX_FMT_MJPEG，即设置为V4L2_PIX_FMT_MJPEG时，可以通过memcpy_picture 将捕获的单帧图像转换为jpeg格式。（即在原始图上加入jpeg头及哈夫曼编码）
linux检测摄像头驱动程序,linux usb 摄像头测试软件
weixin_35625324的博客
05-01 856
在测试usb camera时，直接插在ubuntu主机行可以看到图像;但是插到开发板时，串口打印枚举错误。以上说明以下几点：1、usb camera自身芯片和摄像头正常，因为可以在ubuntu机上采集到图像2、ubuntu14.04与android4.4都是基于linux内核，而且都很新，在USB模块上应该差别不大3、可以将问题集中在枚举时出现错误。看串口打印是在进行读取描述符错误，错误值-71(...
v4l2linux视频测试程序
08-26
v4l2 linux 视频， 从硬件缓冲区获取数据 加工转化
基于V4l2框架实现的camera测试程序
07-30
基于V4l2框架实现的camera测试程序，备注详细，适合广大开发者常用工具，可以保存图片，简单修改即可保存视频
Linux V4L2之camera
嵌入式与人工智能
08-17 1233
Linux V4L2之camera一、硬件知识2. 摄像头引脚作用&硬件连接：二、成像原理三、V4L2软件架构本文来源 一、硬件知识 摄像头硬件结构和工作原理，如图1 外部光线穿过lens镜头，经过红外滤光片后光学图像投射到传感器上，然后光学图像被转换成电信号，电信号再经过模数转换变为数字信号，数字信号经过DSP加工处理，再被送到接收端进行处理，最终转换成屏幕上能够看到的图像。 其中： 1）滤光片作用： 　　a. 滤除红外线，滤除对可见光有干扰的红外光，使成像效果更清晰。 　　b. 修整进来的光线
qt5_V4L2_Camera
04-18
V4L2是Linux内核提供的一种API，用于与视频捕获和输出设备进行交互，而Qt5则是一种流行的C++应用程序开发框架，提供了丰富的图形用户界面（GUI）工具。 首先，我们需要确保系统已经安装了Qt5.7开发环境和必要的编译...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值