linux _ 技巧

linux平台整理的Makefile平台.

点击(此处)折叠或打开

1. #!/bin/sh
   
2. 
   
3. #
   
4. # 为 xxxx 定做文件系统.
   
5. #
   
6. 
   
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
    
11. 
    
12. export HOST=arm-linux
    
13. export BUILD=i686-linux
    
14. export TARGET=arm-unknown-linux-gnu
    
15. 
    
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"
    
18. 
    
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
    
26. 
    
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
    
32. 
    
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
   
4. 
   
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)
   
10. 
    
11. SrcDir= .
    
12. ExtList= .c .cpp
    
13. 
    
14. Source= $(foreach ext,$(ExtList), \
    
15.     $(foreach sd, $(SrcDir), $(wildcard $(addprefix $(sd)/*,$(ext)))))
    
16. 
    
17. Objs= $(foreach ext, $(ExtList), \
    
18.     $(patsubst %$(ext), %.o, $(filter %$(ext),$(Source))))
    
19. 
    
20. CFLAGS += -g -Wall
    
21. CFLAGS += ${CROSS_EXTOPT}
    
22. LDFlags +=
    
23. INCFLAGS := -I .
    
24. 
    
25. #do yourself

编译可执行程序

点击(此处)折叠或打开

1. Target=demo_keypad
   
2. 
   
3. SrcDir= .
   
4. ExtList= .c .cpp
   
5. 
   
6. Source= $(foreach ext,$(ExtList), \
   
7.     $(foreach sd, $(SrcDir), $(wildcard $(addprefix $(sd)/*,$(ext)))))
   
8. 
   
9. Objs= $(foreach ext, $(ExtList), \
   
10.     $(patsubst %$(ext), %.o, $(filter %$(ext),$(Source))))
    
11. 
    
12. CFLAGS += -g -Wall
    
13. CFLAGS += ${CROSS_EXTOPT}
    
14. LDFlags += -lNDPeri
    
15. INCFLAGS := -I . -I ${XROOT}/include/nd_ext/
    
16. 
    
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)
    
21. 
    
22. .PHONY : all objs clean cleanall rebuild install
    
23. 
    
24. $(Target): $(Objs)
    
25.     $(CC) $(CFLAGS) -o $(Target) $(Objs) $(LDFlags)
    
26. 
    
27. install:$(Target)
    
28.     cp -v $(Target) ${XROOT}/bin
    
29. 
    
30. release:$(Target)
    
31.     $(STRIP) $(Target)
    
32.     @$(MAKE) install
    
33. 
    
34. all: $(Target)
    
35. 
    
36. objs: $(Objs)
    
37. 
    
38. RM= rm -rf
    
39. 
    
40. clean:
    
41.     @$(RM) $(foreach sd, $(SrcDir), $(wildcard $(sd)/*.o))
    
42.     @$(RM) $(Target) ${XROOT}/bin/$(Target)
    
43. 
    
44. cleanall:clean
    
45. 
    
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. }
    
55. 
    
56. static int
    
57. read_frame            (void)
    
58. {
    
59.         struct v4l2_buffer buf;
    
60.     unsigned int i;
    
61. 
    
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;
    
68. 
    
69.             case EIO:
    
70.                 /* Could ignore EIO, see spec. */
    
71. 
    
72.                 /* fall through */
    
73. 
    
74.             default:
    
75.                 errno_exit ("read");
    
76.             }
    
77.         }
    
78. 
    
79.             process_image (buffers[0].start);
    
80. 
    
81.         break;
    
82. 
    
83.     case IO_METHOD_MMAP:
    
84.         CLEAR (buf);
    
85. 
    
86.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
87.                 buf.memory = V4L2_MEMORY_MMAP;
    
88. 
    
89.             if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
    
90.                     switch (errno) {
    
91.                     case EAGAIN:
    
92.                             return 0;
    
93. 
    
94.             case EIO:
    
95.                 /* Could ignore EIO, see spec. */
    
96. 
    
97.                 /* fall through */
    
98. 
    
99.             default:
    
100.                 errno_exit ("VIDIOC_DQBUF");
     
101.             }
     
102.         }
     
103. 
     
104.                 assert (buf.index < n_buffers);
     
105. 
     
106.      process_image (buffers[buf.index].start);
     
107. 
     
108.         if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
     
109.             errno_exit ("VIDIOC_QBUF");
     
110. 
     
111.         break;
     
112. 
     
113.     case IO_METHOD_USERPTR:
     
114.         CLEAR (buf);
     
115. 
     
116.             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
117.             buf.memory = V4L2_MEMORY_USERPTR;
     
118. 
     
119.         if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
     
120.             switch (errno) {
     
121.             case EAGAIN:
     
122.                 return 0;
     
123. 
     
124.             case EIO:
     
125.                 /* Could ignore EIO, see spec. */
     
126. 
     
127.                 /* fall through */
     
128. 
     
129.             default:
     
130.                 errno_exit ("VIDIOC_DQBUF");
     
131.             }
     
132.         }
     
