基于GTK的USB视频采集程序

最新推荐文章于 2024-01-26 22:27:56 发布
最新推荐文章于 2024-01-26 22:27:56 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： Linux USB
Linux 同时被 2 个专栏收录
56 篇文章 0 订阅
订阅专栏
USB
22 篇文章 9 订阅
订阅专栏
基于GTK的USB视频采集程序

        查了几天的资料，今天终于将USB摄像头测试程序调试成功了。这个测试程序很简单，功能就是将USB摄像头采集的数据显示在屏幕上。写这个程序的目的是熟悉usb摄像头的一些基本操作方法，为以后在开发板上编写视频采集程序打好基础。本测试程序包括两部分：一是视频采集部分，主要通过v4l2接口操作摄像头，将采集的视频帧存放在内存缓冲区。二是显示部分，将视频缓冲区的数据显示到屏幕上。因为摄像头采集回来的数据帧为YUV格式，不能直接显示，需要转换成RGB格式才可以显示在屏幕上。图形界面采用GNOME桌面环境下的GTK图形库。程序主要参考了v4l2视频采集例程capture.c，以及开源软件Camorama-0.16的源代码。程序运行效果如图：


        本测试程序采用的摄像头是USB摄像头，他既属于USB设备，又属于视频输入设备。USB摄像头在linux上要工作，首先要安装它的驱动，还好现在大部分的USB摄像头都是所谓的免驱摄像头，实际上就是采用系统内置UVC驱动来工作的，UVC全称 USB video device class，是USB设备标准的一个子类。所有支持这个标准的USB设备都可以用UVC来驱动，我采用的摄像头就是这种免驱动摄像头。
        Linux下对视频音频设备操作的接口叫video4linux，现在内核中是它的第二个版本video4linux2（v4l2）。他是内核中的一个模块，就像input模块一样。v4l2对应用程序抽象了操作音频视频设备的细节。应用程序只需要调用v4l2接口函数就可以操作设备，无须关心是什么样的设备，比如在应用程序层面上，USB摄像头与其他类型的摄像头没有分别。与此同时v4l2简化了音视频驱动程序的编写，底层驱动只需要实现很少一部分功能，把其他的工作交给video4linux层就可以了。video4linux2与video4linux差别还是挺大的，采用video4linux接口的程序基本上是不能在v4l2下工作的。但是v4l2也向下兼容了一部分video4linux的接口。下面就简要分析一下我的程序。
一. 主要数据结构 struct camera
[cpp] view plain copy print ?
  1. struct camera {  
  2.     char *device_name;  
  3.     int fd;  
  4.     int width;  
  5.     int height;  
  6.     int display_depth;  
  7.     int image_size;  
  8.     int frame_number;  
  9.     struct video_capability video_cap;  
  10.     struct v4l2_capability v4l2_cap;  
  11.     struct v4l2_cropcap v4l2_cropcap;  
  12.     struct v4l2_format v4l2_fmt;  
  13.     struct video_window video_win;  
  14.     struct video_picture video_pic;  
  15.     struct buffer *buffers;  
  16.     unsigned char *rgbbuf;  
  17. };  
struct camera {
	char *device_name;
	int fd;
	int width;
	int height;
	int display_depth;
	int image_size;
   	int frame_number;
	struct video_capability video_cap;
	struct v4l2_capability v4l2_cap;
	struct v4l2_cropcap v4l2_cropcap;
	struct v4l2_format v4l2_fmt;
	struct video_window video_win;
	struct video_picture video_pic;
	struct buffer *buffers;
	unsigned char *rgbbuf;
};
        这个结构体是我为了方便操作摄像头，自定义的一个结构体，主要包括了摄像头的一些属性，这个结构参考了camorama-0.16中相关结构。
