嵌入式linux采用v4l采集视频源码

最新推荐文章于 2021-05-04 15:16:16 发布
最新推荐文章于 2021-05-04 15:16:16 发布
阅读量1k 收藏
点赞数 2
文章标签： linux 嵌入式 null video struct list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yudatun/article/details/6523575
版权


#ifndef LMH_ERR_H
#define LMH_ERR_H

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>

#define MAXLINE      4096

/*==================================出错处理函数================================*/

extern void ErrRet( const char *fmt, ... );

extern void ErrSys( const char *fmt, ... );

extern void ErrMsg( const char *fmt, ... );

#endif    /* LMH_ERR_H */

#include "lmh_err.h"

static void            /* 声明静态函数 */
ErrDoit(
     int         errnoflag,
     int         error,
     const char *fmt,
     va_list     ap
     );

/*
 * 出错处理函数，当调用linux下系统调用失败时使用, 目的是使程序终止.
 */
void
ErrSys( const char *fmt, ... )
{
     va_list ap;

     va_start( ap, fmt );
     ErrDoit( 1, errno, fmt, ap );
     va_end( ap );
     exit( EXIT_FAILURE );
}

/*
 * 出错处理函数，打印出错信息，并返回到原程序。
 */
void
ErrRet( const char *fmt, ... )
{
     va_list ap;

     va_start( ap, fmt );
     ErrDoit( 1, errno, fmt, ap );
     va_end( ap );
}

/*
 * 出错处理函数，打印出错信息，并返回到源程序。
 */
void
ErrMsg( const char *fmt, ... )
{
     va_list ap;

     va_start( ap, fmt );
     ErrDoit( 0, 0, fmt, ap );
     va_end( ap );
}

static void
ErrDoit(
     int         errnoflag,
     int         error,
     const char *fmt,
     va_list     ap
     )
{
     char buf[MAXLINE];

     vsnprintf( buf, MAXLINE, fmt, ap );
     if ( errnoflag )
     {
      snprintf(
           buf + strlen( buf ),
           MAXLINE - strlen( buf ),
           ": %s",
           strerror( error )
           );
     }
     strcat( buf, "/n" );
     fflush( stdout );
     fputs( buf, stderr );
     fflush( NULL );
}


#ifndef LMH_V4L_H
#define LMH_V4L_H

/* ISO c headers */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

/* Linux c headers */
#include <linux/types.h>
#include <linux/videodev.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>

#define VIDEO_PALETTE_JPEG 21
#define BRIDGE_ZC3XX        0
#define MAX_BRIDGE          2
#define JPEG                0
#define UNOW                1

/* 默认摄像头设备 */
//#define DEFAULT_DEVICE "/dev/v4l/video0" /* FL2440 */
//#define DEFAULT_DEVICE "/dev/video1" /* PC */
#define DEFAULT_DEVICE "/dev/video0" /* 博创 */

#define PIC_WIDTH   240                /* 图片宽度 */
#define PIC_HEIGHT  289                /* 图片高度 */

#define PIC_FORMAT  VIDEO_PALETTE_JPEG    /* 图片格式 */

#define GRAB_METHOD 0        /* 使用read读取一帧图片数据 */

typedef struct bridge_list
{
     int         bl_num;
     const char *bl_name;

} BRIDGE_LIST;

typedef struct v4l_device    /* 自定义v4l设备 */
{
     int                     vd_fd;         /* 设备号 */
     char                   *vd_device;     /* 设备名称 */
     struct video_mmap       vd_mmap;       /* 用于mmap */
     int                     vd_mmapsize;
     struct video_capability vd_capability; /* 包含设备的基本信息 */
     struct video_picture    vd_picture;    /* 设备采集图像的各种属性 */
     struct video_mbuf       vd_mbuf;        /* 用于mmap惊醒映射的帧信息 */
     struct video_channel    vd_channel;
     int                     vd_cameratype; /* 摄像头类型 */
     char                   *vd_cameraname; /* 摄像头名称 */
     char                    vd_bridge[9];
     int                     vd_palette;
     int                     vd_grabmethod; /* 采集图像方式 */
     unsigned char          *vd_framebuf;
     unsigned char          *vd_frame;
     int                     vd_framesize;
     int                     vd_bpp;
     int                     vd_width;
     int                     vd_height;
     int                     vd_format;

} V4L_DEVICE;