133. 
     
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;
     
138. 
     
139.         assert (i < n_buffers);
     
140. 
     
141.             process_image ((void *) buf.m.userptr);
     
142. 
     
143.         if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
     
144.             errno_exit ("VIDIOC_QBUF");
     
145. 
     
146.         break;
     
147.     }
     
148. 
     
149.     return 1;
     
150. }
     
151. 
     
152. static void
     
153. mainloop (void)
     
154. {
     
155.     unsigned int count;
     
156. 
     
157.         count = 100;
     
158. 
     
159.         while (count-- > 0) {
     
160.                 for (;;) {
     
161.                         fd_set fds;
     
162.                         struct timeval tv;
     
163.                         int r;
     
164. 
     
165.                         FD_ZERO (&fds);
     
166.                         FD_SET (fd, &fds);
     
167. 
     
168.                         /* Timeout. */
     
169.                         tv.tv_sec = 2;
     
170.                         tv.tv_usec = 0;
     
171. 
     
172.                         r = select (fd + 1, &fds, NULL, NULL, &tv);
     
173. 
     
174.                         if (-1 == r) {
     
175.                                 if (EINTR == errno)
     
176.                                         continue;
     
177. 
     
178.                                 errno_exit ("select");
     
179.                         }
     
180. 
     
181.                         if (0 == r) {
     
182.                                 fprintf (stderr, "select timeout\n");
     
183.                                 exit (EXIT_FAILURE);
     
184.                         }
     
185. 
     
186.             if (read_frame ())
     
187.                             break;
     
188.     
     
189.             /* EAGAIN - continue select loop. */
     
190.                 }
     
191.         }
     
192. }
     
193. 
     
194. static void
     
195. stop_capturing (void)
     
196. {
     
197.         enum v4l2_buf_type type;
     
198. 
     
199.     switch (io) {
     
200.     case IO_METHOD_READ:
     
201.         /* Nothing to do. */
     
202.         break;
     
203. 
     
204.     case IO_METHOD_MMAP:
     
205.     case IO_METHOD_USERPTR:
     
206.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
207. 
     
208.         if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
     
209.             errno_exit ("VIDIOC_STREAMOFF");
     
210. 
     
211.         break;
     
212.     }
     
213. }
     
214. 
     
215. static void
     
216. start_capturing (void)
     