devide_name    记录摄像头设备的名称，如"/dev/video0"
fd    是设备打开后返回的文件描述符
width    摄像头采集视频的宽度
height    摄像头采集视频的高度
display_depth    显示屏幕的分辨率，以字节为单位，我的显示屏为3,也就是分辨率为24
image_size    摄像头采集视频的大小，为width*height*display_depth
frame_number    视频缓冲区标号，在视频采集的时候需要开辟多个缓冲区，这个表示缓冲区的个数
video_cap    是video_capability结构体，主要定义了视频设备的一些信息，通过ioctl命令可以从设备读出这个信息。
v4l2_cap    是v4l2_capability 结构体，同样定义了一些视频设备的信息与video_capability不同，他是v4l2接口的。但是我发现他缺少video_capability的一些内容，所以还是定义了video_capability  这样两种接口混用了，不过既然v4l2支持设备返回video_capability，这样也没什么不妥。
v4l2_cropcap    是v4l2_cropcap结构体，在操作视频缓冲区的时候使用
v4l2_fmt     是v4l2_format结构体，主要定义了视频显示的一些属性
video_win    是video_window结构体，主要定义了视频格式，如高度，宽度等
video_pic    是video_picture结构体，主要定义画面的属性，如亮度，灰度，饱和度等
buffers     是自定义的struct buffer结构体，包括是频缓冲区的开始地址，以及大小
rgbbuf     视频缓冲区指针，显示程序就是在这里读取数据的。
二. 程序结构
         程序主要分为三个部分：视频采集，格式转换，视频显示。视频采集部分主要是操作v4l2的接口函数，对应v4l2.c以及v4l2.h文件。视频转换，主要是将yuv格式转换成rgb格式，对应于yuv422_rgb.c,以及yuv422_rgb.h文件。视频显示，主要是利用GTK图形库构建图形界面，以及将视频数据显示在窗口上，对应与main.c文件。程序流程图如下：

         程序以main函数开始，首先分配struct camera结构体并初始化，然后初始化显示缓冲区，分配内存。然后打开设备，对设备进行初始化，这部分代码主要调用v4l2.c中的函数，如：设置设备的采集格式，采集方式，以及对设备进行mmap，初始化帧缓存等。注意v4l2读取视频数据有三种方式，一个就是通过普通的read操作，这个比较慢，另外一个就是使用mmap，速度比较块，第三种方式是用户指针，在capeture.c中，可以选择这三种方式，而我的程序中只用了mmap的方式。初始化完设备，设备达到就绪的状态。然后就可以初始化图形显示界面了，主要是建立窗口，设置属性，定义信号链接函数。在这个程序中我是定义了两个线程分别完成视频采集和视频显示工作的。所以接下来要建立这两个线程。最后，调用ioctl，打开设备的视频采集。一切就绪后，进入GTK窗体主循环。然后两个线程就互不干扰的分别进行视频采集与视频显示了，这里利用了一个全局变image_ready 进行两个线程之间的同步。
三. 代码分析 
  1. 首先从main()函数开始
[cpp] view plain copy print ?
  1. int main(int argc, char **argv)  
  2. {  
  3.     /* 
  4.      * init struct camera  
  5.      */  
  6.     struct camera *cam;  
  7.       
  8.     cam = malloc(sizeof(struct camera));  
  9.         //分配内存   
  10.     if (!cam) {   
  11.         printf("malloc camera failure!\n");  
  12.         exit(1);  
  13.     }  
  14.         cam->device_name = "/dev/video0";  
  15.         //在ubuntu下，我的摄像头对应的就是这个设备   
  16.     cam->buffers = NULL;  
  17.     cam->width = 320;  
  18.     cam->height = 240;  
  19.         //我的摄像头质量比较差，最大分辨率只有320*240   
  20.     cam->display_depth = 3;  /* RGB24 */  
  21.     cam->rgbbuf = malloc(cam->width * cam->height * cam->display_depth);  
  22.   
  23.   
  24.     if (!cam->rgbbuf) {   
  25.         printf("malloc rgbbuf failure!\n");  
  26.         exit(1);  
  27.     }  
  28.     open_camera(cam); //打开设备   
  29.     get_cam_cap(cam); //得到设备信息，如果定义了DEBUG_CAM，则会打印视频信息   
  30.     get_cam_pic(cam); //得到图形信息，同样如果定义了DEBUG_CAM，则会打印信息   
  31.     get_cam_win(cam); //得到视频显示信息   
  32.     cam->video_win.width = cam->width;  
  33.     cam->video_win.height = cam->height;  
  34.     set_cam_win(cam);    
  35.         //设置图像大小，视频显示信息中包括摄像头支持的最大分辨率以及最小分辨率，这个可以设置，我设置的是320×240,当然也可以设置成其他，不过只能设置成特定的一些值   
  36.     get_cam_win(cam);  
  37.     //显示设置之后的视频显示信息，确定设置成功     
  38.         init_camera(cam);  
  39.         //初始化设备，这个函数包括很多有关v4l2的操作   
  40.         start_capturing (cam);  
  41.     //打开视频采集   
  42.   
  43.     gtk_window_init(argc,argv,cam);  
  44.         //初始化图形显示   
  45.   
  46.     g_thread_create((GThreadFunc)draw_thread, drawingarea, FALSE, NULL);  
  47.     g_thread_create((GThreadFunc)capture_thread, cam, FALSE, NULL);  
  48.         //建立线程   
  49.   
  50.     gdk_threads_enter();  
  51.     gtk_main();  
  52.     gdk_threads_leave();  
  53.         //进入主循环之后，两个线程开始工作   
  54.     return 0;  
  55. }   
