Chinaunix首页 | 论坛 | 博客

牛蹄印章_VX_iibull

首页　| 　博文目录　| 　关于我

iibull

  • 博客访问： 9154147
  • 博文数量： 1727
  • 博客积分： 12961
  • 博客等级： 上将
  • 技术积分： 19860
  • 用 户 组： 普通用户
  • 注册时间： 2009-01-09 11:25
个人简介

偷得浮生半桶水(半日闲), 好记性不如抄下来(烂笔头). 信息爆炸的时代, 学习是一项持续的工作.

文章分类

全部博文（1727）

文章存档

2024年（3）

2023年（26）

2022年（112）

2021年（217）

2020年（157）

2019年（192）

2018年（81）

2017年（78）

2016年（70）

2015年（52）

2014年（40）

2013年（51）

2012年（85）

2011年（45）

2010年（231）

2009年（287）

我的朋友
最近访客
推荐博文
相关博文
linux _ 技巧

分类： Android平台

2015-12-09 14:43:26

linux平台整理的Makefile平台.


点击(此处)折叠或打开

  1. #!/bin/sh

  3. #
  4. # 为 xxxx 定做文件系统.
  5. #

  7. export XROOT=/home/w55fa92bsp-2.6.35/custom_rootfs/usr_data
  8. export PREFIX=${XROOT}
  9. export LD_LIBRARY_PATH=${PREFIX}/lib
  10. export PKG_CONFIG_PATH=${LD_LIBRARY_PATH}/pkgconfig

  12. export HOST=arm-linux
  13. export BUILD=i686-linux
  14. export TARGET=arm-unknown-linux-gnu

  16. export CROSS_COMPILE=/usr/local/arm/2010q1/bin/arm-none-linux-gnueabi-
  17. export CROSS_EXTOPT="-march=armv5te -mtune=arm9tdmi -msoft-float -mlittle-endian"

  19. export CC=${CROSS_COMPILE}gcc
  20. export CXX=${CROSS_COMPILE}g++
  21. export AR=${CROSS_COMPILE}ar
  22. export RANLIB=${CROSS_COMPILE}ranlib
  23. export NM=${CROSS_COMPILE}nm
  24. export AS=${CROSS_COMPILE}as
  25. export LD=${CROSS_COMPILE}ld

  27. export STRIP=${CROSS_COMPILE}strip
  28. export READELF=${CROSS_COMPILE}readelf
  29. export STRINGS=${CROSS_COMPILE}strings
  30. export SIZE=${CROSS_COMPILE}size
  31. export ADDR2LINE=${CROSS_COMPILE}addr2line

  33. export CFLAGS="-I${XROOT}/include ${CROSS_EXTOPT}"
  34. export CPPFLAGS=${CFLAGS}
  35. export CXXFLAGS=${CFLAGS}
  36. export LDFLAGS="-L${XROOT}/lib"
编译库