217. {
     
218.         unsigned int i;
     
219.         enum v4l2_buf_type type;
     
220. 
     
221.     switch (io) {
     
222.     case IO_METHOD_READ:
     
223.         /* Nothing to do. */
     
224.         break;
     
225. 
     
226.     case IO_METHOD_MMAP:
     
227.         for (i = 0; i < n_buffers; ++i) {
     
228.                     struct v4l2_buffer buf;
     
229. 
     
230.                 CLEAR (buf);
     
231. 
     
232.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
233.                 buf.memory = V4L2_MEMORY_MMAP;
     
234.                 buf.index = i;
     
235. 
     
236.                 if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
     
237.                             errno_exit ("VIDIOC_QBUF");
     
238.         }
     
239.         
     
240.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
241. 
     
242.         if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
     
243.             errno_exit ("VIDIOC_STREAMON");
     
244. 
     
245.         break;
     
246. 
     
247.     case IO_METHOD_USERPTR:
     
248.         for (i = 0; i < n_buffers; ++i) {
     
249.                     struct v4l2_buffer buf;
     
250. 
     
251.                 CLEAR (buf);
     
252. 
     
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;
     
258. 
     
259.             if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
     
260.                             errno_exit ("VIDIOC_QBUF");
     
261.         }
     
262. 
     
263.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
264. 
     
265.         if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
     
266.             errno_exit ("VIDIOC_STREAMON");
     
267. 
     
268.         break;
     
269.     }
     
270. }
     
271. 
     
272. static void
     
273. uninit_device (void)
     
274. {
     
275.         unsigned int i;
     
276. 
     
277.     switch (io) {
     
278.     case IO_METHOD_READ:
     
279.         free (buffers[0].start);
     
280.         break;
     
281. 
     
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;
     
287. 
     
288.     case IO_METHOD_USERPTR:
     
289.         for (i = 0; i < n_buffers; ++i)
     
290.             free (buffers[i].start);
     
291.         break;
     
292.     }
     
293. 
     
294.     free (buffers);
     
295. }
     
296. 
     
297. static void
     
298. init_read            (unsigned int        buffer_size)
     
299. {
     
300.         buffers = calloc (1, sizeof (*buffers));
     
301. 
     
302.         if (!buffers) {
     
303.                 fprintf (stderr, "Out of memory\n");
     
304.                 exit (EXIT_FAILURE);
     
305.         }
     
306. 
     
307.     buffers[0].length = buffer_size;
     
308.     buffers[0].start = malloc (buffer_size);
     
309. 
     
310.     if (!buffers[0].start) {
     
311.             fprintf (stderr, "Out of memory\n");
     
312.                 exit (EXIT_FAILURE);
     
313.     }
     
314. }
     
315. 
     
316. static void
     
317. init_mmap            (void)
     
318. {
     
319.     struct v4l2_requestbuffers req;
     
320. 
     
321.         CLEAR (req);
     
322. 
     
323.         req.count = 4;
     
324.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
325.         req.memory = V4L2_MEMORY_MMAP;
     
326. 
     
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.         }
     
336. 
     
337.         if (req.count < 2) {
     
338.                 fprintf (stderr, "Insufficient buffer memory on %s\n",
     
339.                          dev_name);
     
340.                 exit (EXIT_FAILURE);
     
341.         }
     
342. 
     
343.         buffers = calloc (req.count, sizeof (*buffers));
     
344. 
     
345.         if (!buffers) {
     
346.                 fprintf (stderr, "Out of memory\n");
     
347.                 exit (EXIT_FAILURE);
     
348.         }
     
349. 
     
350.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
     
351.                 struct v4l2_buffer buf;
     
352. 
     
353.                 CLEAR (buf);
     
354. 
     
355.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
356.                 buf.memory = V4L2_MEMORY_MMAP;
     
357.                 buf.index = n_buffers;
     
358. 
     
359.                 if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
     
360.                         errno_exit ("VIDIOC_QUERYBUF");
     
361. 
     
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);
     
369. 
     
370.                 if (MAP_FAILED == buffers[n_buffers].start)
     
371.                         errno_exit ("mmap");
     
372.         }
     
373. }
     
374. 
     
375. static void
     
376. init_userp            (unsigned int        buffer_size)
     
377. {
     
378.     struct v4l2_requestbuffers req;
     
379.         unsigned int page_size;
     
380. 
     
381.         page_size = getpagesize ();
     
382.         buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);
     
383. 
     
384.         CLEAR (req);
     
385. 
     
386.         req.count = 4;
     
387.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
388.         req.memory = V4L2_MEMORY_USERPTR;
     
389. 
     
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.         }
     
399. 
     
400.         buffers = calloc (4, sizeof (*buffers));
     
401. 
     