int main(int argc, char **argv)
{
	/*
	 * init struct camera 
	 */
	struct camera *cam;
	
	cam = malloc(sizeof(struct camera));
        //分配内存
	if (!cam) { 
		printf("malloc camera failure!\n");
		exit(1);
	}
        cam->device_name = "/dev/video0";
        //在ubuntu下，我的摄像头对应的就是这个设备
	cam->buffers = NULL;
	cam->width = 320;
	cam->height = 240;
        //我的摄像头质量比较差，最大分辨率只有320*240
	cam->display_depth = 3;  /* RGB24 */
	cam->rgbbuf = malloc(cam->width * cam->height * cam->display_depth);


	if (!cam->rgbbuf) { 
		printf("malloc rgbbuf failure!\n");
		exit(1);
	}
	open_camera(cam); //打开设备
	get_cam_cap(cam); //得到设备信息，如果定义了DEBUG_CAM，则会打印视频信息
	get_cam_pic(cam); //得到图形信息，同样如果定义了DEBUG_CAM，则会打印信息
	get_cam_win(cam); //得到视频显示信息
	cam->video_win.width = cam->width;
	cam->video_win.height = cam->height;
	set_cam_win(cam);  
        //设置图像大小，视频显示信息中包括摄像头支持的最大分辨率以及最小分辨率，这个可以设置，我设置的是320×240,当然也可以设置成其他，不过只能设置成特定的一些值
	get_cam_win(cam);
	//显示设置之后的视频显示信息，确定设置成功	
        init_camera(cam);
        //初始化设备，这个函数包括很多有关v4l2的操作
        start_capturing (cam);
	//打开视频采集

	gtk_window_init(argc,argv,cam);
        //初始化图形显示

	g_thread_create((GThreadFunc)draw_thread, drawingarea, FALSE, NULL);
	g_thread_create((GThreadFunc)capture_thread, cam, FALSE, NULL);
        //建立线程

	gdk_threads_enter();
	gtk_main();
	gdk_threads_leave();
        //进入主循环之后，两个线程开始工作
  	return 0;
}
  2. 视频采集线程
[cpp] view plain copy print ?
  1. static void capture_thread(struct camera *cam)  
  2. {  
  3.     for (;;) {  
  4.         g_usleep(10000);  
  5.         if (quit_flag == 1) break;  
  6.         gdk_threads_enter();  
  7.         fd_set fds;  
  8.         struct timeval tv;  
  9.         int r;  
  10.   
  11.         FD_ZERO (&fds);  
  12.         FD_SET (cam->fd, &fds);  
  13.   
  14.         /* Timeout. */  
  15.         tv.tv_sec = 2;  
  16.         tv.tv_usec = 0;  
  17.   
  18.         r = select (cam->fd + 1, &fds, NULL, NULL, &tv);  
  19.   
  20.         if (-1 == r) {  
  21.                 if (EINTR == errno)  
  22.                     continue;  
  23.                 errno_exit ("select");  
  24.         }  
  25.   
  26.         if (0 == r) {  
  27.                 fprintf (stderr, "select timeout\n");  
  28.                 exit (EXIT_FAILURE);  
  29.         }  
  30.   
  31.         if (read_frame (cam))  
  32.                     gdk_threads_leave();  
  33.         /* EAGAIN - continue select loop. */  
  34.     }     
  35. }  