/*===============================采集视频函数==============================*/

extern int InitV4LDevice(
     V4L_DEVICE *vd,
     char       *device,
     int         width,
     int         height,
     int         format,
     int         grabmethod
     );
   
extern int V4LGrab( V4L_DEVICE *vd );

extern int CloseV4L( V4L_DEVICE *vd );

extern int GetJpegSize( unsigned char *buf, int insize );

#endif    /* LMH_V4L_H */


#include "lmh_v4l.h"
#include "lmh_err.h"

/*=================================静态函数声明=================================*/

static int ConvertFrame(
     unsigned char *dst,
     unsigned char *src,
     int            width,
     int            height,
     int            format,
     int            size
     );
static int InitV4L( V4L_DEVICE *vd );
static int IsSpcaChip( const char *bridgename );
static int GetStreamID( const char *bridgename );
static int GetDepth( int format );
static int GetVideoPicture( V4L_DEVICE *vd );
static int SetVideoPicture( V4L_DEVICE *vd );

static BRIDGE_LIST g_list[] =
{
//     { BRIDGE_ZC3XX, "zc3xx"   }, /* pc     */
     { BRIDGE_ZC3XX, "ZC301-2" } /* FL2440 */
};

/*
 * 初始化V4L结构, 成功：返回0，失败：返回-1
 */
int
InitV4LDevice(
     V4L_DEVICE *vd,   
     char       *device,
     int         width,
     int         height,
     int         format,
     int         grabmethod
     )
{
     int ret = -1;

     if ( vd == NULL || device == NULL )
     {
      ErrMsg( "InitV4LDevice error: vd == NULL || device == NULL" );
      return -1;
     }
     if ( width == 0 || height == 0 )
     {
      ErrMsg( "InitV4LDevice error: width == 0 || height == 0" );
      return -1;
     }
     if ( grabmethod < 0 || grabmethod > 1 )
     {
      grabmethod = 1;    /* read by default */
     }

     vd->vd_device     = NULL;
     vd->vd_cameraname = NULL;
     vd->vd_device     = (char *)realloc( vd->vd_device, 32 );
     if ( vd->vd_device == NULL )
     {
      ErrSys( "InitV4LDevice realloc vd->vd_device errro" );
     }
     vd->vd_cameraname = (char *)realloc( vd->vd_cameraname, 32 );
     if ( vd->vd_cameraname == NULL )
     {
      ErrSys( "InitV4LDevice realloc vd->vd_cameraname error" );
     }
     snprintf( vd->vd_device, 32, "%s", device );
     memset( vd->vd_cameraname, 0, sizeof (vd->vd_cameraname) );
     memset( vd->vd_bridge, 0, sizeof (vd->vd_bridge) );
     vd->vd_width      = width;
     vd->vd_height     = height;
     vd->vd_format     = format;
     vd->vd_bpp        = GetDepth( vd->vd_format );
     vd->vd_grabmethod = grabmethod;
     vd->vd_framebuf   = NULL;
     ret               = InitV4L( vd );
     vd->vd_frame      = NULL;
     vd->vd_frame      = (unsigned char *)realloc(
      vd->vd_frame, (size_t)vd->vd_framesize
      );

     return ret;
}

/*
 * 关闭摄像头，成功：返回0
 */