点击(此处)折叠或打开

  1. VERSION := 1
  2. PATCHLEVEL := 0
  3. SUBLEVEL := 0

  5. AIM_FILE := NDPeri
  6. SHAREDLIB = lib$(AIM_FILE).so
  7. SHAREDLIBV = lib$(AIM_FILE).so.$(VERSION).$(PATCHLEVEL).$(SUBLEVEL)
  8. SHAREDLIBM = lib$(AIM_FILE).so.$(VERSION)
  9. TARGET := $(SHAREDLIB)

  11. SrcDir= .
  12. ExtList= .c .cpp

  14. Source= $(foreach ext,$(ExtList), \
  15.     $(foreach sd, $(SrcDir), $(wildcard $(addprefix $(sd)/*,$(ext)))))

  17. Objs= $(foreach ext, $(ExtList), \
  18.     $(patsubst %$(ext), %.o, $(filter %$(ext),$(Source))))

  20. CFLAGS += -g -Wall
  21. CFLAGS += ${CROSS_EXTOPT}
  22. LDFlags +=
  23. INCFLAGS := -I .

  25. #do yourself

编译可执行程序

点击(此处)折叠或打开

  1. Target=demo_keypad

  3. SrcDir= .
  4. ExtList= .c .cpp

  6. Source= $(foreach ext,$(ExtList), \
  7.     $(foreach sd, $(SrcDir), $(wildcard $(addprefix $(sd)/*,$(ext)))))

  9. Objs= $(foreach ext, $(ExtList), \
  10.     $(patsubst %$(ext), %.o, $(filter %$(ext),$(Source))))

  12. CFLAGS += -g -Wall
  13. CFLAGS += ${CROSS_EXTOPT}
  14. LDFlags += -lNDPeri
  15. INCFLAGS := -I . -I ${XROOT}/include/nd_ext/

  17. %.o : %.c
  18.     $(CC) $(CFLAGS) -c $(@D)/$(<F) -o $(@D)/$(@F) $(INCFLAGS)
  19. %.o : %.cpp
  20.     $(CPP) $(CFLAGS) -c $(@D)/$(<F) -o $(@D)/$(@F) $(INCFLAGS)

  22. .PHONY : all objs clean cleanall rebuild install

  24. $(Target): $(Objs)
  25.     $(CC) $(CFLAGS) -o $(Target) $(Objs) $(LDFlags)

  27. install:$(Target)
  28.     cp -v $(Target) ${XROOT}/bin

  30. release:$(Target)
  31.     $(STRIP) $(Target)
  32.     @$(MAKE) install

  34. all: $(Target)

  36. objs: $(Objs)

  38. RM= rm -rf

  40. clean:
  41.     @$(RM) $(foreach sd, $(SrcDir), $(wildcard $(sd)/*.o))
  42.     @$(RM) $(Target) ${XROOT}/bin/$(Target)

  44. cleanall:clean

  46. rebuild: cleanall


C / C++中正确使用PRId64

nt64_t用来表示64位整数，在32位系统中是long
long int，在64位系统中是long int，所以打印int64_t的格式化方法是：

点击(此处)折叠或打开

  1. printf("%ld", value); // 64bit OS
  2. printf("%lld", value); // 32bit OS
当然有跨平台的方法：

点击(此处)折叠或打开

  1. #include <inttypes.h>
  2. printf("%" PRId64 "\n", value);
  3. // 相当于64位的：
  4. printf("%" "ld" "\n", value);
  5. // 或32位的：
  6. printf("%" "lld" "\n", value)
但 PRId64/32/16/8 是定义给C语音用的, 如果C++要用,  要在g++ 加入 -D__STDC_FORMAT_MACROS 开关.


V4L_DEMO : v4l version 1

点击(此处)折叠或打开

  1.     int i32VidFD;
  2.     ERRCODE err = ERR_V4L_SUCCESS;
  3.     struct video_capability sVidCap;
  4.     struct video_picture sPict;
  5.     int i32Width, i32Height;
  6.     i32VidFD = open(VID_DEVICE, O_RDWR);
  7.     ioctl(i32VidFD, VIDIOCGCAP, &sVidCap) ;
  8.     if (!(sVidCap.type & VID_TYPE_CAPTURE)) {
  9.         DEBUG_PRINT("Fatal: grab device does not handle capture\n");
  10.         err = ERR_V4L_VID_GRAB_DEV;
  11.         goto fail;
  12.     }
  13.     i32Width = 320;  i32Height = 240;
  14.     ioctl(i32VidFD, VIDIOCGPICT, &sPict);
  15.     sPict.palette = VIDEO_PALETTE_YUV422;
  16.     sPict.depth= 16;
  17.     if(ioctl(i32VidFD, VIDIOCSPICT, &sPict) < 0) {
  18.         DEBUG_PRINT("VIDIOCSPICT: %s\n", strerror(errno));
  19.         err = ERR_V4L_VID_SET_PICT;
  20.         goto fail;
  21.     }
  22.     if (ioctl(i32VidFD, VIDIOCGMBUF, &s_sVidData.sVidMBufs) < 0) {
  23.         /* try to use read based access */
  24.         int val;
  25.         s_sVidData.sVidWin.width = i32Width;
  26.         s_sVidData.sVidWin.height = i32Height;
  27.         s_sVidData.sVidWin.x = 0;
  28.         s_sVidData.sVidWin.y = 0;
  29.         s_sVidData.sVidWin.chromakey = -1;
  30.         s_sVidData.sVidWin.flags = 0;
  31.         if (ioctl(i32VidFD, VIDIOCSWIN, &s_sVidData.sVidWin) < 0) {
  32.             DEBUG_PRINT("VIDIOCSWIN: %s\n", strerror(errno));
  33.             err = ERR_V4L_VID_SET_WIN;
  34.             goto fail;
  35.         }
  36.         s_sVidData.i32FrameFmt = VIDEO_PALETTE_YUV420P;
  37.         val = 1;
  38.         if (ioctl(i32VidFD, VIDIOCCAPTURE, &val) < 0) {
  39.             DEBUG_PRINT("VIDIOCCAPTURE: %s\n", strerror(errno));
  40.             err = ERR_AVDEV_VID_CAPTURE;
  41.             goto fail;
  42.         }
  43.         s_sVidData.i32UseMMap = 0;
  44.     }
  45.     else {
  46.         s_sVidData.pu8VidBuf = mmap(0, s_sVidData.sVidMBufs.size, PROT_READ|PROT_WRITE, MAP_SHARED, i32VidFD, 0);
  47.         if ((unsigned char*)-1 == s_sVidData.pu8VidBuf) {
  48.             s_sVidData.pu8VidBuf = mmap(0, s_sVidData.sVidMBufs.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, i32VidFD, 0);
  49.             if ((unsigned char*)-1 == s_sVidData.pu8VidBuf) {
  50.                 DEBUG_PRINT("mmap: %s\n", strerror(errno));
  51.                 err = ERR_V4L_MMAP;
  52.                 goto fail;
  53.             }
  54.         }
  55.         s_sVidData.i32VidFrame = 0;
  56.         /* start to grab the first frame */
  57.         s_sVidData.sVidMMap.frame = s_sVidData.i32VidFrame % s_sVidData.sVidMBufs.frames;
  58.         s_sVidData.sVidMMap.height = i32Height;
  59.         s_sVidData.sVidMMap.width = i32Width;
  60.         s_sVidData.sVidMMap.format = VIDEO_PALETTE_YUV420P;
  61.         if (ioctl(i32VidFD, VIDIOCMCAPTURE, &s_sVidData.sVidMMap) < 0) {
  62.             if (errno != EAGAIN) {
  63.                 DEBUG_PRINT("VIDIOCMCAPTURE: %s\n", strerror(errno));
  64.             }
  65.             else {
  66.                 DEBUG_PRINT("Fatal: grab device does not receive any video signal\n");
  67.             }
  68.             err = ERR_V4L_VID_MCAPTURE;
  69.             goto fail;
  70.         }
  71.         ioctl(i32VidFD,VIDIOC_G_DIFF_OFFSET, &s_sVidData.i32DiffOffset);
  72.         ioctl(i32VidFD,VIDIOC_G_DIFF_SIZE, &s_sVidData.i32DiffSize);
  73.         s_sVidData.pu8MDDiffBuf = s_sVidData.pu8VidBuf + s_sVidData.i32DiffOffset;   
  74.         s_sVidData.i32FrameFmt = s_sVidData.sVidMMap.format;
  75.         s_sVidData.i32UseMMap = 1;
  76.     }
  77.     s_sVidData.i32FrameSize = s_sVidData.sVidMMap.width * s_sVidData.sVidMMap.height* 2;
  78.     s_sVidData.i32VidFD = i32VidFD;
  79.     return err;


V4L2_Demo

点击(此处)折叠或打开

  1. /*
  2.  * V4L2 video capture example
  3.  *
  4.  * This program can be used and distributed without restrictions.
  5.  */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <assert.h>
  10. #include <getopt.h> /* getopt_long() */
  11. #include <fcntl.h> /* low-level i/o */
  12. #include <unistd.h>
  13. #include <errno.h>
  14. #include <malloc.h>
  15. #include <sys/stat.h>
  16. #include <sys/types.h>
  17. #include <sys/time.h>
  18. #include <sys/mman.h>
  19. #include <sys/ioctl.h>
  20. #include <asm/types.h> /* for videodev2.h */
  21. #include <linux/videodev2.h>
  22. #define CLEAR(x) memset (&(x), 0, sizeof (x))
  23. typedef enum {
  24.     IO_METHOD_READ,
  25.     IO_METHOD_MMAP,    
  26.     IO_METHOD_USERPTR,
  27. } io_method;
  28. struct buffer {
  29.         void * start;
  30.         size_t length;
  31. };
  32. static char * dev_name = NULL;
  33. static io_method    io        = IO_METHOD_MMAP;
  34. static int fd = -1;
  35. struct buffer * buffers = NULL;
  36. static unsigned int n_buffers = 0;
  37. static void
  38. errno_exit (const char * s)
  39. {
  40.         fprintf (stderr, "%s error %d, %s\n",
  41.                  s, errno, strerror (errno));
  42.         exit (EXIT_FAILURE);
  43. }
  44. static int
  45. xioctl (int fd,  int request, void * arg)
  46. {
  47. int r;
    do r = ioctl (fd, request, arg);
    while (-1 == r && EINTR == errno);
  48.         return r;
  49. }
  50. static void process_image (const void * p)
  51. {
  52.         fputc ('.', stdout);
  53.         fflush (stdout);
  54. }

  56. static int
  57. read_frame            (void)
  58. {
  59.         struct v4l2_buffer buf;
  60.     unsigned int i;

  62.     switch (io) {
  63.     case IO_METHOD_READ:
  64.             if (-1 == read (fd, buffers[0].start, buffers[0].length)) {
  65.                     switch (errno) {
  66.                     case EAGAIN:
  67.                             return 0;

  69.             case EIO:
  70.                 /* Could ignore EIO, see spec. */

  72.                 /* fall through */

  74.             default:
  75.                 errno_exit ("read");
  76.             }
  77.         }

  79.             process_image (buffers[0].start);

  81.         break;

  83.     case IO_METHOD_MMAP:
  84.         CLEAR (buf);

  86.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  87.                 buf.memory = V4L2_MEMORY_MMAP;

  89.             if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
  90.                     switch (errno) {
  91.                     case EAGAIN:
  92.                             return 0;

  94.             case EIO:
  95.                 /* Could ignore EIO, see spec. */

  97.                 /* fall through */

  99.             default:
  100.                 errno_exit ("VIDIOC_DQBUF");
  101.             }
  102.         }

  104.                 assert (buf.index < n_buffers);

  106.      process_image (buffers[buf.index].start);

  108.         if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  109.             errno_exit ("VIDIOC_QBUF");

  111.         break;

  113.     case IO_METHOD_USERPTR:
  114.         CLEAR (buf);

  116.             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  117.             buf.memory = V4L2_MEMORY_USERPTR;

  119.         if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
  120.             switch (errno) {
  121.             case EAGAIN:
  122.                 return 0;

  124.             case EIO:
  125.                 /* Could ignore EIO, see spec. */

  127.                 /* fall through */

  129.             default:
  130.                 errno_exit ("VIDIOC_DQBUF");
  131.             }
  132.         }

  134.         for (i = 0; i < n_buffers; ++i)
  135.             if (buf.m.userptr == (unsigned long) buffers[i].start
  136.              && buf.length == buffers[i].length)
  137.                 break;

  139.         assert (i < n_buffers);

  141.             process_image ((void *) buf.m.userptr);

  143.         if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  144.             errno_exit ("VIDIOC_QBUF");

  146.         break;
  147.     }

  149.     return 1;
  150. }

  152. static void
  153. mainloop (void)
  154. {
  155.     unsigned int count;

  157.         count = 100;

  159.         while (count-- > 0) {
  160.                 for (;;) {
  161.                         fd_set fds;
  162.                         struct timeval tv;
  163.                         int r;

  165.                         FD_ZERO (&fds);
  166.                         FD_SET (fd, &fds);

  168.                         /* Timeout. */
  169.                         tv.tv_sec = 2;
  170.                         tv.tv_usec = 0;

  172.                         r = select (fd + 1, &fds, NULL, NULL, &tv);

  174.                         if (-1 == r) {
  175.                                 if (EINTR == errno)
  176.                                         continue;

  178.                                 errno_exit ("select");
  179.                         }

  181.                         if (0 == r) {
  182.                                 fprintf (stderr, "select timeout\n");
  183.                                 exit (EXIT_FAILURE);
  184.                         }

  186.             if (read_frame ())
  187.                             break;
  188.     
  189.             /* EAGAIN - continue select loop. */
  190.                 }
  191.         }
  192. }

  194. static void
  195. stop_capturing (void)
  196. {
  197.         enum v4l2_buf_type type;

  199.     switch (io) {
  200.     case IO_METHOD_READ:
  201.         /* Nothing to do. */
  202.         break;

  204.     case IO_METHOD_MMAP:
  205.     case IO_METHOD_USERPTR:
  206.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  208.         if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
  209.             errno_exit ("VIDIOC_STREAMOFF");

  211.         break;
  212.     }
  213. }

  215. static void
  216. start_capturing (void)
  217. {
  218.         unsigned int i;
  219.         enum v4l2_buf_type type;

  221.     switch (io) {
  222.     case IO_METHOD_READ:
  223.         /* Nothing to do. */
  224.         break;

  226.     case IO_METHOD_MMAP:
  227.         for (i = 0; i < n_buffers; ++i) {
  228.                     struct v4l2_buffer buf;

  230.                 CLEAR (buf);

  232.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  233.                 buf.memory = V4L2_MEMORY_MMAP;
  234.                 buf.index = i;

  236.                 if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  237.                             errno_exit ("VIDIOC_QBUF");
  238.         }
  239.         
  240.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  242.         if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
  243.             errno_exit ("VIDIOC_STREAMON");

  245.         break;

  247.     case IO_METHOD_USERPTR:
  248.         for (i = 0; i < n_buffers; ++i) {
  249.                     struct v4l2_buffer buf;

  251.                 CLEAR (buf);

  253.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  254.                 buf.memory = V4L2_MEMORY_USERPTR;
  255.             buf.index = i;
  256.             buf.m.userptr    = (unsigned long) buffers[i].start;
  257.             buf.length = buffers[i].length;

  259.             if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  260.                             errno_exit ("VIDIOC_QBUF");
  261.         }

  263.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  265.         if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
  266.             errno_exit ("VIDIOC_STREAMON");

  268.         break;
  269.     }
  270. }

  272. static void
  273. uninit_device (void)
  274. {
  275.         unsigned int i;

  277.     switch (io) {
  278.     case IO_METHOD_READ:
  279.         free (buffers[0].start);
  280.         break;

  282.     case IO_METHOD_MMAP:
  283.         for (i = 0; i < n_buffers; ++i)
  284.             if (-1 == munmap (buffers[i].start, buffers[i].length))
  285.                 errno_exit ("munmap");
  286.         break;

  288.     case IO_METHOD_USERPTR:
  289.         for (i = 0; i < n_buffers; ++i)
  290.             free (buffers[i].start);
  291.         break;
  292.     }

  294.     free (buffers);
  295. }

  297. static void
  298. init_read            (unsigned int        buffer_size)
  299. {
  300.         buffers = calloc (1, sizeof (*buffers));

  302.         if (!buffers) {
  303.                 fprintf (stderr, "Out of memory\n");
  304.                 exit (EXIT_FAILURE);
  305.         }

  307.     buffers[0].length = buffer_size;
  308.     buffers[0].start = malloc (buffer_size);

  310.     if (!buffers[0].start) {
  311.             fprintf (stderr, "Out of memory\n");
  312.                 exit (EXIT_FAILURE);
  313.     }
  314. }

  316. static void
  317. init_mmap            (void)
  318. {
  319.     struct v4l2_requestbuffers req;

  321.         CLEAR (req);

  323.         req.count = 4;
  324.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  325.         req.memory = V4L2_MEMORY_MMAP;

  327.     if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  328.                 if (EINVAL == errno) {
  329.                         fprintf (stderr, "%s does not support "
  330.                                  "memory mapping\n", dev_name);
  331.                         exit (EXIT_FAILURE);
  332.                 } else {
  333.                         errno_exit ("VIDIOC_REQBUFS");
  334.                 }
  335.         }

  337.         if (req.count < 2) {
  338.                 fprintf (stderr, "Insufficient buffer memory on %s\n",
  339.                          dev_name);
  340.                 exit (EXIT_FAILURE);
  341.         }

  343.         buffers = calloc (req.count, sizeof (*buffers));

  345.         if (!buffers) {
  346.                 fprintf (stderr, "Out of memory\n");
  347.                 exit (EXIT_FAILURE);
  348.         }

  350.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
  351.                 struct v4l2_buffer buf;

  353.                 CLEAR (buf);

  355.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  356.                 buf.memory = V4L2_MEMORY_MMAP;
  357.                 buf.index = n_buffers;

  359.                 if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
  360.                         errno_exit ("VIDIOC_QUERYBUF");

  362.                 buffers[n_buffers].length = buf.length;
  363.                 buffers[n_buffers].start =
  364.                         mmap (NULL /* start anywhere */,
  365.                               buf.length,
  366.                               PROT_READ | PROT_WRITE /* required */,
  367.                               MAP_SHARED /* recommended */,
  368.                               fd, buf.m.offset);

  370.                 if (MAP_FAILED == buffers[n_buffers].start)
  371.                         errno_exit ("mmap");
  372.         }
  373. }

  375. static void
  376. init_userp            (unsigned int        buffer_size)
  377. {
  378.     struct v4l2_requestbuffers req;
  379.         unsigned int page_size;

  381.         page_size = getpagesize ();
  382.         buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);

  384.         CLEAR (req);

  386.         req.count = 4;
  387.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  388.         req.memory = V4L2_MEMORY_USERPTR;

  390.         if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  391.                 if (EINVAL == errno) {
  392.                         fprintf (stderr, "%s does not support "
  393.                                  "user pointer i/o\n", dev_name);
  394.                         exit (EXIT_FAILURE);
  395.                 } else {
  396.                         errno_exit ("VIDIOC_REQBUFS");
  397.                 }
  398.         }

  400.         buffers = calloc (4, sizeof (*buffers));

  402.         if (!buffers) {
  403.                 fprintf (stderr, "Out of memory\n");
  404.                 exit (EXIT_FAILURE);
  405.         }

  407.         for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
  408.                 buffers[n_buffers].length = buffer_size;
  409.                 buffers[n_buffers].start = memalign (/* boundary */ page_size,
  410.                                                      buffer_size);

  412.                 if (!buffers[n_buffers].start) {
  413.                 fprintf (stderr, "Out of memory\n");
  414.                     exit (EXIT_FAILURE);
  415.         }
  416.         }
  417. }

  419. static void
  420. init_device (void)
  421. {
  422.         struct v4l2_capability cap;
  423.         struct v4l2_cropcap cropcap;
  424.         struct v4l2_crop crop;
  425.         struct v4l2_format fmt;
  426.     unsigned int min;

  428.         if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
  429.                 if (EINVAL == errno) {
  430.                         fprintf (stderr, "%s is no V4L2 device\n",
  431.                                  dev_name);
  432.                         exit (EXIT_FAILURE);
  433.                 } else {
  434.                         errno_exit ("VIDIOC_QUERYCAP");
  435.                 }
  436.         }

  438.         if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
  439.                 fprintf (stderr, "%s is no video capture device\n",
  440.                          dev_name);
  441.                 exit (EXIT_FAILURE);
  442.         }

  444.     switch (io) {
  445.     case IO_METHOD_READ:
  446.         if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
  447.             fprintf (stderr, "%s does not support read i/o\n",
  448.                  dev_name);
  449.             exit (EXIT_FAILURE);
  450.         }

  452.         break;

  454.     case IO_METHOD_MMAP:
  455.     case IO_METHOD_USERPTR:
  456.         if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
  457.             fprintf (stderr, "%s does not support streaming i/o\n",
  458.                  dev_name);
  459.             exit (EXIT_FAILURE);
  460.         }

  462.         break;
  463.     }


  466.         /* Select video input, video standard and tune here. */


  469.     CLEAR (cropcap);

  471.         cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  473.         if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
  474.                 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  475.                 crop.c = cropcap.defrect; /* reset to default */

  477.                 if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
  478.                         switch (errno) {
  479.                         case EINVAL:
  480.                                 /* Cropping not supported. */
  481.                                 break;
  482.                         default:
  483.                                 /* Errors ignored. */
  484.                                 break;
  485.                         }
  486.                 }
  487.         } else {    
  488.                 /* Errors ignored. */
  489.         }


  492.         CLEAR (fmt);

  494.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  495.         fmt.fmt.pix.width = 640;
  496.         fmt.fmt.pix.height = 480;
  497.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  498.         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

  500.         if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
  501.                 errno_exit ("VIDIOC_S_FMT");

  503.         /* Note VIDIOC_S_FMT may change width and height. */

  505.     /* Buggy driver paranoia. */
  506.     min = fmt.fmt.pix.width * 2;
  507.     if (fmt.fmt.pix.bytesperline < min)
  508.         fmt.fmt.pix.bytesperline = min;
  509.     min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  510.     if (fmt.fmt.pix.sizeimage < min)
  511.         fmt.fmt.pix.sizeimage = min;

  513.     switch (io) {
  514.     case IO_METHOD_READ:
  515.         init_read (fmt.fmt.pix.sizeimage);
  516.         break;

  518.     case IO_METHOD_MMAP:
  519.         init_mmap ();
  520.         break;

  522.     case IO_METHOD_USERPTR:
  523.         init_userp (fmt.fmt.pix.sizeimage);
  524.         break;
  525.     }
  526. }

  528. static void
  529. close_device (void)
  530. {
  531.         if (-1 == close (fd))
  532.      errno_exit ("close");

  534.         fd = -1;
  535. }

  537. static void
  538. open_device (void)
  539. {
  540.         struct stat st;

  542.         if (-1 == stat (dev_name, &st)) {
  543.                 fprintf (stderr, "Cannot identify '%s': %d, %s\n",
  544.                          dev_name, errno, strerror (errno));
  545.                 exit (EXIT_FAILURE);
  546.         }

  548.         if (!S_ISCHR (st.st_mode)) {
  549.                 fprintf (stderr, "%s is no device\n", dev_name);
  550.                 exit (EXIT_FAILURE);
  551.         }

  553.         fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);

  555.         if (-1 == fd) {
  556.                 fprintf (stderr, "Cannot open '%s': %d, %s\n",
  557.                          dev_name, errno, strerror (errno));
  558.                 exit (EXIT_FAILURE);
  559.         }
  560. }

  562. static void
  563. usage (FILE * fp,
  564.                                  int argc,
  565.                                  char ** argv)
  566. {
  567.         fprintf (fp,
  568.                  "Usage: %s [options]\n\n"
  569.                  "Options:\n"
  570.                  "-d | --device name Video device name [/dev/video]\n"
  571.                  "-h | --help Print this message\n"
  572.                  "-m | --mmap Use memory mapped buffers\n"
  573.                  "-r | --read Use read() calls\n"
  574.                  "-u | --userp Use application allocated buffers\n"
  575.                  "",
  576.          argv[0]);
  577. }

  579. static const char short_options [] = "d:hmru";

  581. static const struct option
  582. long_options [] = {
  583.         { "device", required_argument, NULL, 'd' },
  584.         { "help", no_argument, NULL, 'h' },
  585.         { "mmap", no_argument, NULL, 'm' },
  586.         { "read", no_argument, NULL, 'r' },
  587.         { "userp", no_argument, NULL, 'u' },
  588.         { 0, 0, 0, 0 }
  589. };

  591. int
  592. main (int argc,
  593.                                  char ** argv)
  594. {
  595.         //dev_name = "/dev/video";
  596.         dev_name = "/dev/video0";
  597.         for (;;) {
  598.                 int index;
  599.                 int c;
  600.                 
  601.                 c = getopt_long (argc, argv,
  602.                                  short_options, long_options,
  603.                                  &index);

  605.                 if (-1 == c)
  606.                         break;

  608.                 switch (c) {
  609.                 case 0: /* getopt_long() flag */
  610.                         break;

  612.                 case 'd':
  613.                         dev_name = optarg;
  614.                         break;

  616.                 case 'h':
  617.                         usage (stdout, argc, argv);
  618.                         exit (EXIT_SUCCESS);

  620.                 case 'm':
  621.                         io = IO_METHOD_MMAP;
  622.             break;

  624.                 case 'r':
  625.                         io = IO_METHOD_READ;
  626.             break;

  628.                 case 'u':
  629.                         io = IO_METHOD_USERPTR;
  630.             break;

  632.                 default:
  633.                         usage (stderr, argc, argv);
  634.                         exit (EXIT_FAILURE);
  635.                 }
  636.         }

  638.         open_device ();

  640.         init_device ();

  642.         start_capturing ();

  644.         mainloop ();

  646.         stop_capturing ();

  648.         uninit_device ();

  650.         close_device ();

  652.         exit (EXIT_SUCCESS);

  654.         return 0;
  655. }



