5.0 本节分析所使用的应用程序源代码

最新推荐文章于 2021-11-12 15:59:07 发布
最新推荐文章于 2021-11-12 15:59:07 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： i.MX6-IPU子系统 文章标签： IPU NXP arm imx6 内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanbixing123/article/details/52294463
版权 
本节分析所使用的应用程序的源代码

/*
 * Copyright 2004-2013 Freescale Semiconductor, Inc. All rights reserved.
 */

/*
 * The code contained herein is licensed under the GNU General Public
 * License. You may obtain a copy of the GNU General Public License
 * Version 2 or later at the following locations:
 *
 * http://www.opensource.org/licenses/gpl-license.html
 * http://www.gnu.org/copyleft/gpl.html
 */

/*
 * @file mxc_v4l2_capture.c
 *
 * @brief Mxc Video For Linux 2 driver test application
 *
 */

#ifdef __cplusplus
extern "C"{
#endif

/*=======================================================================
                                        INCLUDE FILES
=======================================================================*/
/* Standard Include Files */
#include <errno.h>

/* Verification Test Environment Include Files */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <asm/types.h>
#include <linux/videodev2.h>
#include <sys/mman.h>
#include <string.h>
#include <malloc.h>

struct v4l2_mxc_offset {
	uint32_t u_offset;
	uint32_t v_offset;
};

#define TEST_BUFFER_NUM 3

struct testbuffer
{
        unsigned char *start;
        size_t offset;
        unsigned int length;
};

struct testbuffer buffers[TEST_BUFFER_NUM];
int g_in_width = 176;
int g_in_height = 144;
int g_out_width = 176;
int g_out_height = 144;
int g_top = 0;
int g_left = 0;
int g_input = 0;
int g_capture_count = 100;
int g_rotate = 0;
int g_cap_fmt = V4L2_PIX_FMT_YUV420;
int g_camera_framerate = 30;
int g_extra_pixel = 0;
int g_capture_mode = 0;
int g_usb_camera = 0;
char g_v4l_device[100] = "/dev/video0";

static void print_pixelformat(char *prefix, int val)
{
	printf("%s: %c%c%c%c\n", prefix ? prefix : "pixelformat",
					val & 0xff,
					(val >> 8) & 0xff,
					(val >> 16) & 0xff,
					(val >> 24) & 0xff);
}

int start_capturing(int fd_v4l)
{
        unsigned int i;
        struct v4l2_buffer buf;
        enum v4l2_buf_type type;

        for (i = 0; i < TEST_BUFFER_NUM; i++)
        {
                memset(&buf, 0, sizeof (buf));
                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;
	           	buf.index = i;
                if (ioctl(fd_v4l, VIDIOC_QUERYBUF, &buf) < 0)
                {
                        printf("VIDIOC_QUERYBUF error\n");
                        return -1;
                }

                buffers[i].length = buf.length;
                buffers[i].offset = (size_t) buf.m.offset;
                buffers[i].start = mmap (NULL, buffers[i].length,
                    PROT_READ | PROT_WRITE, MAP_SHARED,
                    fd_v4l, buffers[i].offset);
				memset(buffers[i].start, 0xFF, buffers[i].length);
        }

        for (i = 0; i < TEST_BUFFER_NUM; i++)
        {
                memset(&buf, 0, sizeof (buf));
                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;
                buf.index = i;
				buf.m.offset = buffers[i].offset;
				if (g_extra_pixel){
	                buf.m.offset += g_extra_pixel *
	                	(g_out_width + 2 * g_extra_pixel) + g_extra_pixel;
				}

                if (ioctl (fd_v4l, VIDIOC_QBUF, &buf) < 0) {
                        printf("VIDIOC_QBUF error\n");
                        return -1;
                }
        }

        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if (ioctl (fd_v4l, VIDIOC_STREAMON, &type) < 0) {
                printf("VIDIOC_STREAMON error\n");
                return -1;
        }
        return 0;
}

int stop_capturing(int fd_v4l)
{
        enum v4l2_buf_type type;

        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        return ioctl (fd_v4l, VIDIOC_STREAMOFF, &type);
}

int v4l_capture_setup(void)
{
        struct v4l2_format fmt;
        struct v4l2_control ctrl;
        struct v4l2_streamparm parm;
	struct v4l2_crop crop;
        int fd_v4l = 0;
		struct v4l2_mxc_offset off;
	struct v4l2_dbg_chip_ident chip;
	struct v4l2_frmsizeenum fsize;
	struct v4l2_fmtdesc ffmt;

        if ((fd_v4l = open(g_v4l_device, O_RDWR, 0)) < 0)
        {
                printf("Unable to open %s\n", g_v4l_device);
                return 0;
        }

	/* UVC driver does not support this ioctl */
	if (g_usb_camera != 1) {
		if (ioctl(fd_v4l, VIDIOC_DBG_G_CHIP_IDENT, &chip))
		{
			printf("VIDIOC_DBG_G_CHIP_IDENT failed.\n");
			return -1;
		}
		printf("sensor chip is %s\n", chip.match.name);
	}

	printf("sensor supported frame size:\n");
	fsize.index = 0;
	while (ioctl(fd_v4l, VIDIOC_ENUM_FRAMESIZES, &fsize) >= 0) {
		printf(" %dx%d\n", fsize.discrete.width,
					       fsize.discrete.height);
		fsize.index++;
	}

	ffmt.index = 0;
	while (ioctl(fd_v4l, VIDIOC_ENUM_FMT, &ffmt) >= 0) {
		print_pixelformat("sensor frame format", ffmt.pixelformat);
		ffmt.index++;
	}

	parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	parm.parm.capture.timeperframe.numerator = 1;
	parm.parm.capture.timeperframe.denominator = g_camera_framerate;
	parm.parm.capture.capturemode = g_capture_mode;

	if (ioctl(fd_v4l, VIDIOC_S_PARM, &parm) < 0)
	{
	        printf("VIDIOC_S_PARM failed\n");
	        return -1;
	}

	if (ioctl(fd_v4l, VIDIOC_S_INPUT, &g_input) < 0)
	{
		printf("VIDIOC_S_INPUT failed\n");
		return -1;
	}

	/* UVC driver does not implement CROP */
	if (g_usb_camera != 1) {
		crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		if (ioctl(fd_v4l, VIDIOC_G_CROP, &crop) < 0)
		{
			printf("VIDIOC_G_CROP failed\n");
			return -1;
		}

		crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		crop.c.width = g_in_width;
		crop.c.height = g_in_height;
		crop.c.top = g_top;
		crop.c.left = g_left;
		if (ioctl(fd_v4l, VIDIOC_S_CROP, &crop) < 0)
		{
			printf("VIDIOC_S_CROP failed\n");
			return -1;
		}
	}

        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	fmt.fmt.pix.pixelformat = g_cap_fmt;
        fmt.fmt.pix.width = g_out_width;
        fmt.fmt.pix.height = g_out_height;
        if (g_extra_pixel){
			off.u_offset = (2 * g_extra_pixel + g_out_width) * (g_out_height + g_extra_pixel)
				 - g_extra_pixel + (g_extra_pixel / 2) * ((g_out_width / 2)
				 + g_extra_pixel) + g_extra_pixel / 2;
			off.v_offset = off.u_offset + (g_extra_pixel + g_out_width / 2) *
				((g_out_height / 2) + g_extra_pixel);
        	fmt.fmt.pix.bytesperline = g_out_width + g_extra_pixel * 2;
			fmt.fmt.pix.priv = (uint32_t) &off;
        	fmt.fmt.pix.sizeimage = (g_out_width + g_extra_pixel * 2 )
        		* (g_out_height + g_extra_pixel * 2) * 3 / 2;
		} else {
	        fmt.fmt.pix.bytesperline = g_out_width;
			fmt.fmt.pix.priv = 0;
        	fmt.fmt.pix.sizeimage = 0;
		}

        if (ioctl(fd_v4l, VIDIOC_S_FMT, &fmt) < 0)
        {
                printf("set format failed\n");
                return 0;
        }

        /*
	 * Set rotation
	 * It's mxc-specific definition for rotation.
	 */
	if (g_usb_camera != 1) {
		ctrl.id = V4L2_CID_PRIVATE_BASE + 0;
		ctrl.value = g_rotate;
		if (ioctl(fd_v4l, VIDIOC_S_CTRL, &ctrl) < 0)
		{
			printf("set ctrl failed\n");
			return 0;
		}
	}

        struct v4l2_requestbuffers req;
        memset(&req, 0, sizeof (req));
        req.count = TEST_BUFFER_NUM;
        req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        req.memory = V4L2_MEMORY_MMAP;

        if (ioctl(fd_v4l, VIDIOC_REQBUFS, &req) < 0)
        {
                printf("v4l_capture_setup: VIDIOC_REQBUFS failed\n");
                return 0;
        }

        return fd_v4l;
}

int v4l_capture_test(int fd_v4l, const char * file)
{
        struct v4l2_buffer buf;
#if TEST_OUTSYNC_ENQUE
        struct v4l2_buffer temp_buf;
#endif
        struct v4l2_format fmt;
        FILE * fd_y_file = 0;
        int count = g_capture_count;

        if ((fd_y_file = fopen(file, "wb")) ==NULL)
        {
                printf("Unable to create y frame recording file\n");
                return -1;
        }

        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if (ioctl(fd_v4l, VIDIOC_G_FMT, &fmt) < 0)
        {
                printf("get format failed\n");
                return -1;
        }
        else
        {
                printf("\t Width = %d", fmt.fmt.pix.width);
                printf("\t Height = %d", fmt.fmt.pix.height);
                printf("\t Image size = %d\n", fmt.fmt.pix.sizeimage);
		print_pixelformat(0, fmt.fmt.pix.pixelformat);
        }

        if (start_capturing(fd_v4l) < 0)
        {
                printf("start_capturing failed\n");
                return -1;
        }

        while (count-- > 0) {
                memset(&buf, 0, sizeof (buf));
                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;
                if (ioctl (fd_v4l, VIDIOC_DQBUF, &buf) < 0)	{
                        printf("VIDIOC_DQBUF failed.\n");
                }

                fwrite(buffers[buf.index].start, fmt.fmt.pix.sizeimage, 1, fd_y_file);

#if TEST_OUTSYNC_ENQUE
				/* Testing out of order enque */
				if (count == 25) {
					temp_buf = buf;
                    printf("buf.index %d\n", buf.index);
					continue;
				}

				if (count == 15) {
                        if (ioctl (fd_v4l, VIDIOC_QBUF, &temp_buf) < 0) {
                                printf("VIDIOC_QBUF failed\n");
                        		break;
                        }
				}
#endif
                if (count >= TEST_BUFFER_NUM) {
                        if (ioctl (fd_v4l, VIDIOC_QBUF, &buf) < 0) {
                                printf("VIDIOC_QBUF failed\n");
                        		break;
                        }
                }
                else
                        printf("buf.index %d\n", buf.index);
        }

        if (stop_capturing(fd_v4l) < 0)
        {
                printf("stop_capturing failed\n");
                return -1;
        }

        fclose(fd_y_file);

        close(fd_v4l);
        return 0;
}


int process_cmdline(int argc, char **argv)
{
        int i;

        for (i = 1; i < argc; i++) {
                if (strcmp(argv[i], "-iw") == 0) {
                        g_in_width = atoi(argv[++i]);
                }
                else if (strcmp(argv[i], "-ih") == 0) {
                        g_in_height = atoi(argv[++i]);
                }
		else if (strcmp(argv[i], "-ow") == 0) {
			g_out_width = atoi(argv[++i]);
		}
		else if (strcmp(argv[i], "-oh") == 0) {
			g_out_height = atoi(argv[++i]);
		}
		else if (strcmp(argv[i], "-t") == 0) {
			g_top = atoi(argv[++i]);
		}
		else if (strcmp(argv[i], "-l") == 0) {
			g_left = atoi(argv[++i]);
		}
		else if (strcmp(argv[i], "-i") == 0) {
			g_input = atoi(argv[++i]);
		}
                else if (strcmp(argv[i], "-r") == 0) {
                        g_rotate = atoi(argv[++i]);
                }
                else if (strcmp(argv[i], "-c") == 0) {
                        g_capture_count = atoi(argv[++i]);
                }
                else if (strcmp(argv[i], "-fr") == 0) {
                        g_camera_framerate = atoi(argv[++i]);
                }
                else if (strcmp(argv[i], "-e") == 0) {
                        g_extra_pixel = atoi(argv[++i]);
                }
		else if (strcmp(argv[i], "-m") == 0) {
			g_capture_mode = atoi(argv[++i]);
		}
		else if (strcmp(argv[i], "-d") == 0) {
			strcpy(g_v4l_device, argv[++i]);
		}
                else if (strcmp(argv[i], "-f") == 0) {
                        i++;
                        g_cap_fmt = v4l2_fourcc(argv[i][0], argv[i][1],argv[i][2],argv[i][3]);

                        if ( (g_cap_fmt != V4L2_PIX_FMT_BGR24) &&
                             (g_cap_fmt != V4L2_PIX_FMT_BGR32) &&
                             (g_cap_fmt != V4L2_PIX_FMT_RGB565) &&
			     (g_cap_fmt != V4L2_PIX_FMT_NV12) &&
			     (g_cap_fmt != V4L2_PIX_FMT_YUV422P) &&
			     (g_cap_fmt != V4L2_PIX_FMT_UYVY) &&
			     (g_cap_fmt != V4L2_PIX_FMT_YUYV) &&
			     (g_cap_fmt != V4L2_PIX_FMT_YVU420) &&
                             (g_cap_fmt != V4L2_PIX_FMT_YUV420) )
                        {
                                return -1;
                        }
                }
		else if (strcmp(argv[i], "-uvc") == 0) {
			g_usb_camera = 1;
		}
                else if (strcmp(argv[i], "-help") == 0) {
                        printf("MXC Video4Linux capture Device Test\n\n" \
			       "Syntax: mxc_v4l2_capture.out -iw <capture croped width>\n" \
			       " -ih <capture cropped height>\n" \
			       " -ow <capture output width>\n" \
			       " -oh <capture output height>\n" \
			       " -t <capture top>\n" \
			       " -l <capture left>\n" \
			       " -i <input mode, 0-use csi->prp_enc->mem, 1-use csi->mem>\n" \
                               " -r <rotation> -c <capture counter> \n"
                               " -e <destination cropping: extra pixels> \n" \
			       " -m <capture mode, 0-low resolution, 1-high resolution> \n" \
			       " -d <camera select, /dev/video0, /dev/video1> \n" \
			       " -uvc (for USB camera test) \n" \
			       " -f <format> -fr <frame rate, 30fps by default> \n");
                        return -1;
               }
        }

	printf("in_width = %d, in_height = %d\n", g_in_width, g_in_height);
	printf("out_width = %d, out_height = %d\n", g_out_width, g_out_height);
	printf("top = %d, left = %d\n", g_top, g_left);

        if ((g_in_width == 0) || (g_in_height == 0)) {
                return -1;
        }
        return 0;
}

int main(int argc, char **argv)
{
        int fd_v4l;

        if (process_cmdline(argc, argv) < 0) {
                return -1;
        }
        fd_v4l = v4l_capture_setup();
        return v4l_capture_test(fd_v4l, argv[argc-1]);
}

执行应用程序所使用的命令如下:

xxxxxxxxxx

后面再补充

yanbixing123
关注
专栏目录
5.1 mxc_v4l2_capture.c应用程序追踪分析
吾皇的博客
08-23 8571
对于IPU在内核驱动中的执行过程，需要通过应用程序的函数调用来一步一步追踪，下面就根据mxc_v4l2_capture.c这个应用程序来分析。经过此轮分析，应该对IPU内部那些函数都有一个大致的认识。 1. 应用程序中的参数 g_in_width= 352, g_in_height = 288, g_out_width = 352, g_out_height = 288,g_rota
linux内核V4L2_API架构学习(1)-常用CMD和操作函数
SSSS的博客
04-18 382
V4l2_API常用操作，原版参考官网Video for Linux Two API Specification介绍。 V4L2 close() — Close a V4L2 device 关闭一个V4L2设备 V4L2 ioctl() — Program a V4L2 device 控制一个V4L2设备 ioctl VIDIOC_CROPCAP — Information about t...
V4L2简介
hushup的专栏
10-13 7233
http://work-blog.readthedocs.org/en/latest/v4l2%20intro.html 第一章 V4L2简介 1.1、什么是v4l2 V4L2（Video4Linux的缩写）是Linux下关于视频采集相关设备的驱动框架，为驱动和应用程序提供了一套统一的接口规范。 V4L2支持的设备十分广泛，但是其中只有很少一部分在本质上是真正的视频设备：
v4l2功能查询列表
zhoudidong的专栏
04-28 635
一，功能参考 目录 V4L2 close（） - 关闭一个V4L2设备 V4L2 ioctl（） - 创建的V4L2设备 ioctl VIDIOC_CROPCAP - 视频裁剪和缩放功能信息 ioctl VIDIOC_DBG_G_REGISTER，VIDIOC_DBG_S_REGISTER - 读或写硬件注册表 ioctl VIDIOC_ENCODER_CMD，VIDIOC_TRY_E...
Qt Creator 5.0 官方源代码编译版本
09-09
MinGW-w64支持编译原生的Windows应用程序，它是编译Qt Creator源代码所必需的工具链。 编译Qt Creator的步骤大致如下： 1. **获取源代码**：首先，从Qt官方网站下载Qt Creator 5.0的源代码压缩包，并将其解压到...
让VB应用程序支持鼠标滚轮源代码.doc
最新发布
01-18
【标题】: "让VB应用程序支持鼠标滚轮源代码" 【描述】: "本文介绍如何在VB应用程序中添加鼠标滚轮支持，通过源代码实现，避免依赖第三方控件" 【标签】: "软件/插件 让VB应用程序支持鼠标滚轮源代码" 【正文】: ...
WINCE 5.0 ，6.0 ，7.0 应用程序自动更新源代码
10-26
真正实现通过配置文件实现WINCE APP 自动更新的通用程序 要点： 1，UPDATELIST 文件第一行为服务器下载文件夹虚拟路径 2，UPDATELIST 文件第二行为本地APP程序 3，需要在SHSAN.EXE 所在文件夹建立temp 子文件夹
Vtcp 5.0版本C++源代码
01-14
Vtcp 5.0版本的C++源代码是软件开发领域中一个重要的学习资源，尤其对于那些想要深入理解网络编程和C++编程技术的人来说。Vtcp是一个基于TCP/IP协议的库，它允许开发者轻松地创建高性能的网络应用程序。在本文中，...
WINCE5.0应用程序
02-03
具体的功能和使用方法需要查看其文档或源代码才能详细了解。 6. **调试和优化**：在开发过程中，性能优化是关键，包括内存管理、CPU利用率和电池寿命。VS2005的性能分析工具可以帮助找出瓶颈并优化代码。 7. **...
Linux之V4L2基础编程-内存映射
11-14
详细介绍使用mmap实现V4L2视频处理机制，包括具体流程，部分参考代码，原理讲解，相信对初学同学有一定帮助
int val=rand() & 0xFF 是什么意思？
wonderful931106的博客
11-12 975
rand()随机数函数返回一个int型的数，之后用这个数逻辑与上一个0xff，最后将结果赋值给val； 例如： rand()函数返回值为8；8的2进制形式为0000，0000，0000，0000，0000,0000,0000,1000 0xff的2进制形式为0000，0000，0000，0000，1111,1111,1111,1111 两个数作为运算‘&‘ 之后得到0000，0000，0000，0000，0000,0000,0000,1000 然后将这个数赋值给m_session 整个这条语句的作用
imx v4l2 视频获取代码分析
leon
04-08 4906
1.g2d.h#ifndef __G2D_H__ #define __G2D_H__ #ifdef __cplusplus extern "C"  { #endif enum g2d_format { //rgb formats      G2D_RGB565               = 0,      G2D_RGBA8888             = 1
Linux5.0内核系统调用分析
kyhquite的博客
03-19 739
原创作品转载请注明出处 +https://github.com/mengning/linuxkernel/” 学号：SA18225163 目录 一、内核编译 1.安装必备的软件编译工具 2.下载Linux5.0内核代码 3.配置内核 二.启动QEMU 一、内核编译 Linux内核是操作系统的核心，也是整个Linux功能体现的核心，就如同发动机在汽车中的重要性。内核主要功...
V4L2开发应用流程的各类超实用VIDIOC命令及其结构体集锦
Mark_minGE的博客
08-05 6365
本人作为初入音视频领域的新人，观摩了各位大佬关于V4L2详细开发流程的满满干货，特意为这两周的学习做个总结，希望后来者能顺利完成关于V4L2的第一个demo。这期内容主要内容为V4L2的各类实用VIDIOC命令调用， 各命令顺序总体上呈现的一个V4L2开发流程。 读前必看： 1. 在函数原型中出现的 int request , 其中request 参数即所属的VIDIOC命令。 ...
IPU概述
热门推荐
吾皇的博客
08-23 3万+
1. IPU概述 （一）框架 首先来看看imx6q整体系统框架图，看看IPU位于整个SOC系统中的位置： 可以看出来，整个IPU挂接在AXI与AHB总线上面，通过总线，它可以与ARM，VPU，GPU和RAM等模块通信。 另外，每个IPU有两个camera接口，如下所示： 通过LDB控制到LVDS屏，直接控制LCD屏，并且可以通过HDMI或者MIPI来显示。
cremb pc5.0 源代码
11-27
Cremb PC5.0 是一个用于 PC 端的源代码，它包含了一系列用于开发 PC 应用程序的代码和库。这些源代码可以用于创建各种不同类型的应用程序，比如办公软件、游戏、工具软件等等。源代码提供了一种自定义和修改软件的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值