嵌入式Linux下LCD应用编程: 读取摄像头画面完成本地视频监控画面显示

简介: 嵌入式Linux下LCD应用编程: 读取摄像头画面完成本地视频监控画面显示

一、开发环境介绍

开发板:友善之臂Tiny4412


LCD型号: S702 、分辨率: 800*480


Linux内核版本: Linux 3.5


摄像头: USB免驱摄像头


文本显示采用矢量字库, FreeType引擎。


完整项目代码下载地址(包含矢量字库源码和编译安装方法): https://download.csdn.net/download/xiaolong1126626497/16680219


二、核心代码

注意: 文本编码必须是UTF-8编码.

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>
#include <poll.h>
#include <string.h>
#include <linux/fb.h>
#include <stdlib.h>
#include <math.h>
#include <wchar.h>
#include <time.h>
#include <string.h>
#include <locale.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_STROKER_H
/*定义一个结构体存放矢量字体的配置*/
struct FREE_TYPE_CONFIG
{
  FT_Library    library;
  FT_Face       face;
  FT_GlyphSlot  slot;
  FT_Vector     pen;                    /* untransformed origin  */
  FT_Error      error;
  FT_BBox  bbox;
  FT_Glyph  glyph;
};
struct FREE_TYPE_CONFIG FreeTypeConfig;
typedef unsigned int u32;
typedef unsigned short u16;
typedef unsigned char u8;
/*全局变量*/
int lcd_fd;
unsigned char *lcd_mem_p=NULL;  //保存LCD屏映射到进程空间的首地址
struct fb_var_screeninfo vinfo;
struct fb_fix_screeninfo finfo;
int video_fd;
char *video_buff_buff[4]; /*保存摄像头缓冲区的地址*/
int video_height=0;
int video_width=0;
unsigned char *lcd_display_buff; //LCD显存空间
/*函数声明*/
void LCD_WritePoint(int x,int y,int c);
int LCD_ReadPoint(int x,int y);
/*  LCD显示矢量字体的位图信息
 *    bitmap : 要显示的字体的矢量位图
 *    x : 显示的x坐标
 *    y : 显示的y坐标
 */