static void capture_thread(struct camera *cam)
{
	for (;;) {
		g_usleep(10000);
		if (quit_flag == 1) break;
		gdk_threads_enter();
		fd_set fds;
		struct timeval tv;
		int r;

		FD_ZERO (&fds);
		FD_SET (cam->fd, &fds);

		/* Timeout. */
		tv.tv_sec = 2;
		tv.tv_usec = 0;

		r = select (cam->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 (cam))
            		gdk_threads_leave();
		/* EAGAIN - continue select loop. */
	}	
}
        这是一个死循环，当GTK主函数进入以后一直执行，除非检测到了退出标志才退出循环。这里首先用select判断设备是否可读，这是非阻塞的读方式。如果设备可读那么select就会返回1,从而执行read_frame(cam),进行视频数据的读取。如果设备阻塞了，程序就退出了。这里的关键函数就是read_frame()，定义在v4l2.c里：
[cpp] view plain copy print ?
  1. int read_frame(struct camera *cam)  
  2. {  
  3.         struct v4l2_buffer buf;  
  4.   
  5.     CLEAR (buf);  
  6.         //这是自定义的一个宏，调用memset对内存清零   
  7.   
  8.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  9.         buf.memory = V4L2_MEMORY_MMAP;  
  10.     if (quit_flag == 0) {  
  11.             if (-1 == xioctl (cam->fd, VIDIOC_DQBUF, &buf)) {  
  12.                     switch (errno) {  
  13.                     case EAGAIN:  
  14.                     return 0;  
  15.   
  16.                 case EIO:  
  17.         /* Could ignore EIO, see spec. */  
  18.   
  19.             /* fall through */  
  20.             default:  
  21.             errno_exit ("VIDIOC_DQBUF");  
  22.             }  
  23.         }  
  24.     }  
  25.   
  26.         assert (buf.index < n_buffers);  
  27.   
  28.     process_image (cam->buffers[buf.index].start, cam);  
  29.   
  30.     if (quit_flag == 0) {  
  31.         if (-1 == xioctl (cam->fd, VIDIOC_QBUF, &buf))  
  32.             errno_exit ("VIDIOC_QBUF");  
  33.     }  
  34.     return 1;  
  35. }  
int read_frame(struct camera *cam)
{
        struct v4l2_buffer buf;

	CLEAR (buf);
        //这是自定义的一个宏，调用memset对内存清零

        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
	if (quit_flag == 0) {
        	if (-1 == xioctl (cam->fd, VIDIOC_DQBUF, &buf)) {
            		switch (errno) {
            		case EAGAIN:
                	return 0;

	        	case EIO:
		/* Could ignore EIO, see spec. */

	        /* fall through */
			default:
			errno_exit ("VIDIOC_DQBUF");
			}
		}
	}

        assert (buf.index < n_buffers);

	process_image (cam->buffers[buf.index].start, cam);

	if (quit_flag == 0) {
		if (-1 == xioctl (cam->fd, VIDIOC_QBUF, &buf))
			errno_exit ("VIDIOC_QBUF");
	}
	return 1;
}
        这里读视频数据采用的方法是mmap方法，就是将用内核空间的内存映射到用户空间来用，提高了效率。在设备初始化的时候我已经用mmap映射了四块缓冲区用来存放视频数据，也就是说设备已经知道了将视频数据存放到哪里，应用程序只需要调用VIDIOC_DQBUF ioctl命令，取缓冲队列数据，设备自然就会将视频数据放到相应的缓冲区里，处理完数据后，再调用VIDIOC_QBUF ioctl命令就可以了。这样设备就会循环处理四块缓冲区的视频数据。
        xioctl 函数其实就是ioctl，只不过加了一些错误处理。process_image（）是mian.c 中的函数，用来处理数据，是直接显示，还是压缩后存储，以及传输，这取决于具体应用。这里我是调用了格式转换函数，直接显示在屏幕上。
  3. 视频显示线程
[cpp] view plain copy print ?
  1. static void draw_thread(GtkWidget *widget)  
  2. {  
  3.         for(;;) {  
  4.                 g_usleep(10000);  
  5.         if (quit_flag == 1) break;  
  6.                 gdk_threads_enter();  
  7.                 if(image_ready) {  
  8.                         gtk_widget_queue_draw(GTK_WIDGET (widget));  
  9.                 }  
  10.                 else {  
  11.                         gdk_threads_leave();  
  12.                 }  
  13.                 gdk_threads_leave();  
  14.         }  
  15. }  
