usb camera demo

最新推荐文章于 2024-03-04 10:42:36 发布
最新推荐文章于 2024-03-04 10:42:36 发布
阅读量182 收藏
点赞数
分类专栏： USB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmzjzwlzs/article/details/86498195
版权

int song(char **argv){
    int g_out_width = 1280;
    int g_out_height = 720;

    int fb_fd;
    int i,x,y,cur_id;
    char buff[3];
    char *fb_mem;
    unsigned char r,g,b,count;
    unsigned char y1,u1,v1;
    
    int vd_fd;
    struct v4l2_format fmt;
    struct v4l2_frmsizeenum frmsize;
    struct v4l2_streamparm parm;
    struct v4l2_fmtdesc fmtdesc;
    struct v4l2_capability cap;
    struct v4l2_requestbuffers req;
    VideoBuffer *buffers;
    struct v4l2_buffer buf;
    struct v4l2_plane planes = { 0 };

    char vd_name[100];
    char vd_id = argv[1][0];
    char vd_id_i = vd_id -48;
    vd_id_i = 0;
    int off_x =0;
    int off_y =0;
    int count_s =0;

    char * temp_buff = malloc(1920*720*4);    
    memset(vd_name,0,100);
    sprintf(vd_name, "/dev/video%c", vd_id);

    if ((fb_fd = open("/dev/graphics/fb0", O_RDWR, 0)) < 0) {
        printf("song can not open fb0\n");
        return 1;
    }
    fb_mem = mmap (NULL, 1920*720*4, PROT_READ|PROT_WRITE,MAP_SHARED,fb_fd,0);
    
    if ((vd_fd = open(vd_name, O_RDWR, 0)) < 0) {
        printf("song can not open %s\n", vd_name);
        return 1;
    }
    printf("song open %s ok\n", vd_name);

    printf("\n song VIDIOC_QUERYCAP\n");
    if (ioctl(vd_fd, VIDIOC_QUERYCAP, &cap) == 0) {
        printf("cap=0x%x\n", cap.capabilities);
        if (!(cap.capabilities & V4L2_BUF_TYPE_VIDEO_CAPTURE)) {
            printf("song not support v4l2 capture device.\n");
            return -1;
        }
    } else {
        close(vd_fd);
        printf("VIDIOC_QUERYCAP fail\n");
        return -1;
    }

    printf("\n song VIDIOC_ENUM_FMT\n");    
    fmtdesc.index=0;
    fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
    while(ioctl(vd_fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
    {
        printf("/t%d.%s/n",fmtdesc.index+1,fmtdesc.description);
        fmtdesc.index++;

        frmsize.pixel_format = fmtdesc.pixelformat;
              frmsize.index = 0;
             while (ioctl(vd_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) >= 0){
             printf("fbl:%dx%d\n", frmsize.discrete.width, frmsize.discrete.height);
            frmsize.index++;
             }
    }
    
    printf("\n song VIDIOC_S_FMT\n");    
    memset(&fmt, 0, sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    //fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_BGR24;
//    fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_RGB24;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.width = g_out_width;
    fmt.fmt.pix.height = g_out_height;
//    fmt.fmt.pix_mp.num_planes = 1;    /* RGB */
    if (ioctl(vd_fd, VIDIOC_S_FMT, &fmt) < 0) {
        printf("set format failed\n");
        goto fail;
    }
    
    printf("\n song VIDIOC_G_FMT\n");        
    memset(&fmt, 0, sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if (ioctl(vd_fd, VIDIOC_G_FMT, &fmt) < 0) {
        printf("get format failed\n");
        goto fail;
    }
    printf(" width=%d, height=%d, \n",fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height);
    print_pixelformat2("***** pixelformat", fmt.fmt.pix_mp.pixelformat);

    printf("\n song VIDIOC_G_PARM\n");    
    memset(&parm, 0, sizeof(parm));
    parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if (ioctl(vd_fd, VIDIOC_G_PARM, &parm) < 0) {
        printf("VIDIOC_G_PARM failed\n");
    }    

    printf("\n song VIDIOC_REQBUFS\n");    
    memset(&req, 0, sizeof(req));
    req.count = 3;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;

    if (ioctl(vd_fd, VIDIOC_REQBUFS, &req) < 0) {
        printf("VIDIOC_REQBUFS failed\n");
        goto fail;
    }
    
    buffers = calloc(req.count, sizeof(VideoBuffer));
    
    for(i=0;i<3;i++){
        printf("\n song VIDIOC_QUERYBUF\n");
        memset( &buf, 0, sizeof(buf));
        memset(&planes, 0, sizeof(planes));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;        
        buf.memory = V4L2_MEMORY_MMAP;    
    
        //buf.m.planes = &planes;
        buf.length = 1;    /* plane num */
        buf.index = i;
        if (ioctl(vd_fd, VIDIOC_QUERYBUF, &buf) < 0){
            printf("VIDIOC_QUERYBUF error\n");
            goto fail;
        }

        buffers[i].length = buf.length;
        printf("\n buffers[i].length :%d\n", buffers[i].length);
        buffers[i].offset = (size_t) buf.m.offset;
        buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, vd_fd, buf.m.offset);            
        if (buffers[i].start == MAP_FAILED){
            printf("buffers error\n");
            goto fail;
        }
    }
printf("\n 11111 buffers[i].length :%d\n", buffers[0].length);
    for(i=0;i<3;i++){
        printf("\n song VIDIOC_QBUF\n");    
        memset( &buf, 0, sizeof(buf));
        memset(&planes, 0, sizeof(planes));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;        
        buf.memory = V4L2_MEMORY_MMAP;    
        //buf.m.planes = &planes;
        buf.length = buffers[i].length;
        buf.length = 1;    /* plane num */
        buf.index = i;
        buf.m.offset = buffers[i].offset;
        if (ioctl(vd_fd, VIDIOC_QBUF, &buf) < 0){
            printf("VIDIOC_QBUF error\n");
            goto fail;
        }
    }
printf("\n 2222 buffers[i].length :%d\n", buffers[0].length);
    printf("\n song VIDIOC_STREAMON\n");    
    enum v4l2_buf_type type;    
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;            
    if (ioctl(vd_fd, VIDIOC_STREAMON, &type) < 0){
        printf("VIDIOC_STREAMON error\n");
        goto fail;
    }
printf("\n 3333 buffers[i].length :%d\n", buffers[0].length);
count =0;
    while(1){    
        //count++;
        printf("\n song VIDIOC_DQBUF\n");
        memset( &buf, 0, sizeof(buf));
        memset(&planes, 0, sizeof(planes));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;    
        buf.memory = V4L2_MEMORY_MMAP;
        //buf.m.planes = &planes;
        buf.length = 1;    /* plane num */
        if (ioctl(vd_fd, VIDIOC_DQBUF, &buf) < 0){
            printf("VIDIOC_DQBUF failed.\n");
            goto fail;        
        }    
        cur_id = buf.index;
    //    printf("\n cur_id:%d\n",cur_id );
    //    printf("\n buffers[cur_id].length :%d\n",buffers[cur_id].length );
    //    sleep(1);
        count_s=0;
    //    printf("count_s:%d\n", count_s);

        for (x = 0; x < g_out_height; ++x) {
            memcpy(&(fb_mem[x*1920*4]),&(temp_buff[x*g_out_width*4]),g_out_width*4);

        }

 

    
        for (x = 0; x < g_out_height; ++x) {
            for (y = 0; y < g_out_width; ++y){                            
                 y1 = buffers[cur_id].start[x*g_out_width*2+2*y];
                if(y%2==0){
                    u1 = buffers[cur_id].start[x*g_out_width*2+2*y+1];
                    v1 = buffers[cur_id].start[x*g_out_width*2+2*y+3];
                }else{
                    u1 = buffers[cur_id].start[x*g_out_width*2+2*y-1];
                    v1 = buffers[cur_id].start[x*g_out_width*2+2*y+1];
                }
    
                //y1 = buffers[cur_id].start[x*g_out_width*2+2*y+1];
                //if(y%2==0){
                //    v1 = buffers[cur_id].start[x*g_out_width*2+2*y+2];
                //    u1 = buffers[cur_id].start[x*g_out_width*2+2*y];
            //    }else{
            //        v1 = buffers[cur_id].start[x*g_out_width*2+2*y];
            //        u1 = buffers[cur_id].start[x*g_out_width*2+2*y-2];
            //    }
                            
                r = (y1) + 1.403 *(v1 - 128);   
                g = (y1) - 0.343 *(u1 - 128) - 0.714 *(v1 - 128);
                b = (y1) + 1.77 *(u1 - 128) ;
                
                temp_buff[(x)*g_out_width*4+4*(y)+0] = b;
                                temp_buff[(x)*g_out_width*4+4*(y)+1] = g;
                                temp_buff[(x)*g_out_width*4+4*(y)+2] = r;
            }
        }

        printf("\n song VIDIOC_QBUF\n");    
        memset( &buf, 0, sizeof(buf));
        memset(&planes, 0, sizeof(planes));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;        
        buf.memory = V4L2_MEMORY_MMAP;    
        //buf.m.planes = &planes;
        buf.length = buffers[cur_id].length;
        buf.length = 1;    /* plane num */
        buf.index = cur_id;
        buf.m.offset = buffers[cur_id].offset;
        if (ioctl(vd_fd, VIDIOC_QBUF, &buf) < 0){
            printf("VIDIOC_QBUF error\n");
            goto fail;
        }
    }

fail:    
    close(fb_fd);
    close(vd_fd);    
    return 1;
}

wmzjzwlzs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AndroidUsb摄像头Demo
08-22
AndroidUsb摄像头，读取外界摄像头，支持实时预览，拍照，录像，录音。
外接USB摄像头Demo
03-17
Android 调用外接USB UVCCamera完成自动对焦拍照。
usbcamera_demo
08-03
usbcamera_demo
支持打开两个USBcamera的测试demo
05-24
支持同时打开两个USBcamera,支持手动选择节点和分辨率
USB Camera Demo
09-11
《Android USB Camera开发详解——基于USB Camera Demo源码分析》 在移动设备上，相机功能是不可或缺的一部分。然而，随着技术的发展，用户对于相机的需求不仅仅局限于内置摄像头，外接USB摄像头成为了新的探索方向...
android 连接多个usb camera的demo
09-11
这个"android 连接多个usb camera的demo"项目提供了一个解决方案，允许开发者在Android设备上实现对多个USB摄像头的接入和控制。 首先，我们要了解的是Android对USB设备的支持。从Android 3.1版本开始，Android引入...
USB Camera Demo in CortexM0 (Nuvoton Nano130)
07-15
在Cortex M0处理上实现USB摄像头的DEMO代码。此代码在Nuvoton Nano130（开发板：NuTiny-SDK-Nano130）上成功运行。用一内置的图片作为摄像头上传的视频流数据作为演示。其中USB摄像头设备属性协商部分在本代码中没有...
前后摄和USB摄像头DEMOAPK
06-25
该应用为同时打开前摄像头、后摄像头和一路USB摄像头。需设备支持前后摄同时开启
【USBCamera】UVCCamera多摄像头预览拍照
lianghao的博客
04-28 4342
USB多摄像头同时预览和拍照
Android多路USB摄像头Demo
08-09
操作/dev/video，此demo仅提供开发思路，本人测试时无法打开video1，报VIDIOC_S_FMT error 16, Device or resource busy
USB摄像头实现ORB_SLAM2
Miniebin的博客
03-19 548
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、具体实现步骤1. 创建catkin 工作空间：2.编译catkin 工作空间3.编译usb_cam package4. 打开 usb_cam-test.launch总结 前言 这篇文章主要记录以下我是如何使用USB 实现ORB_SLAM2,以及在编译过程中出现的错误是如何解决，希望能够帮助别人在实现这个框架的时候避免踩雷 提示：本文章的实现基础是 Ubuntu 18.04, 其他的Eigen3, OpenCV，Pango
V4L2文档翻译（十三）
Feed Technology
05-05 5308
http://linuxtv.org/downloads/v4l-dvb-apis/dmabuf.html I/O流 （DMA缓存引用） 这是一个实验性接口，将来可能发生改变 DMABUF框架提供了在多设备见共享缓存的通用方法，支持DMABUF的设备驱动可以将一个DMA缓存以文件句柄的方式输出到用户空间（输出者规则），以文件句柄的方式从用户空间获取一个DMA缓存，这个文件句柄是之前其
基于V4L2采集摄像头数据
lingyi_cai的博客
09-28 2308
基于Linux Kernel V4L2框架验证采集摄像头数据，捕获到的yuv数据在7yuv.exe进行查看，从而验证摄像头驱动到应用层的数据链路完整性。源码如下所示： #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <sys/ioctl.h> #include <linux/types.h> #in
Android P摄像头开发和V4l2视频处理
Sunxiaolin2016的博客
06-04 4722
基于安卓9.0系统，简单实现打开摄像头并获取视频流数据。 1、打开摄像头 摄像头设备为：/dev/video0 //打开摄像头 deviceName为/dev/video0 if ((fd = open(deviceName, O_RDWR, 0)) < 0){ return false; } 2、查询视频设备的能力，是否具有视频输入，或者音频输入功能 v4l2_capabili...
全志D1-H开发板USB摄像头拍照Demo
最新发布
DOT小文哥的博客
03-04 1096
本章节将讲解如何D1-H上使用一个USB摄像头拍摄一张照片。D1-H哪吒开发板上有一个USB Host接口（即电脑上那种插鼠标键盘的USB口），同时D1-H Tina Linux支持UVC（USB Video Class，USB视频类），这样D1-H就具备了开发和使用USB摄像头的软硬件条件。
Android USB Camera
你好呀，信田君！
06-21 2892
Android 设备基于linux kernel, 自带V4L2支持。 z
V4L2命令之 VIDIOC_G_PARM, VIDIOC_S_PARM
woxx
10-29 9390
http://linuxtv.org/downloads/v4l-dvb-apis/vidioc-g-parm.html Name VIDIOC_G_PARM, VIDIOC_S_PARM — Get or set streaming parameters //获取或设置数据流的参数，一般设置帧率等参数 Synopsis int ioc
终于搞定android驱动USB摄像头了！
热门推荐
zhuanghuahui的专栏
07-25 1万+
终于搞定android驱动USB摄像头了！ 多亏了stackoverflow看到的一篇帖子，其中有几句关键的话，然后顺藤摸瓜解决了问题。 帖子大意： 讨论的前提是你的USB摄像头是UVC兼容的（如今大部分摄像头兼容） 默认Android不提供访问外部摄像头的API，所以你要考虑写一个内核到Android应用层通信的中间件。 当你给设备接入了USB摄像头，首先要检查一下几点： 1)你
camera demo
04-07
I'm sorry, as an AI language model, I do not have the ability to demonstrate a camera. However, I can provide you with information on how to demo a camera if you would like. Please let me know if you have any specific requests or questions.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值