int
CloseV4L( V4L_DEVICE *vd )
{
     if ( vd->vd_grabmethod )
     {
      munmap( vd->vd_framebuf, vd->vd_mmapsize );
     }
     else
     {
      free( vd->vd_framebuf );
      vd->vd_framebuf = NULL;
     }

     if ( close( vd->vd_fd ) < 0 )
     {
      ErrRet( "CloseV4L error: close error" );
      return -1;
     }

     /* 释放分配的内存 */
     if ( vd->vd_device != NULL )
     {
      free( vd->vd_device );
      vd->vd_device = NULL;
     }
     if ( vd->vd_cameraname != NULL )
     {
      free( vd->vd_cameraname );
      vd->vd_cameraname = NULL;
     }
     if ( vd->vd_frame != NULL )
     {
      free( vd->vd_frame );
      vd->vd_frame = NULL;
     }

     return 0;
}

int
GetJpegSize( unsigned char *buf, int insize )
{
     int i;

     for ( i = 1024; i < insize; i++ )
     {
      if ( (buf[i] == 0xff && (buf[i+1] == 0xD9)) )
      {
           return i + 2;
      }
     }

     return -1;
}


/*
 * 使用V4L抓取一帧图像，成功：返回图像大小，失败：返回-1
 */
int
V4LGrab( V4L_DEVICE *vd )
{
     int        len;
     int        size;
     int        jpegsize = -1;

     if ( vd->vd_grabmethod )
     {
      vd->vd_mmap.height = vd->vd_height;
      vd->vd_mmap.width  = vd->vd_width;
      vd->vd_mmap.format = vd->vd_format;

      if ( ioctl( vd->vd_fd, VIDIOCMCAPTURE, &(vd->vd_mmap) ) < 0 )
      {
           ErrSys( "V4LGrab error/VIDIOCMCAPTURE" );
      }
      if ( ioctl( vd->vd_fd, VIDIOCSYNC, &(vd->vd_mmap.frame) ) < 0 )
      {
           ErrSys( "V4LGrab error/VIDIOCSYNC" );
      }

      jpegsize = ConvertFrame(
           vd->vd_frame,
           vd->vd_framebuf + vd->vd_mbuf.offsets[vd->vd_mmap.frame],
           vd->vd_width,
           vd->vd_height,
           vd->vd_format,
           vd->vd_framesize
           );

      return jpegsize;
     }
     else
     {
      size = vd->vd_framesize;
      len  = read( vd->vd_fd, vd->vd_framebuf, size );
      if ( len < 0 )
      {
           ErrSys( "V4LGrab read error" );
      }
      jpegsize = ConvertFrame(
           vd->vd_frame,
           vd->vd_framebuf,
           vd->vd_width,
           vd->vd_height,
           vd->vd_format,
           vd->vd_framesize
           );

      return jpegsize;
     }

     return -1;
}

/*================================以下是静态函数定义================================*/

/*
 * 摄像头采集图像之前的初始化工作，成功：返回0，失败：终止程序.
 */
