视频监控系统

基于jz2440开发板的视屏监控系统lcd实时显示转载请注明出处https://www.cnblogs.com/xiao-yong/p/9596235.html

main函数：

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>    

#include <asm/types.h>          /* for videodev2.h */    

#include <sys/time.h>   

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <error.h>    

#include <errno.h>

#include <malloc.h>   

#include <linux/fb.h>

#include <linux/videodev2.h>  

#include <assert.h>

#include "main.h"



#define CLIP(color) (unsigned char)(((color)>0xFF)?0xff:(((color)<0)?0:(color)))





static int *LutRv = NULL;

static int *LutGu = NULL;

static int *LutGv = NULL;

static int *LutBu = NULL;





struct buffer *buffers=NULL;





void fb_init(Fb_dev *myfb)

{

    struct fb_fix_screeninfo fb_fix;

    struct fb_var_screeninfo fb_var;

    

    //1、打开设备

    myfb->iFd = open(DEVICE_NAME, O_RDWR);

    //2、获取固定和可变参数

    ioctl(myfb->iFd, FBIOGET_FSCREENINFO, &fb_fix);

    ioctl(myfb->iFd, FBIOGET_VSCREENINFO, &fb_var);

    

    //3、打印屏幕参数

    printf("***********LCD-params****************
");

    printf("xres:%d, yres:%d
"

            "bits_per_pixel:%d
"

            "height:%d, %d
",

            fb_var.xres, fb_var.yres,

            fb_var.bits_per_pixel,

            fb_var.height, fb_var.width);

    printf("smem_start:%ld
"

            "smem_len:%d
"

            "line_length:%d
",

            fb_fix.smem_start,

            fb_fix.smem_len,

            fb_fix.line_length);

    printf("**************end********************
");  

    

    myfb->iWidth      = fb_var.xres;/* 宽度: 一行有多少个象素 */

    myfb->iHeight     = fb_var.yres;/* 高度: 一列有多少个象素 */

    myfb->iBpp           = fb_var.bits_per_pixel;/* 一个象素用多少位来表示 */

    myfb->iLineBytes     = fb_var.xres*fb_var.bits_per_pixel/8;/* 一行数据有多少字节 */

    myfb->iTotalBytes     = fb_var.yres*myfb->iLineBytes;/* 所有字节数 */

    

    //5、进行映射

    myfb->fb_addr = (char *)mmap(0,myfb->iTotalBytes,PROT_READ|PROT_WRITE, MAP_SHARED, myfb->iFd, 0);

     

}











void initLut(void)

{

    int i;

    #define CoefRv 1402

    #define CoefGu 714 // 344

    #define CoefGv 344 // 714

    #define CoefBu 1772

    

    LutRv = malloc(256*sizeof(int));

    LutGu = malloc(256*sizeof(int));

    LutGv = malloc(256*sizeof(int));

    LutBu = malloc(256*sizeof(int));

    

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

        LutRv[i] = (i-128)*CoefRv/1000;

        LutBu[i] = (i-128)*CoefBu/1000;

        LutGu[i] = (128-i)*CoefGu/1000;

        LutGv[i] = (128-i)*CoefGv/1000;

    }    

}



void freeLut(void){

    free(LutRv);

    free(LutGu);

    free(LutGv);

    free(LutBu);

}









unsigned char R_FROMYV(unsigned char y, unsigned char v)

{

    return CLIP((y) + LutRv[(v)]);

}

unsigned char G_FROMYUV(unsigned char y, unsigned char u, unsigned char v)

{

    return CLIP((y) + LutGu[(u)] + LutGv[(v)]);

}

unsigned char B_FROMYU(unsigned char y, unsigned char u)

{

    return CLIP((y) + LutBu[(u)]);

}





unsigned int Pyuv422torgb565(unsigned char * input_ptr, unsigned char * output_ptr, unsigned int image_width, unsigned int image_height)

{

    unsigned int i, size;

    unsigned char Y, Y1, U, V;

    unsigned char *buff = input_ptr;

    unsigned char *output_pt = output_ptr;



    unsigned int r, g, b;

    unsigned int color;

    

    size = image_width * image_height /2;

    for (i = size; i > 0; i--) {

        /* bgr instead rgb ?? */

        Y = buff[0] ;

        U = buff[1] ;

        Y1 = buff[2];

        V = buff[3];

        buff += 4;

        r = R_FROMYV(Y,V);

        g = G_FROMYUV(Y,U,V); //b

        b = B_FROMYU(Y,U); //v



        /* 把r,g,b三色构造为rgb565的16位值 */

        r = r >> 3;

        g = g >> 2;

        b = b >> 3;

        color = (r << 11) | (g << 5) | b;

        *output_pt++ = color & 0xff;

        *output_pt++ = (color >> 8) & 0xff;

            

        r = R_FROMYV(Y1,V);

        g = G_FROMYUV(Y1,U,V); //b

        b = B_FROMYU(Y1,U); //v

        

        /* 把r,g,b三色构造为rgb565的16位值 */

        r = r >> 3;

        g = g >> 2;

        b = b >> 3;

        color = (r << 11) | (g << 5) | b;

        *output_pt++ = color & 0xff;

        *output_pt++ = (color >> 8) & 0xff;

    }

    

    return 0;

} 







/********************************

*函数功能：初始化摄像头+显示摄像头信息

*********************************/

void init_device(Cam_dev *camdev,Fb_dev *myfb)

{

    unsigned int n_buffers;

    struct v4l2_requestbuffers req;

    struct v4l2_capability cap;

    struct v4l2_fmtdesc fmtdesc;

    struct v4l2_format fmt;

    

    //0、打开摄像头

    if((camdev->cfd=open(dev_name,O_RDWR|O_NONBLOCK,0))<0)

    {

    printf("device:%s open failed!!
",dev_name);    

    exit(-1);

    }

    

    //1、查询摄像头信息并打印

    if (ioctl(camdev->cfd, VIDIOC_QUERYCAP, &cap) == -1) 

    {

        printf("Error opening device %s: unable to query device.
",dev_name);

        exit(-1);

    }

    else

    {

        /*打印信息*/

        printf("*************Camera-params***************
");

        printf("driver:		%s
",    cap.driver);

        printf("card:		%s
",        cap.card);

        printf("bus_info:	%s
",    cap.bus_info);

        printf("version:	%d
",    cap.version);

        printf("capabilities:	%x
",    cap.capabilities);

        printf("*****************end*********************
");

         

        /*检测摄像头是否支持图像抓取功能*/

        if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == V4L2_CAP_VIDEO_CAPTURE) 

        {

            printf("Device %s: supports capture.
",dev_name);

        }

    /*检测摄像头是否支持视频流*/

        if ((cap.capabilities & V4L2_CAP_STREAMING) == V4L2_CAP_STREAMING) 

        {

            printf("Device %s: supports streaming.
",dev_name);

        }

    }



    //2、打印所有支持格式

    ///////////////////////////////////////////////////////////////

    printf("Support format:
");

    fmtdesc.index    = 0;

    fmtdesc.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    while(ioctl(camdev->cfd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)

    {

        printf("	%d.%s
",fmtdesc.index+1,fmtdesc.description);

        fmtdesc.index++;

    }

    /////////////////////////////////////////////////////////////////

    

    //3、设置摄像头格式

    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    fmt.fmt.pix.height         = myfb->iHeight;

    fmt.fmt.pix.width         = myfb->iWidth;

    fmt.fmt.pix.field         = V4L2_FIELD_ANY;//V4L2_FIELD_INTERLACED;

    fmt.fmt.pix.pixelformat     = V4L2_PIX_FMT_YUYV;

    

    if (-1 == ioctl(camdev->cfd, VIDIOC_S_FMT, &fmt))  

    { 

        printf("VIDIOC_S_FMT error!
");

    exit(-1);   

    }

        

    if(ioctl(camdev->cfd, VIDIOC_G_FMT, &fmt) == -1)

    {

        printf("Unable to get format
");

        exit(-1); 

    } 



    printf("fmt.type:		%d
",fmt.type);

    printf("pix.pixelformat:	%c%c%c%c
",fmt.fmt.pix.pixelformat & 0xFF, (fmt.fmt.pix.pixelformat >> 8) & 0xFF,(fmt.fmt.pix.pixelformat >> 16) & 0xFF, (fmt.fmt.pix.pixelformat >> 24) & 0xFF);

    printf("pix.height:		%d
",fmt.fmt.pix.height);

    printf("pix.		%d
",fmt.fmt.pix.width);

    printf("pix.field:		%d
",fmt.fmt.pix.field);

    //保存摄像头图像像素信息

    camdev->cWidth      = fmt.fmt.pix.width;

    camdev->cHeight     = fmt.fmt.pix.height;

    camdev->cLineBytes    = fmt.fmt.pix. bytesperline;

    camdev->cTotalBytes = fmt.fmt.pix. sizeimage;

 

    //4、请求四个缓冲帧

    req.count    = REBUF_CNT;

    req.memory    = V4L2_MEMORY_MMAP;

    req.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    

    if(ioctl(camdev->cfd,VIDIOC_REQBUFS,&req)==-1)

    {

        printf("request for buffers error！
");

    }

    if (req.count < 2)

    {

        printf("Insufficient buffer memory on %s
",dev_name); 

           exit(-1);

    }

    

    //2、分配图像缓冲结构 （mmap for buffers） 

    buffers = calloc(req.count, sizeof (struct buffer));  

    if (!buffers) 

    {

        printf ("Out of memory: error!
");

        exit(-1);

    }

    

    //3、把内核空间中的图像缓冲区映射到用户空间 

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

    {   

    struct v4l2_buffer buf;   

        

    CLEAR(buf);   

    buf.index       = n_buffers;

    buf.memory      = V4L2_MEMORY_MMAP;          

    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;   

    

    /*获取要映射屏幕大小*/

    if (-1 == ioctl(camdev->cfd, VIDIOC_QUERYBUF, &buf))   

    {

         printf ("VIDIOC_QUERYBUF error!
");

        exit(-1);   

    }    

    

    /*这里的输出是为了检查有关参数的大小*/

    camdev->cTotalBytes       = buf.length;   

    

    buffers[n_buffers].length = buf.length;   

    

    

    buffers[n_buffers].start =   

        mmap(NULL /* start anywhere */,   

        buf.length,   

        PROT_READ | PROT_WRITE /* required */,   

        MAP_SHARED /* recommended */,   

        camdev->cfd, buf.m.offset);   

    /*不成功则退出*/

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

    {

         printf ("mmap error!
");

        exit(-1);   

    }  

    } 

    

    /*将缓冲帧放入队列*/

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

    {   

    struct v4l2_buffer buf;   

    CLEAR(buf);   

    

    buf.index       = n_buffers;   

    buf.memory      = V4L2_MEMORY_MMAP;   

    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;  

        

    if (-1 == ioctl(camdev->cfd, VIDIOC_QBUF, &buf))   

    {

         printf ("VIDIOC_QBUF error!
");

        exit(-1);   

    }  

    }   

    

    camdev->displaybuf =(char*)malloc(camdev->cTotalBytes);

    

}





/********************************

*函数功能：启动捕获图像

*********************************/

void start_capture(int cfd)

{

    /*帧类型，应用程序设置  */

    enum v4l2_buf_type type;

 

    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;   

    /*启动数据流*/

    if (-1 == ioctl(cfd, VIDIOC_STREAMON, &type))  

    {

         printf ("VIDIOC_STREAMON error!
");

        exit(-1);   

    }    

    printf ("Start Video Capturing!
");

}





void display_pic(Cam_dev *camdev,Fb_dev *myfb)

{

    struct v4l2_buffer buf;   

    unsigned char* ptmp;

    unsigned long i,j;

    

    CLEAR (buf);   

    buf.memory     = V4L2_MEMORY_MMAP;   

    buf.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;   

    

    /*取出一缓冲帧*/

    if (-1 == ioctl(camdev->cfd, VIDIOC_DQBUF, &buf)) 

    {   

    printf(" VIDIOC_DQBUF error!
");

    exit(-1);

    }   

    /*检查缓冲帧是否有效*/

    assert(buf.index < 4);  

     

    /*图片格式转换:YUV422->RGB565*/

    ptmp = (unsigned char*)buffers[buf.index].start;

    

    Pyuv422torgb565(ptmp,camdev->displaybuf,camdev->cHeight,camdev->cWidth);

    

    PicMerge(camdev,myfb);

    

    if (-1 == ioctl(camdev->cfd, VIDIOC_QBUF, &buf))   

    {

        printf("VIDIOC_QBUF error!
");

    exit(-1);    

    }

}





int PicMerge(Cam_dev *camdev,Fb_dev *myfb)

{

    int i;

    int iX,iY;

    unsigned char *pucSrc;

    unsigned char *pucDst;

    

    iX = (myfb->iWidth -camdev->cWidth )/2;

    iY = (myfb->iHeight -camdev->cHeight )/2;

    

       //指向放缩后的图像

    pucSrc = camdev->displaybuf;

    //计算空出来的起始的空格

    pucDst = myfb->fb_addr + iY * myfb->iLineBytes + iX *myfb->iBpp/8;

    

    for (i = 0; i <camdev->cHeight; i++)

    {

        memcpy(pucDst, pucSrc, camdev->cLineBytes);

        pucSrc += camdev->cLineBytes;

        pucDst += myfb->iLineBytes;

    }

    return 0;

}












void uninit_device(Cam_dev *camdev,Fb_dev *myfb)

{

    unsigned int i;

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

      munmap (buffers[i].start, buffers[i].length);   

    free(buffers);  

    free(camdev->displaybuf);

    close(camdev->cfd);

    close(myfb->iFd);

    printf("quit!!
");

}











int main(void)

{

    int ret;

    fd_set fds;

    struct timeval tv; 

        

           Fb_dev  myfb;   //显示设备

           Cam_dev camdev; //图像采集设备

           

    //1、初始化显示设备

    fb_init(&myfb);

    init_device(&camdev,&myfb);

    initLut();//初始化颜色转换

    //4、开启捕捉视频

    start_capture(camdev.cfd);

    

    while(1)

    {

            /*每次循环都要清空*/

        FD_ZERO(&fds);   

        /*添加描述符*/

        FD_SET(camdev.cfd, &fds);   

        

        /* Timeout. */   

        tv.tv_sec  = 20;   

        tv.tv_usec = 0;   

        ret = select (camdev.cfd + 1, &fds, NULL, NULL, NULL);   

          

        /*select错误，退出*/

        if (-1 == ret) 

        {   

            printf("Select() error!
");

            //exit(-1);   

            break;

        }   

        if (0 == ret) {   

            printf("select timeout
");   

            continue;   

        }   

        if(FD_ISSET(camdev.cfd, &fds))

        {

            display_pic(&camdev,&myfb);

        }

    

            

    }

        

    freeLut();//释放颜色转换空间

    uninit_device(&camdev,&myfb);

    return 0;    

}

.h文件

#ifndef _V4L2_INIT

#define _V4L2_INIT







#define dev_name "/dev/video0"

#define REBUF_CNT  4

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





typedef struct fbdev

{

    int iFd;      /*lcd文件描述符*/

    int iWidth;   /* 宽度: 一行有多少个象素 */

    int iHeight;  /* 高度: 一列有多少个象素 */

    int iBpp;     /* 一个象素用多少位来表示 */

    int iLineBytes;  /* 一行数据有多少字节 */

    int iTotalBytes; /* 所有字节数 */ 

    char *fb_addr;//用户层映射后的地址

}Fb_dev;



#define DEVICE_NAME "/dev/fb0"



void fb_init(Fb_dev *myfb);



unsigned int 

Pyuv422torgb565(unsigned char * input_ptr, unsigned char * output_ptr, 

        unsigned int image_width, unsigned int image_height);

        

void initLut(void);

void freeLut(void);

/*******************************

*用来存放帧缓冲地址和长度

*******************************/

struct buffer

{

    void * start;

    unsigned int length;

};





typedef struct camdev

{

    int cfd;      /*lcd文件描述符*/

    int cWidth;   /* 宽度: 一行有多少个象素 */

    int cHeight;  /* 高度: 一列有多少个象素 */

    int cLineBytes;  /* 一行数据有多少字节 */

    int cTotalBytes; /* 所有字节数 */ 

    char *displaybuf;

}Cam_dev;



void init_device(Cam_dev *camdev,Fb_dev *myfb);

void start_capture(int cfd);

void yuv422_2_rgb(unsigned char* ptr);

void display_pic(Cam_dev *camdev,Fb_dev *myfb);

int PicMerge(Cam_dev *camdev,Fb_dev *myfb);



void uninit_device(Cam_dev *camdev,Fb_dev *myfb);





#endif

直接拷贝到linux环境下 编译即可运行。