void LCD_DrawBitmap(FT_Bitmap* bitmap,FT_Int x,FT_Int y)
{
    FT_Int i,j,p,q;
    FT_Int x_max=x+bitmap->width;
    FT_Int y_max=y+bitmap->rows;
  /* 将位图信息循环打印到屏幕上 */
  for(i=x,p=0;i<x_max;i++,p++)
  {
    for(j=y,q=0;j<y_max;j++,q++)
    {
      if((i>x_max)||(j>y_max)||(i<0)||(j<0))continue;
      if(bitmap->buffer[q*bitmap->width+p]!=0)
      {
        LCD_WritePoint(i, j,0xFF0033);
      }
      else
      {
        //LCD_WritePoint(i, j,0xFFFFFF);
      }
    }
  }
}
/*
函数功能: 初始化FreeType配置
*/
int InitConfig_FreeType(char *font_file)
{
  FT_Error      error;
  /*1. 初始化freetype库*/
  error=FT_Init_FreeType(&FreeTypeConfig.library);
  if(error)
  {
    printf("freetype字体库初始化失败.\n");
    return -1;
  }
  /*2. 打开加载的字体文件*/
  error=FT_New_Face(FreeTypeConfig.library,font_file,0,&FreeTypeConfig.face);
    if(error)
    {
    printf("矢量字体文件加载失败.\n");
    return -2;
  }
  return 0;
}
/*
函数功能: 释放FreeType配置
*/
void FreeType_Config(void)
{
  FT_Done_Face(FreeTypeConfig.face);
    FT_Done_FreeType(FreeTypeConfig.library);
}
/*
函数功能: 在LCD屏显示一串文本数据
函数参数:
  u32 x   坐标位置
  u32 y   坐标位置
  u32 size 字体大小
  wchar_t *text 显示的文本数据
*/
int LCD_DrawText(u32 x,u32 y,u32 size,wchar_t *text)
{
  FT_Error      error;
  int i = 0;
  int bbox_height_min = 10000;
  int bbox_height_max = 0;
  /*3. 设置字符的像素的大小为size*size*/
  error=FT_Set_Pixel_Sizes(FreeTypeConfig.face,size,0);
  if(error)
  {
    printf("字符的像素大小设置失败.\n");
    return -1;
  }
  /*4. 设置字体文件的轮廓的插槽*/
  FreeTypeConfig.slot=FreeTypeConfig.face->glyph;
  /* 设置坐标为原点坐标
   * 将LCD坐标转换成笛卡尔坐标
   * 单位是 1/64 Point
   */
  FreeTypeConfig.pen.x=x*64;
    FreeTypeConfig.pen.y=(vinfo.yres-size-y)*64;
  /*5. 循环的将文字显示出来*/
  for(i=0;i<wcslen(text);i++)
  {
    FT_Set_Transform(FreeTypeConfig.face,0,&FreeTypeConfig.pen);  //设置字体的起始坐标位置
    /*装载字符编码,填充face的glyph slot成员*/
    error=FT_Load_Char(FreeTypeConfig.face,text[i],FT_LOAD_RENDER);
    if(error)
    {
      printf("装载字符编码失败.\n");
      return -1;
    }
    /*通过glyph slot来获得glyph*/
    FT_Get_Glyph(FreeTypeConfig.slot,&FreeTypeConfig.glyph);
    /*通过glyph来获得cbox*/
    FT_Glyph_Get_CBox(FreeTypeConfig.glyph,FT_GLYPH_BBOX_TRUNCATE,&FreeTypeConfig.bbox);
    /*获得字体高度的最大值和最小值*/
    if(bbox_height_min>FreeTypeConfig.bbox.yMin)bbox_height_min=FreeTypeConfig.bbox.yMin;
    if(bbox_height_max<FreeTypeConfig.bbox.yMax)bbox_height_max=FreeTypeConfig.bbox.yMax;
    /*画点,把笛卡尔坐标转换成LCD坐标*/
    LCD_DrawBitmap(&FreeTypeConfig.slot->bitmap,
            FreeTypeConfig.slot->bitmap_left,
            vinfo.yres-FreeTypeConfig.slot->bitmap_top);
    if(FreeTypeConfig.slot->bitmap_left+size*2>vinfo.xres)
    {
      FreeTypeConfig.pen.x=0; //更新X坐标位置
      FreeTypeConfig.pen.y=(vinfo.yres-size-y-size)*64; //更新Y坐标位置
    }
    else
    {
      /* 更新原点坐标位置 */
      FreeTypeConfig.pen.x+=FreeTypeConfig.slot->advance.x;
      FreeTypeConfig.pen.y+=FreeTypeConfig.slot->advance.y;
    }
  }
  return 0;
}
// 将char类型转化为wchar
// src:  源
// dest: 目标
// locale: 环境变量的值,mbstowcs依赖此值来判断src的编码方式
void CharToWchar(char *src, wchar_t *dest)
{
  // 根据环境变量设置locale
  setlocale(LC_CTYPE,"zh_CN.utf8");
  // mbstowcs函数得到转化为需要的宽字符大小: 计算char转为wcchar存放时实际占用空间大小.
  // 也可以直接传入一个大数组代替
  //w_size=mbstowcs(NULL, src, 0) + 1;
  mbstowcs(dest, src, strlen(src)+1);
}
/**
 * 画点函数
 */
void LCD_WritePoint(int x,int y,int c)
{
    unsigned int *p=(unsigned int *)(lcd_display_buff+vinfo.xres*y*vinfo.bits_per_pixel/8+x*vinfo.bits_per_pixel/8);
    *p=c;
}
/**
 * 读点函数
 */