402.         if (!buffers) {
     
403.                 fprintf (stderr, "Out of memory\n");
     
404.                 exit (EXIT_FAILURE);
     
405.         }
     
406. 
     
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);
     
411. 
     
412.                 if (!buffers[n_buffers].start) {
     
413.                 fprintf (stderr, "Out of memory\n");
     
414.                     exit (EXIT_FAILURE);
     
415.         }
     
416.         }
     
417. }
     
418. 
     
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;
     
427. 
     
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.         }
     
437. 
     
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.         }
     
443. 
     
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.         }
     
451. 
     
452.         break;
     
453. 
     
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.         }
     
461. 
     
462.         break;
     
463.     }
     
464. 
     
465. 
     
466.         /* Select video input, video standard and tune here. */
     
467. 
     
468. 
     
469.     CLEAR (cropcap);
     
470. 
     
471.         cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
472. 
     
473.         if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
     
474.                 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
475.                 crop.c = cropcap.defrect; /* reset to default */
     
476. 
     
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.         }
     
490. 
     
491. 
     
492.         CLEAR (fmt);
     
493. 
     
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;
     
499. 
     
500.         if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
     
501.                 errno_exit ("VIDIOC_S_FMT");
     
502. 
     
503.         /* Note VIDIOC_S_FMT may change width and height. */
     
504. 
     
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;
     
512. 
     
513.     switch (io) {
     
514.     case IO_METHOD_READ:
     
515.         init_read (fmt.fmt.pix.sizeimage);
     
516.         break;
     
517. 
     
518.     case IO_METHOD_MMAP:
     
519.         init_mmap ();
     
520.         break;
     
521. 
     
522.     case IO_METHOD_USERPTR:
     
523.         init_userp (fmt.fmt.pix.sizeimage);
     
524.         break;
     
525.     }
     
526. }
     
527. 
     
528. static void
     
529. close_device (void)
     
530. {
     
531.         if (-1 == close (fd))
     
532.      errno_exit ("close");
     
533. 
     
534.         fd = -1;
     
535. }
     
536. 
     
537. static void
     
538. open_device (void)
     
539. {
     
540.         struct stat st;
     
541. 
     
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.         }
     
547. 
     
548.         if (!S_ISCHR (st.st_mode)) {
     
549.                 fprintf (stderr, "%s is no device\n", dev_name);
     
550.                 exit (EXIT_FAILURE);
     
551.         }
     
552. 
     
553.         fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
     
554. 
     
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. }
     
561. 
     
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. }
     
578. 
     
579. static const char short_options [] = "d:hmru";
     
580. 
     
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. };
     
590. 
     
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);
     
604. 
     
605.                 if (-1 == c)
     
606.                         break;
     
607. 
     
608.                 switch (c) {
     
609.                 case 0: /* getopt_long() flag */
     
610.                         break;
     
611. 
     
612.                 case 'd':
     
613.                         dev_name = optarg;
     
614.                         break;
     
615. 
     
616.                 case 'h':
     
617.                         usage (stdout, argc, argv);
     
618.                         exit (EXIT_SUCCESS);
     
619. 
     
620.                 case 'm':
     
621.                         io = IO_METHOD_MMAP;
     
622.             break;
     
623. 
     
624.                 case 'r':
     
625.                         io = IO_METHOD_READ;
     
626.             break;
     
627. 
     
628.                 case 'u':
     
629.                         io = IO_METHOD_USERPTR;
     
630.             break;
     
631. 
     
632.                 default:
     
633.                         usage (stderr, argc, argv);
     
634.                         exit (EXIT_FAILURE);
     
635.                 }
     
636.         }
     
637. 
     
638.         open_device ();
     
639. 
     
640.         init_device ();
     
641. 
     
642.         start_capturing ();
     
643. 
     
644.         mainloop ();
     
645. 
     
646.         stop_capturing ();
     
647. 
     
648.         uninit_device ();
     
649. 
     
650.         close_device ();
     
651. 
     
652.         exit (EXIT_SUCCESS);
     
653. 
     
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;