static void draw_thread(GtkWidget *widget)
{
        for(;;) {
                g_usleep(10000);
		if (quit_flag == 1) break;
                gdk_threads_enter();
                if(image_ready) {
                        gtk_widget_queue_draw(GTK_WIDGET (widget));
                }
                else {
                        gdk_threads_leave();
                }
                gdk_threads_leave();
        }
}
        这个线程很简单，判断image_ready，如果被置1那么就调用gtk_widget_queue_draw函数，触发widget的‘expose-event’事件，从而执行相关处理函数。这个widget参数是gtk控件drawingarea,视频就是显示在这个控件上。在窗口初始化的时候定义了这个控件，并初始化了控件的'expose-event'事件的处理函数为on_darea_expose()，这个函数调用了GTK提供的RGB绘图函数gdk_draw_rgb_image（）将缓冲区的内容绘制到屏幕上。
        在设备初始化之后，两个线程通过image_ready进行同步，视频采集进程默默的采集数据，每采回一帧数据，都会调用process_image，对数据进行处理，而process_image处理完数据后置位image_ready，然后视频显示线程将视频显示在屏幕上，同时清零image_ready，准备下一次转换。
  4. 格式转换函数
        摄像头输出的帧图像的格式一般都是YUV格式，也就是亮度与色差的格式，如果不进行转换，显示到屏幕上图像就会不对。不仅没有色彩，而且还会有交叉。不过大体上还是可以分辨出图像的。所以原始数据也可以作为验证是否采集成功。YUV格式有很多中，各种格式差别就是YUV这三个元素在内存中的排列方式，以及所占比例不同。我的摄像头输出格式是YUV422类型，也就是YUYV类型。因为无论怎么变，一个像素YUV三个分量必不可少，而YUV422为了节省数据量，YUV 的比例为 2：1：1，也就是两个Y，对应一个U与V，在内存中存放格式就是 Y0 U0 Y1 V0 （每个Y，U，V 分别占用一个字节） 这样原本六个字节表示的两个像素，四个字节就是表示了。
        了解YUV422的格式后，转换就很简单了，因为YUV与RGB的转换公式是固定了。只要在你的缓冲区里，每隔四个字节提取出两个像素的YUV的值，比如 Y0 U0 Y1 V0 就提取出了Y0 U0 V0 与 Y1 U0 V0 这两个像素的值，带入公式就转化成了相应的RGB的值。
 * R = Y + 1.4075*(V-128)
 * G = Y - 0.3455*(U-128) - 0.7169*(V-128)
 * B = Y +1.779 *(U-128)         
        以上就是转化公式，不过注意到上面公式都是浮点数运算，在电脑上就不用说了，直接用就可以了，因为大部分的CPU都支持硬件浮点运算，可是在嵌入式CPU中，不一定包含硬件浮点运算，比如我用的ARM920T就不支持硬浮点运算，除法指令也没用。所以，软件模拟的肯定会耗费大量的CPU时间。针对这种情况，就应该用乘法与移位操作代替浮点与除法运算。于是有人开发出了如下算法：
 * U' = U -128
 * V' = V - 128
 * R = Y + V' + ((V'*104) >> 8))
 * G = Y - ((U'*89) >> 8) - ((V' * 183) >> 8)
 * B = Y + U' + ((U'*199) >> 8)
        这样算出来的结果差不多，速度会比前一种算法快。下面就是我写的采用快速算法的格式转换程序，如果是YUV其他格式的，只需要修改少部分代码就可以了。