int LCD_ReadPoint(int x,int y)
{
    int c;
    unsigned int *p=(unsigned int *)(lcd_display_buff+vinfo.xres*y*vinfo.bits_per_pixel/8+x*vinfo.bits_per_pixel/8);
    c=*p;
    return c;
}
/*初始化摄像头设备*/
int VideoDev_Init(const char *dev_path)
{
  /*1. 打开摄像头设备*/
  video_fd=open(dev_path,2);
  if(video_fd<0)return -1;
  /*2. 设置摄像头的输出图像尺寸与图像格式*/
  struct v4l2_format video_format;
  memset(&video_format,0,sizeof(struct v4l2_format));
  video_format.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; //捕获设备
  video_format.fmt.pix.height=480;
  video_format.fmt.pix.width=800;
  video_format.fmt.pix.pixelformat=V4L2_PIX_FMT_YUYV;
  if(ioctl(video_fd,VIDIOC_S_FMT,&video_format))return -2;
  printf("当前摄像头支持的分辨率:%dx%d\n",video_format.fmt.pix.width,video_format.fmt.pix.height);
  if(video_format.fmt.pix.pixelformat!=V4L2_PIX_FMT_YUYV)
  {
    printf("当前摄像头不支持YUYV格式输出.\n");
    return -3;
  }
  else
  {
    video_height=video_format.fmt.pix.height;
    video_width=video_format.fmt.pix.width; 
    printf("当前摄像头支持YUYV格式输出.\n");
  }
  /*3. 申请缓冲区*/
  struct v4l2_requestbuffers video_requestbuffers;
  memset(&video_requestbuffers,0,sizeof(struct v4l2_requestbuffers));
  video_requestbuffers.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
  video_requestbuffers.count=4;
  video_requestbuffers.memory=V4L2_MEMORY_MMAP;
  if(ioctl(video_fd,VIDIOC_REQBUFS,&video_requestbuffers))return -4;
  printf("成功申请的缓冲区数量:%d\n",video_requestbuffers.count);
  /*4. 得到每个缓冲区的地址: 将申请的缓冲区映射到进程空间*/
  struct v4l2_buffer video_buffer;
  memset(&video_buffer,0,sizeof(struct v4l2_buffer));
  int i;
  for(i=0;i<video_requestbuffers.count;i++)
  {
    video_buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
    video_buffer.index=i;
    video_buffer.memory=V4L2_MEMORY_MMAP;
    if(ioctl(video_fd,VIDIOC_QUERYBUF,&video_buffer))return -5;
    /*映射缓冲区的地址到进程空间*/
    video_buff_buff[i]=mmap(NULL,video_buffer.length,PROT_READ|PROT_WRITE,MAP_SHARED,video_fd,video_buffer.m.offset);
    printf("第%d个缓冲区地址:%#X\n",i,video_buff_buff[i]);
  } 
  /*5. 将缓冲区放入到采集队列*/
  memset(&video_buffer,0,sizeof(struct v4l2_buffer));
  for(i=0;i<video_requestbuffers.count;i++)
  {
    video_buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
    video_buffer.index=i;
    video_buffer.memory=V4L2_MEMORY_MMAP;
    if(ioctl(video_fd,VIDIOC_QBUF,&video_buffer))return -6;
  }
  /*6. 启动摄像头采集*/
  int opt_type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
  if(ioctl(video_fd,VIDIOC_STREAMON,&opt_type))return -7;
  return 0;
}
/*
将YUV格式数据转为RGB
*/
void yuv_to_rgb(unsigned char *yuv_buffer,unsigned char *rgb_buffer,int iWidth,int iHeight)
{
  int x;
  int z=0;
  unsigned char *ptr = rgb_buffer;
  unsigned char *yuyv= yuv_buffer;
  for (x = 0; x < iWidth*iHeight; x++)
  {
    int r, g, b;
    int y, u, v;
    if (!z)
    y = yuyv[0] << 8;
    else
    y = yuyv[2] << 8;
    u = yuyv[1] - 128;
    v = yuyv[3] - 128;
    r = (y + (359 * v)) >> 8;
    g = (y - (88 * u) - (183 * v)) >> 8;
    b = (y + (454 * u)) >> 8;
    *(ptr++) = (b > 255) ? 255 : ((b < 0) ? 0 : b);
    *(ptr++) = (g > 255) ? 255 : ((g < 0) ? 0 : g);
    *(ptr++) = (r > 255) ? 255 : ((r < 0) ? 0 : r);
    if(z++)
    {
      z = 0;
      yuyv += 4;
    }
  }
}
/*
LCD显示屏初始化
*/
int LCD_Init(const char *dev_path)
{
  /*1. 打开设备文件*/
    lcd_fd=open(dev_path,2);
    if(lcd_fd<0)
    {
        return -1;
    }
    /*2. 获取可变参数*/
    if(ioctl(lcd_fd,FBIOGET_VSCREENINFO,&vinfo))return -2;
    printf("屏幕X:%d   屏幕Y:%d  像素位数:%d\n",vinfo.xres,vinfo.yres,vinfo.bits_per_pixel);
  //分配显存空间,完成图像显示
  lcd_display_buff=malloc(vinfo.xres*vinfo.yres*vinfo.bits_per_pixel/8);
    /*3. 获取固定参数*/
    if(ioctl(lcd_fd,FBIOGET_FSCREENINFO,&finfo))return -3;
    printf("smem_len=%d Byte,line_length=%d Byte\n",finfo.smem_len,finfo.line_length);
    /*4. 映射LCD屏物理地址到进程空间*/
    lcd_mem_p =(unsigned char *)mmap(0,finfo.smem_len,PROT_READ|PROT_WRITE,MAP_SHARED,lcd_fd,0); //从文件的那个地方开始映射
    memset(lcd_mem_p,0xFFFFFFFF,finfo.smem_len);
  return 0;
}
//[root@wbyq code]# ./app /dev/video15 simhei.ttf 
//[root@wbyq code]# date -s "2020-09-19 09:39:20"
//编译程序记得加上-lfreetype
int main(int argc,char **argv)
{
  if(argc!=3)
  {
    printf("传参格式:./app </dev/videoX> <矢量字体文件>\n");
    return 0;
  }
  /*初始化配置FreeType*/
  InitConfig_FreeType(argv[2]);
  /*1. 初始化摄像头*/
  printf("摄像头初始化状态:%d\n",VideoDev_Init(argv[1]));
  /*2. 初始化LCD显示屏*/
  printf("LCD显示屏的初始化状态:%d\n",LCD_Init("/dev/fb0"));
  /*3. 读取摄像头的数据*/
  struct pollfd video_fds;
  video_fds.events=POLLIN;
  video_fds.fd=video_fd;
  struct v4l2_buffer video_buffer;
  memset(&video_buffer,0,sizeof(struct v4l2_buffer));
  unsigned char *rgb_buffer=malloc(video_height*video_width*3);
  unsigned char *rgb_p;
  int w,h;
  int x0;
  unsigned char r,g,b; 
  unsigned int c;
  time_t sec;
  struct tm c_timedate;
  char time_date[50];
  wchar_t time_date_wchar[100];
  x0=(vinfo.xres-video_width)/2; //摄像头图片显示的起始位置
  while(1)
  {
    /*等待摄像头采集数据*/
    poll(&video_fds,1,-1);
    /*得到缓冲区的编号*/
    video_buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
    video_buffer.memory=V4L2_MEMORY_MMAP;
    ioctl(video_fd,VIDIOC_DQBUF,&video_buffer);
    //printf("当前采集OK的缓冲区编号:%d,地址:%#X\n",video_buffer.index,video_buff_buff[video_buffer.index]);
    /*对缓冲区数据进行处理*/
    yuv_to_rgb(video_buff_buff[video_buffer.index],rgb_buffer,video_width,video_height);
    /*将图像数据显示在LCD屏幕上*/
    rgb_p=rgb_buffer;
    for(h=0;h<video_height;h++)
    {
      for(w=0;w<video_width;w++)
      {
        b=*rgb_p++;
        g=*rgb_p++;
        r=*rgb_p++;
        c=r<<16|g<<8|b<<0;
        LCD_WritePoint(w+x0,h,c); /*绘制像素点到LCD屏*/
      }
    }
    /*获取本地时间*/
    sec=time(NULL); //获取当前系统的秒单位时间
    localtime_r(&sec,&c_timedate); //将秒单位时间转为结构体返回
    sprintf(time_date,"%d-%d-%d %d:%d:%d",c_timedate.tm_year+1900,c_timedate.tm_mon+1,c_timedate.tm_mday,c_timedate.tm_hour,c_timedate.tm_min,c_timedate.tm_sec);
    //printf("time_date=%s\n",time_date);
    //char类型转Wchar
    CharToWchar(time_date,time_date_wchar);
    LCD_DrawText(x0,0,32,L"实训楼六楼");
    LCD_DrawText(x0,32,32,time_date_wchar);
    //显示屏进行显示: 将显存空间的数据拷贝到LCD屏进行显示
    memcpy(lcd_mem_p,lcd_display_buff,vinfo.xres*vinfo.yres*vinfo.bits_per_pixel/8);
    /*将缓冲区放入采集队列*/
    ioctl(video_fd,VIDIOC_QBUF,&video_buffer);
  }
  /*4. 关闭视频设备*/
  close(video_fd);
  return 0;
}