static int
InitV4L( V4L_DEVICE *vd )
{
     int ret;

     if ( (vd->vd_fd = open( vd->vd_device, O_RDWR )) < 0 )
     {
      ErrSys( "InitV4L open error" );
     }
     if ( ioctl( vd->vd_fd, VIDIOCGCAP, &vd->vd_capability ) < 0 )
     {
      ErrSys( "InitV4L get video capture error" );
     }
     snprintf( vd->vd_cameraname, 32, "%s", vd->vd_capability.name );

     ret = GetVideoPicture( vd );

     if ( ioctl( vd->vd_fd, VIDIOCGCHAN, &vd->vd_channel ) < 0 )
     {
      vd->vd_cameratype = UNOW;
     }
     else
     {
      if ( vd->vd_channel.name != NULL )
      {
           snprintf( vd->vd_bridge, 9, "%s", vd->vd_channel.name );
           vd->vd_cameratype = GetStreamID( vd->vd_bridge );
      }
      else
      {
           vd->vd_cameratype = UNOW;
      }
     }

     if ( vd->vd_cameratype != JPEG )
     {
      ErrSys( "Not a JPEG webcam sorry Abort!" );
     }
     vd->vd_picture.palette = vd->vd_format;
     vd->vd_picture.depth   = GetDepth( vd->vd_format );
     vd->vd_framesize       = (vd->vd_width * vd->vd_height >> 2);
     ret                    = SetVideoPicture( vd );
     if ( vd->vd_format != vd->vd_picture.palette
       || vd->vd_bpp    != vd->vd_picture.depth )
     {
      ErrSys( "couldn't set video palette Abort!" );
     }
     if ( vd->vd_grabmethod )
     {
      memset( &vd->vd_mbuf, 0, sizeof (vd->vd_mbuf) );
      if ( ioctl( vd->vd_fd, VIDIOCGMBUF, &vd->vd_mbuf ) < 0 )
      {
           ErrSys( "InitV4L get mbuf error" );
      }
      vd->vd_framebuf = (unsigned char *)mmap(
           0,
           vd->vd_mbuf.size,
           PROT_READ | PROT_WRITE,
           MAP_SHARED,
           vd->vd_fd,
           0
           );
      if ( vd->vd_framebuf == MAP_FAILED )
      {
           ErrSys( "InitV4L mmap error" );
      }
      vd->vd_mmapsize    = vd->vd_mbuf.size;
      vd->vd_mmap.height = vd->vd_height;
      vd->vd_mmap.width  = vd->vd_width;
      vd->vd_mmap.format = vd->vd_format;
      vd->vd_mmap.frame  = 0;
      if ( ioctl( vd->vd_fd, VIDIOCMCAPTURE, &vd->vd_mmap ) < 0 )
      {
           ErrSys( "V4LInit get capture error" );
      }
     }
     else
     {
      vd->vd_framebuf = (unsigned char *)realloc(
           vd->vd_framebuf,
           (size_t)vd->vd_framesize
           );
     }

     return ret;
}

/*
 * 转换图像格式，成功：返回图像大小，失败：返回-1
 */
static int
ConvertFrame(
     unsigned char *dst,
     unsigned char *src,
     int            width,
     int            height,
     int            format,
     int            size
     )
{
     int jpegsize = -1;

     switch ( format )
     {
     case VIDEO_PALETTE_JPEG:
      jpegsize = GetJpegSize( src, size );
      if ( jpegsize < 0 )
      {
           jpegsize = -1;
           break;
      }
      memcpy( dst, src, jpegsize );
      break;

     default:
      break;
     }

     return jpegsize;
}

/*
 * 获取图像属性，成功：返回0，失败：终止程序
 */
static int
GetVideoPicture( V4L_DEVICE *vd )
{
     if ( ioctl( vd->vd_fd, VIDIOCGPICT, &vd->vd_picture ) < 0 )
     {
      ErrSys( "GetVideoPicture error" );
     }

     return 0;
}

/*
 * 设置图像属性, 成功：返回0, 失败：终止程序
 */
static int
SetVideoPicture( V4L_DEVICE *vd )
{
     if ( ioctl( vd->vd_fd, VIDIOCSPICT, &vd->vd_picture ) < 0 )
     {
      ErrSys( "SetVideoPicture error" );
     }

     return 0;
}

static int
IsSpcaChip( const char *bridgename )
{
     int i    = -1;
     int find = -1;
     int size =  0;

     for ( i = 0; i < MAX_BRIDGE - 1; i++ )
     {
      size = strlen( g_list[i].bl_name );
      if ( strncmp( bridgename, g_list[i].bl_name, size ) == 0 )
      {
           find = i;
           break;
      }
     }

     return find;
}

static int
GetStreamID( const char *bridgename )
{
     int i     = -1;
     int match = -1;

     if ( (match = IsSpcaChip( bridgename )) < 0 )
     {
      return match;
     }

     switch ( match )
     {
     case BRIDGE_ZC3XX:
      i = JPEG;
      break;
     }

     return i;
}

static int
GetDepth( int format )
{
     int depth;

     switch ( format )
     {
     case VIDEO_PALETTE_JPEG:
      depth = 8;
      break;

     default:
      depth = -1;
      break;
     }

     return depth;
}