把frame buffer 映射到用户控件, 然后可以操作fb的用户控件的达到控制像素点的功能.

点击(此处)折叠或打开

  1. int InitFBDevice(
  2.     uint8_t **ppu8FBBuf,
  3.     uint32_t *pu32FBBufSize
  4. )
  5. {
  6.     int32_t i32FBFd;
  7.     uint8_t *pu8FBBuf;
  8.     char achFBDevice[] = "/dev/fb0";
  9.     static struct fb_var_screeninfo sVar;
  10.     *ppu8FBBuf = MAP_FAILED;
  11.     *pu32FBBufSize = 0;
  12.     i32FBFd = open(achFBDevice, O_RDWR);   printf("fb open successful\n");
  13.     ioctl(i32FBFd, FBIOGET_VSCREENINFO, &sVar) ;
  14.     s_i32FBWidth = sVar.xres;
  15.     s_i32FBHeight = sVar.yres;
  16.     pu8FBBuf = mmap( NULL, s_i32FBWidth*s_i32FBHeight*2 , PROT_READ|PROT_WRITE, MAP_SHARED, i32FBFd, 0 );
  17.     if ((unsigned char*)-1 == pu8FBBuf) {
  18.             close(i32FBFd);
  19.             return -1;
  20.     }
  21.     *pu32FBBufSize = s_i32FBWidth*s_i32FBHeight*2;
  22.     ioctl(i32FBFd, IOCTL_LCD_DISABLE_INT, 0);
  23.     ioctl(i32FBFd, VIDEO_FORMAT_CHANGE, DISPLAY_MODE_YCBYCR);
  24.     ioctl(i32FBFd, IOCTL_LCD_ENABLE_INT, 0);
  25.     *ppu8FBBuf = pu8FBBuf;
  26.     return i32FBFd;
  27. }