三、编译与运行效果

[root@wbyq code]# ./app /dev/video15 simhei.ttf 
当前摄像头支持的分辨率:640x480
当前摄像头支持YUYV格式输出.
成功申请的缓冲区数量:4
第0个缓冲区地址:0XB6CE9000
第1个缓冲区地址:0XB6C53000
第2个缓冲区地址:0XB6BBD000
第3个缓冲区地址:0XB6B27000
摄像头初始化状态:0
屏幕X:800   屏幕Y:480  像素位数:32
smem_len=4608000 Byte,line_length=3200 Byte
LCD显示屏的初始化状态:0

image.png

目录
相关文章
|
12天前
|
存储 监控 Linux
嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
在嵌入式Linux系统编程中,`times`和 `clock`函数是获取进程时间的两个重要工具。`times`函数提供了更详细的进程和子进程时间信息,而 `clock`函数则提供了更简单的处理器时间获取方法。根据具体需求选择合适的函数,可以更有效地进行性能分析和资源管理。通过本文的介绍,希望能帮助您更好地理解和使用这两个函数,提高嵌入式系统编程的效率和效果。
68 13
|
1月前
|
缓存 Linux 开发者
Linux内核中的并发控制机制:深入理解与应用####
【10月更文挑战第21天】 本文旨在为读者提供一个全面的指南,探讨Linux操作系统中用于实现多线程和进程间同步的关键技术——并发控制机制。通过剖析互斥锁、自旋锁、读写锁等核心概念及其在实际场景中的应用,本文将帮助开发者更好地理解和运用这些工具来构建高效且稳定的应用程序。 ####
46 5
|
1月前
|
存储 安全 关系型数据库
Linux系统在服务器领域的应用与优势###
本文深入探讨了Linux操作系统在服务器领域的广泛应用及其显著优势。通过分析其开源性、安全性、稳定性和高效性,揭示了为何Linux成为众多企业和开发者的首选服务器操作系统。文章还列举了Linux在服务器管理、性能优化和社区支持等方面的具体优势,为读者提供了全面而深入的理解。 ###
|
4月前
|
Unix Linux Ruby
在windows和linux上高效快捷地发布Dash应用
在windows和linux上高效快捷地发布Dash应用
|
4月前
|
Linux iOS开发 开发者
跨平台开发不再难:.NET Core如何让你的应用在Windows、Linux、macOS上自如游走?
【8月更文挑战第28天】本文提供了一份详尽的.NET跨平台开发指南,涵盖.NET Core简介、环境配置、项目结构、代码编写、依赖管理、构建与测试、部署及容器化等多个方面,帮助开发者掌握关键技术与最佳实践,充分利用.NET Core实现高效、便捷的跨平台应用开发与部署。
418 3
|
4月前
|
NoSQL Linux C语言
嵌入式GDB调试Linux C程序或交叉编译(开发板)
【8月更文挑战第24天】本文档介绍了如何在嵌入式环境下使用GDB调试Linux C程序及进行交叉编译。调试步骤包括:编译程序时加入`-g`选项以生成调试信息;启动GDB并加载程序;设置断点;运行程序至断点;单步执行代码;查看变量值;继续执行或退出GDB。对于交叉编译,需安装对应架构的交叉编译工具链,配置编译环境,使用工具链编译程序,并将程序传输到开发板进行调试。过程中可能遇到工具链不匹配等问题,需针对性解决。
160 3
|
4月前
|
存储 Linux 开发工具
【Azure App Service】本地Git部署Python Flask应用上云(Azure App Service For Linux)关键错误
【Azure App Service】本地Git部署Python Flask应用上云(Azure App Service For Linux)关键错误
|
4月前
|
存储 Linux 网络安全
【Azure App Service】.NET代码实验App Service应用中获取TLS/SSL 证书 (App Service Linux/Linux Container)
【Azure App Service】.NET代码实验App Service应用中获取TLS/SSL 证书 (App Service Linux/Linux Container)
|
4月前
|
JavaScript Linux
【Azure App Service for Linux】NodeJS镜像应用启动失败,遇见 RangeError: Incorrect locale information provided
【Azure App Service for Linux】NodeJS镜像应用启动失败,遇见 RangeError: Incorrect locale information provided
|
4月前
|
JavaScript Linux API
【Azure 应用服务】NodeJS Express + MSAL 应用实现AAD集成登录并部署在App Service Linux环境中的实现步骤
【Azure 应用服务】NodeJS Express + MSAL 应用实现AAD集成登录并部署在App Service Linux环境中的实现步骤