[cpp] view plain copy print ?
  1. #define Y0  0   
  2. #define U   1   
  3. #define Y1  2   
  4. #define V   3   
  5.   
  6. #define R   0   
  7. #define G   1   
  8. #define B   2   
  9.   
  10. int yuv422_rgb24(unsigned char *yuv_buf, unsigned char *rgb_buf, unsigned int width, unsigned int height)  
  11. {  
  12.     int yuvdata[4];  
  13.     int rgbdata[3];  
  14.     unsigned char *rgb_temp;  
  15.     unsigned int i, j;  
  16.   
  17.     rgb_temp = rgb_buf;  
  18.     for (i = 0; i < height * 2; i++) {  
  19.         for (j = 0; j < width; j+= 4) {  
  20.             /* get Y0 U Y1 V */  
  21.             yuvdata[Y0] = *(yuv_buf + i * width + j + 0);  
  22.             yuvdata[U]  = *(yuv_buf + i * width + j + 1);  
  23.             yuvdata[Y1] = *(yuv_buf + i * width + j + 2);  
  24.             yuvdata[V]  = *(yuv_buf + i * width + j + 3);  
  25.   
  26.             /* the first pixel */  
  27.             rgbdata[R] = yuvdata[Y0] + (yuvdata[V] - 128) + (((yuvdata[V] - 128) * 104 ) >> 8);  
  28.             rgbdata[G] = yuvdata[Y0] - (((yuvdata[U] - 128) * 89) >> 8) - (((yuvdata[V] - 128) * 183) >> 8);  
  29.             rgbdata[B] = yuvdata[Y0] + (yuvdata[U] - 128) + (((yuvdata[U] - 128) * 199) >> 8);  
  30.   
  31.             if (rgbdata[R] > 255)  rgbdata[R] = 255;        
  32.             if (rgbdata[R] < 0) rgbdata[R] = 0;            
  33.             if (rgbdata[G] > 255)  rgbdata[G] = 255;        
  34.             if (rgbdata[G] < 0) rgbdata[G] = 0;            
  35.             if (rgbdata[B] > 255)  rgbdata[B] = 255;        
  36.             if (rgbdata[B] < 0) rgbdata[B] = 0;            
  37.               
  38.             *(rgb_temp++) = rgbdata[R] ;  
  39.             *(rgb_temp++) = rgbdata[G];  
  40.             *(rgb_temp++) = rgbdata[B];  
  41.               
  42.             /* the second pix */   
  43.             rgbdata[R] = yuvdata[Y1] + (yuvdata[V] - 128) + (((yuvdata[V] - 128) * 104 ) >> 8);  
  44.             rgbdata[G] = yuvdata[Y1] - (((yuvdata[U] - 128) * 89) >> 8) - (((yuvdata[V] - 128) * 183) >> 8);  
  45.             rgbdata[B] = yuvdata[Y1] + (yuvdata[U] - 128) + (((yuvdata[U] - 128) * 199) >> 8);  
  46.           
  47.             if (rgbdata[R] > 255)  rgbdata[R] = 255;        
  48.             if (rgbdata[R] < 0) rgbdata[R] = 0;            
  49.             if (rgbdata[G] > 255)  rgbdata[G] = 255;        
  50.             if (rgbdata[G] < 0) rgbdata[G] = 0;            
  51.             if (rgbdata[B] > 255)  rgbdata[B] = 255;        
  52.             if (rgbdata[B] < 0) rgbdata[B] = 0;        
  53.       
  54.             *(rgb_temp++) = rgbdata[R];  
  55.             *(rgb_temp++) = rgbdata[G];  
  56.             *(rgb_temp++) = rgbdata[B];  
  57.           
  58.         }  
  59.     }  
  60.     return 0;  
  61. }  
#define Y0	0
#define U	1
#define Y1	2
#define	V	3

#define R	0
#define G	1
#define	B	2