从各个设备节点点取出其名字. 对应判断是哪个设备. 如果从/dev/eventX中取出名字, 判断是键盘/鼠标/触屏等等.

点击(此处)折叠或打开

  1. char achDevName[256]; 
  2.     char achKeypad[] = "Keypad";  //想要找的设备名称, 对应 driver 里边的name.
  3.     char achKpdDevice[] = "/dev/input/event0";
  4.     int32_t i32KpdFd= -1;
  5.     uint32_t u32Result;
  6.     int32_t i;    
  7.     u32Result = 0;
  8.     for (i = 0; i < RETRY_NUM; i++) {
  9.         DEBUG_PRINT("trying to open %s ...\n", achKpdDevice);
  10.         if ((i32KpdFd=open(achKpdDevice, O_RDONLY | O_NONBLOCK)) < 0) {
  11.             break;
  12.         }
  13.         memset(achDevName, 0x0, sizeof(achDevName));
  14.         if (ioctl(i32KpdFd, EVIOCGNAME(sizeof(achDevName)), achDevName) < 0) {  //取出设备名.  等同于操作 /sys/class/input/input0/name
  15.             DEBUG_PRINT("%s evdev ioctl error!\n", achKpdDevice);
  16.         }
  17.         else{
  18.             if (strstr(achDevName, achKeypad) != NULL) { //比较名字.
  19.                 DEBUG_PRINT("Keypad device is %s\n", achKpdDevice);
  20.                 u32Result = 1;
  21.                 break;
  22.             }
  23.         }
  24.         close(i32KpdFd);
  25.         achKpdDevice[16]++;
  26.     }
  27.     if (u32Result == 0) {
  28.         DEBUG_PRINT("can not find any Keypad device!\n");
  29.         return -1;
  30.     }
  31.     return i32KpdFd;

阅读(3334) | 评论(0) | 转发(0) |
0

上一篇：linux kernel 常见错误整理

下一篇：Android NDK开发指南

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6