yudatun
关注
嵌入式Linux下LCD应用编程: 读取摄像头画面完成本地视频监控画面显示
走向CTO的路上...
06-07 489
在嵌入式Linux系统中实现本地视频监控功能,需要从摄像头读取画面数据,并将其显示在LCD上。在嵌入式Linux系统中实现本地视频监控功能,需要从摄像头读取视频流数据、解码视频帧,并将解码后的视频帧绘制到LCD上。通过调用LCD驱动程序提供的接口,将解码后的视频帧绘制到LCD上,从而实现本地视频监控的显示功能。总之,通过持续优化和扩展,可以将嵌入式Linux系统中的本地视频监控功能发展为智能、高效、多功能的解决方案,满足不同行业和场景的需求。调用LCD驱动程序的绘图函数,将当前视频帧绘制到LCD上。
linux-v4l视频采集源码
06-11
本程序是linux下采集视频源码程序，可用于PC上和嵌入式操作系统linux上，经过简单修改即可使用，欢迎下载
明天回家啦，庆祝一下，贡献一段源码，基于linux V4L视频采集摄像程序
奔跑
07-10 7002
/*****************************************************************************************************linux_m4v.cgcc -o linux_m4v linux_m4v.c -lc -lm -lxvidcore**********************************
linux下V4L视频采集总结
奔跑
06-01 7602
视频采集，调用V4L模块参数进行视频原始数据的采集。熟悉/include/linux/videodev.h，根据这个头文件来定义自己的video device的数据结构，下面是几个重要的数据结构，定义在videodev.h里    struct video_mmap vmmap;struct video_capability videocap;struct video_mbuf videombuf
嵌入式linux中V4L2应用程序开发
cjyusha的专栏
01-08 953
嵌入式linux中有标准的V4L2协议，很多摄像头驱动和应用都是基于V4L2来进行的，一般情况下，摄像头的设备号为/dev/video0 #define DEVICE_NAME /dev/video0 一 、 打开设备 int fd; void open_device(void) { fd = open(DEVICE_NAME, O_RDWR /*| O_NONBLOCK */,
基于v4l的视频采集显示程序。外加QT界面
08-17
Linux下的v4l视频采集播放程序，外加QT界面，可用于视频检控官及安防系统
嵌入式linux下QT开发 Camera摄像头采集视频源码
02-02
总之，这个项目为开发者提供了一个在嵌入式Linux环境中使用Qt进行摄像头视频采集的起点。通过学习和研究这个源码，开发者可以深入理解Qt与硬件交互的方式，以及如何在资源有限的嵌入式设备上构建高效、稳定的多媒体...
嵌入式LINUX环境下视频采集知识(V4L2)-joryers-ChinaUnix博客1
08-03
总之，V4L2为嵌入式Linux环境下的视频采集提供了全面的框架和工具，让开发者能够充分利用硬件资源，构建高效、灵活的视频处理系统。无论是在监控系统、视频会议还是多媒体播放器等应用中，V4L2都扮演着不可或缺的...
嵌入式linux图像采集编程接口函数V4L源码
11-08
Video for Linux（V4L）是一个核心的API，为Linux平台上的设备驱动提供了一种标准接口，用于支持视频捕获、视频输出以及视频编码解码等功能。本文将深入探讨V4L接口函数，并以"PXA_270-v4l源文件"为例，解析其在图像...
Linux V4L2 源码分析
负电离子的博客
10-13 1359
Linux V4L2 源码分析前言层次必要的数据结构源码分析ov2640.c 前言 Video For Linux 2真的是一个很复杂的框架，抽象倒不是它复杂的原因，是因为耦合了其他框架的内容，导致要掌握V4L2必须得需要一个非常广的内核层知识面，才能开始学习。这篇文章将会以ov2640.c为例子进行源码分析，我会尽量从上往下，也就是用户层调用到内核层进行分析。 注：在Linux内核层学习，你得学会适应庞大代码给你带来的不安感。 层次 首先，像OV2640这样类似的摄像头传感器，是由多部分组成的，需要I
v4l2视频采集
12-15
代码中包含通过V4L2接口来实现视频的采集以及编码部分，可以很好的对初学者进行思路整理，可以运行
Video4linux（v4l）摄像头采集jpeg图片
b02330224的专栏
09-17 804
1、Video4linux下视频编程的流程 （1）打开视频设备： （2） 读取设备信息 （3）更改设备当前设置（没必要的话可以不做） （4）进行视频采集，两种方法:         a.内存映射         b.直接从设备读取 （5）对采集的视频进行处理 （6）关闭视频设备。 2、为程序定义的数据结构 [cpp] view plaincopyprint?
FFMPEG音频开发: Linux下采集摄像头(使用V4L2框架)数据录制成MP4视频保存到本地
03-17 7837
一、环境介绍 操作系统介绍：ubuntu 18.04 FFMPEG版本: 4.4.2 摄像头: USB摄像头、虚拟机挂载本机自带摄像头 二、FFMPEG与X264下载编译 X264下载地址: http://www.videolan.org/developers/x264.html FFMPEG下载地址:https://ffmpeg.org/download.html Yasm ...
linux 摄像程序,基于linux V4L视频采集摄像程序
weixin_39888180的博客
05-04 133
/*****************************************************************************************************linux_m4v.cgcc -o linux_m4v linux_m4v.c -lc -lm -lxvidcore****************************************...
V4L2视频采集的基本流程
anqincui2000的博客
09-07 1687
V4L2视频采集的基本流程 嵌入式的Linux使用视频驱动V4L2（Video For Linux Two）来进行视频采集、输出。本文就V4L2的使用方式做简易说明。 视频采集的基本流程 一般的，视频采集都有如下流程： 打开视频设备 在V4L2中，视频设备被看做一个文件。使用open函数打开这个设备： // 用非阻塞模式打开摄像头设备int cameraFd;camer...
V4L2采集图像基本流程
yuyangyg的博客
03-14 7975
http://download.csdn.net/detail/yuyangyg/9780338
Linux V4L2 摄像头视频采集
热门推荐
jiang_dlut
09-07 1万+
<br />一，什么是 video4linux<br /> Video4linux（简称V4L),是linux中关于视频设备的内核驱动,现在已有Video4linux2，还未加入linux内核，使用需自己 下载补丁。在Linux中，视频设备是设备文件，可以像访问普通文件一样对其进行读写，摄像头在/dev/videoN下，N可能为0，1，2，3... 一般0.<br />另，推荐一个用于播放从摄像头采集到的raw数据的播放器RawPlayer，只需要把采集的数据保存到文件***.yuv就OK了。<br
嵌入式板上使用USB摄像头问题
benjaminwan的专栏
06-18 2838
前阶段我所说的ov511(网眼3000)在我自己写的程序以240x320方式下截图花屏，是因为ov511不支持此分辨率，已经在pc上用其他视频程序证实。现在我的程序可以良好的工作在240x240模式以RGB565方式输出图像，并且直接显示在液晶屏上。屏幕下方一段240x80的空间用来显示一些信息(说白了就是显示些字)，因为摄像头模块只是我所要做的一部分。 最近刚新买了一个中星微芯片zc0301p
linux v4l2进行视频采集编程介绍
技术交流
04-07 2178
使用V4L2进行视频采集，一般有下面的五个主要步骤： 1.打开设备（一般是/dev/video），进行初始化参数设置，包括分辨率，像素格式等； 2.申请图像帧缓冲，并进行内存映射mmap； 3.把帧缓冲进行入队操作，开始视频流进行采集； 4.进行出队，然后对数据进行处理，然后入队，如此循环往复； 5.释放资源，停止采集工作。 ...
嵌入式Linux V4L2视频采集详解
"嵌入式LINUX环境下视频采集知识(V4L2)-joryers-ChinaUnix博客1" 在嵌入式Linux系统中，视频采集是一个重要的功能，常常用于各种设备如监控摄像头、行车记录仪等。V4L2，全称为Video for Linux two，是Linux内核...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值