int yuv422_rgb24(unsigned char *yuv_buf, unsigned char *rgb_buf, unsigned int width, unsigned int height)
{
	int yuvdata[4];
	int rgbdata[3];
	unsigned char *rgb_temp;
 	unsigned int i, j;

	rgb_temp = rgb_buf;
	for (i = 0; i < height * 2; i++) {
		for (j = 0; j < width; j+= 4) {
			/* get Y0 U Y1 V */
			yuvdata[Y0] = *(yuv_buf + i * width + j + 0);
			yuvdata[U]  = *(yuv_buf + i * width + j + 1);
			yuvdata[Y1] = *(yuv_buf + i * width + j + 2);
			yuvdata[V]  = *(yuv_buf + i * width + j + 3);

			/* the first pixel */
			rgbdata[R] = yuvdata[Y0] + (yuvdata[V] - 128) + (((yuvdata[V] - 128) * 104 ) >> 8);
			rgbdata[G] = yuvdata[Y0] - (((yuvdata[U] - 128) * 89) >> 8) - (((yuvdata[V] - 128) * 183) >> 8);
			rgbdata[B] = yuvdata[Y0] + (yuvdata[U] - 128) + (((yuvdata[U] - 128) * 199) >> 8);

			if (rgbdata[R] > 255)  rgbdata[R] = 255;		 
			if (rgbdata[R] < 0) rgbdata[R] = 0;			
			if (rgbdata[G] > 255)  rgbdata[G] = 255;		 
			if (rgbdata[G] < 0) rgbdata[G] = 0;			
			if (rgbdata[B] > 255)  rgbdata[B] = 255;		 
			if (rgbdata[B] < 0) rgbdata[B] = 0;			
			
			*(rgb_temp++) = rgbdata[R] ;
			*(rgb_temp++) = rgbdata[G];
			*(rgb_temp++) = rgbdata[B];
			
			/* the second pix */ 
			rgbdata[R] = yuvdata[Y1] + (yuvdata[V] - 128) + (((yuvdata[V] - 128) * 104 ) >> 8);
			rgbdata[G] = yuvdata[Y1] - (((yuvdata[U] - 128) * 89) >> 8) - (((yuvdata[V] - 128) * 183) >> 8);
			rgbdata[B] = yuvdata[Y1] + (yuvdata[U] - 128) + (((yuvdata[U] - 128) * 199) >> 8);
		
			if (rgbdata[R] > 255)  rgbdata[R] = 255;		 
			if (rgbdata[R] < 0) rgbdata[R] = 0;			
			if (rgbdata[G] > 255)  rgbdata[G] = 255;		 
			if (rgbdata[G] < 0) rgbdata[G] = 0;			
			if (rgbdata[B] > 255)  rgbdata[B] = 255;		 
			if (rgbdata[B] < 0) rgbdata[B] = 0;		
	
			*(rgb_temp++) = rgbdata[R];
			*(rgb_temp++) = rgbdata[G];
			*(rgb_temp++) = rgbdata[B];
		
		}
	}
	return 0;
}
四 . 总结

        这个测试程序主要参考了v4l2的例程capture.c，因为以后要移植到开发板上，所以将操作V4L2接口的函数放到了v4l2.c这个文件中。程序还参考了开源软件camoram-0.16，这个软件的这个版本是v4l接口的，但是一些编程方法还是值得借鉴，新版本已经是v4l2接口的了，但是在网上下载不到源代码，没有办法。程序功能比较单一，一些地方没有优化，写在这里一来为了分享，二来巩固一下知识，三来希望高手能指点一下。

程序的全部源代码在我的资源里：http://download.csdn.net/detail/yaozhenguo2006/3822525 编译通过的前提是正确安装了相应的GTK2.0的库。

 

原文：http://blog.csdn.net/yaozhenguo2006/article/details/6996931

 

ljzcom
关注
专栏目录
基于GTK的USB视频采集测试程序
11-21
这个在ubuntu10.10 开发的USB视频采集程序，基于GKT2.0图形库，采用V4L2接口 实现功能比较简单，就是采集视频并显示。编译通过前提必须安装相应的库文件，如gnome-core-devel 等
C语言基于GTK+Libvlc实现的简易视频播放器（二）
实验楼--动手做实验，轻松学IT！
12-24 1348
上一次我们使用gtk+libvlc实现了一个最简单的视频播放器，可以实现点击按钮暂定和停止播放视频，以及同步显示视频播放进度，但即使作为一个视频播放器，只有这些功能也还是不够的，至少我们还应该有全屏播放的功能吧，所以这一次我们就来为上一次的视频播放器添加上全屏播放功能。这个功能实现起来思路很简单，只是具体实现过程中有很多坑罢了，需要我们注意很多细节问题，还要解决一些bug等等。这次我们的代码出了增加功能之外，也还会对上一次的基础代码做一些修改。
Ubuntu下屏幕录制软件--gtk-recordMyDesktop
懒人的技术笔记
07-18 3040
在Ubuntu下要录制讲课视频，可选择的软件应该比Windows和Mac下少一些，不过recordMyDesktop是个不错的选择。建议用ubuntu software进行可视化安装。 记得将Encode On the Fly也选择上。录制后的格式为ogv，如果想转换为mp4格式，需要使用ffmpeg。 参考如下：sudo add-apt-repository ppa:mc3man/tr
Linux下使用GTK+V4L2进行的视频开发
11-13
尝试了MJPEG和YUYV两种视频流格式，均能得到较好的视频显示结果
在tda4vm evm上基于v4l2实现使用usb摄像头采集数据并显示
05-02
本文将详细介绍如何在TDA4VM EVM（Evaluation Module）上利用V4L2库来实现USB摄像头的数据采集，并将YUV4:2:2格式的图像转换为RGB格式以便在显示器上显示。 首先，TDA4VM EVM是一款由Texas Instruments推出的开发...
基于ARM11和GTK 的视频监控系统设计.pdf
09-21
《基于ARM11和GTK的视频监控系统设计》是一篇探讨如何在嵌入式ARM-Linux平台上构建网络视频监控终端的论文。文章重点讲述了多线程编程和GTK+技术的应用，以及利用TCP/IP协议实现远程通信的方法。 在硬件层面，系统...
linux视频采集
04-03
本项目显然基于GTK（GIMP Toolkit）构建了一个用户界面，来管理和操作视频采集流程。GTK是用于创建图形用户界面的开源库，支持多种操作系统，包括Linux。 首先，我们要理解的是"USB视频采集"。在Linux中，USB摄像头...
基于Video4Linux2的图像采集程序设计.pdf
09-06
本文主要介绍了基于Video4Linux2的图像采集程序设计，旨在实现在Linux系统下USB摄像头图像数据的采集和显示。Video4Linux2是Linux系统下的应用编程接口，提供了数据结构、应用函数等，用于实现音频视频开发。 在...
《基于GTK的USB视频采集程序》
liuwei423210896的专栏
09-09 824
《V4L2驱动的移植与应用（一）》 vivi.c中的头文件包含： vivi.c包含头文件v4l2-device.h和v4l2-ioctl.h，其中v4l2-device.h中包含了v4l2-subdev.h，v4l2-subdev.h 中又包含了v4l2-common.h，v4l2-common.h中包含了v4l2-dev.h。vivi.h 在v4l2-dev.h中定义了结
基于gst,gtk等库开发的摄像头视频采集程序
12-21
基于gstream,gtk等库开发的摄像头视频采集程序,用gtk做界面
webcam snaps-开源
05-09
基于GTK的网络摄像头实用程序，用于拍摄快照。
GTK渲染摄像头图像数据
weixin_44453694的博客
10-28 1173
绘图工具集(GDK，Graphics Drawing Kit)是在GTK+ 和特定操作系统的应用编程接口(API,Application Program Interface)之间的低级绘图制层—— Linux的API是Xlib。由于GTK和机器的API之间没有直接接口，移植GTK+就成为移植GLIB和GDK的问题。GDK提供像元的绘制能力以及低层的窗口建立和处理能力。对许多应用来说，使用构件时最方便的，但是，如果你想用GTK+编写模拟时钟的应用程序，由于它没有绘制时钟表面的能力，实现这样的任务就有困难了。
GTK实现打开文件操作
juagle的专栏
04-21 4124
<br />/******************************************************************************* * Author :Honker.y * Email :Honker.ying@gmail.com * Last modified :2011-04-21 22:34 * Filename :open_file.c * version :1.0
GTK进行rgb绘图
m0_60352504的博客
07-29 629
例如
Linux下基于GTK人脸识别界面设计
weixin_44453694的博客
11-01 1454
人脸识别，是基于人的脸部特征信息进行身份识别的一种生物识别技术。用摄像机或摄像头采集含有人脸的图像或视频流，并自动在图像中检测和跟踪人脸，进而对检测到的人脸进行脸部识别的一系列相关技术，通常也叫做人像识别、面部识别。
摄像头采集程序linux下
BLUESTAR
07-04 1018
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #define COLS 640 #define ROWS 480 int fd
C语言基于GTK+Libvlc实现的简易视频播放器(二）
alss13237的博客
12-24 291
简易视频播放器-全屏播放 一、课程说明 上一次我们使用gtk+libvlc实现了一个最简单的视频播放器，可以实现点击按钮暂定和停止播放视频，以及同步显 示视频播放进度，但即使作为一个视频播放器，只有这些功能也还是不够的，至少我们还应该有全屏播放的功能吧，所以这一次我们就来为上一次的视频播放器添加 上全屏播放功能。这个功能实现起来思路很简单，只是具体实现过程中有很多坑罢了，需要我们...
Ubuntu22.04 Mono C# gtk 编程习练笔记(四)
最新发布
weixin_45707491的博客
01-26 654
drawingarea1Width和drawingarea1Height 是读取的drawingarea1的宽高尺寸，surfacepub是内存中的图像的surface，ctxpub 是 surface 的 Cairo Context。
使用gst和gtk库实现的摄像头视频采集程序
"该资源是关于使用gstream和gtk库开发的摄像头视频采集程序，通过gtk构建用户界面，gstream处理视频流。" 在本文中，我们将深入探讨如何利用GStreamer（gst）和GTK（gtk）库来创建一个摄像头视频采集程序。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值