Framebuffer 是用一個視頻輸出設備從包含完整的幀數據的一個內存緩沖區中來驅動一個視頻顯示設備,本文我們來看看嵌入式Linux基于framebuffer的jpeg格式在本地LCD屏顯示.

在基于Linux的視頻監控采集系統中,攝像頭采集到的一幀視頻圖像數據一般都是經過硬件自動壓縮成jpeg格式的,然后再保存到攝像頭設備的緩沖區.如果要把采集到的jpeg格式顯示在本地LCD屏上,由于我們的Linux系統沒有移植任何GUI系統,就要考慮以下方面:

1. 將jpeg格式解壓縮為位圖格式,也就是jpeg解碼.

2. 將解碼出來的位圖格式輸出到本地的LCD屏上. 在Linux系統下是通過寫入幀緩沖(framebuffer)來實現的.

3. framebuffer相當于為LCD設備提供一個統一的接口,對framebuffer的操控會反映到LCD顯示設備上去. 如果配置Linux內核時沒有找到支持本地lcd屏這種型號的驅動,那我們要自己寫lcd屏驅動,然后選擇靜態加入內核或以模塊的形式加入內核動態加載. 針對以上三點,我們逐一解決:

1.jpeg解碼

先了解一下jpeg標準的編碼過程:原始的一幀未壓縮過的圖像可以看成是RGB(紅綠藍)色彩空間上的一組向量集合,但在RGB空間是不利于數據壓縮的,因此為了壓縮先要把圖像映射到利于壓縮的YUV空間上(原因是因為人類的眼睛對于亮度差異的敏感度高于色彩變化,而YUV空間的一個基向量Y就是亮度), 這一步叫色彩空間轉換.

下一步可以在YUV空間上減少U(色調)和V(飽和度)的成分,也就是在亮度信息不減少的情況下移除部分色彩信息,誰叫人的眼睛對亮度的敏感優于對色彩的敏感呢.這一步叫縮減取樣.下一步是將圖像從色彩空間映射到頻率空間,可以采用的變換方法有:離散余弦變換,傅氏變換,正弦變換等. 其中應用最廣的是離散余弦變換(DCT).這一步是無損的,目的是為了在下一步稱之為量化的過程中可以經過四舍五入刪除高頻量得到壓縮后的矩陣.量化之后就是對這個矩陣的編碼問題了.針對這個矩陣的分布特點,采用"Z"字形的順序掃描編排,然后進行RLE行程編碼,把大量連續重復的數據壓縮.最后再用范式Huffman編碼.要了解詳細的過程,可以查看JPEG標準. 而解碼就是以上編碼的逆過程了.除非想要自己實現jpeg的編碼和解碼函數,我們可以不必細究這些過程,而是直接使用別人已經實現的jpeg編碼解碼庫.在Linux平臺下,有libjpeg庫,它是完全用C語言編寫的, 依照它的許可協議,可自由使用,不是GPL協議,它可以用于商業目的. libjpeg的6b版本有個問題,就是解碼接口,它只接受文件源.打開源的函數jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)要求解碼源infile是文件.而我們希望解碼的是直接來自映射內存中的數據.要解碼內存流的話就要修改libjpeg的源碼了,可以參考這里:http://my.unix-center.net/~Simon_fu/?p=565 目前libjpeg的最新版8c已經解決了這個接口不好的問題了,它增加了對內存流解碼的支持.通過調用函數

jpeg_mem_src(&cinfo, fdmem, st.st_size);

就可以將保存在內存的jpeg格式數據作為源輸入了.因此我們就用libjpeg 8c這個版本來解碼,用到的函數主要有:

初始化jpeg解壓對象:

1. /* init jpeg decompress object error handler */ 
2. cinfo.err = jpeg_std_error(&jerr); 
3. jpeg_create_decompress(&cinfo); 

綁定jpeg解壓對象到輸入流:

1. /* bind jpeg decompress object to infile */ 
2. READ_FILE    // 從jpeg文件讀入 
3. jpeg_stdio_src(&cinfo, infile); 
4. f READ_MEM    // 從內存讀入jpeg格式 
5. jpeg_mem_src(&cinfo, fdmem, st.st_size); 
6. if 

讀取jpeg頭部信息:

1. /* read jpeg header */ 
2. jpeg_read_header(&cinfo, TRUE); 

解壓過程:

1. /* decompress process */ 
2. jpeg_start_decompress(&cinfo); 

調用這個函數之后,可以得到jpeg圖像的下面幾個參數:

1. output_width // 圖像的寬度 
2. output_height // 圖像的高度 
3. output_components // 每個像素占用的字節數 

我們采用每掃描一行像素就輸出到屏幕的方法的話,根據以上參數可以確定分配一行信息需要的緩沖區:

1. buffer = (unsigned char *)malloc(cinfo.output_width * 
2.         cinfo.output_components); 

總共需要掃描output_height行,讀取一行掃描數據并輸出到LCD屏幕:

1. y = 0; 
2. while (cinfo.output_scanline < cinfo.output_height) { 
3.     jpeg_read_scanlines(&cinfo, &buffer, 1); 
4.     if (fb_depth == 16) {    // 如果顯示設備色深是16位 
5.         ... 
6.     } else if (fb_depth == 24) {    // 如果顯示設備色深是24位 
7.         ... 
8.     } else if (fb_depth == 32) {    // 如果顯示設備色深是32位 
9.         ... 
10.     } 
11.     y++; 
12. } 

結束jpeg解碼:

1. /* finish decompress, destroy decompress object */ 
2. jpeg_finish_decompress(&cinfo); 
3. jpeg_destroy_decompress(&cinfo); 

釋放緩沖區:

1. /* release memory buffer */ 
2. free(buffer); 

2.輸出位圖到LCD屏

通過framebuffer直接寫屏的主要步驟有:

打開framebuffer設備:

1. /* open framebuffer device */ 
2. fbdev = fb_open("/dev/fb0"); 

獲取framebuffer設備參數:

1. /* get status of framebuffer device */ 
2. fb_stat(fbdev, &fb_width, &fb_height, &fb_depth); 

映射framebuffer設備到共享內存:

1. screensize = fb_width * fb_height * fb_depth / 8; 
2. fbmem = fb_mmap(fbdev, screensize); 

直接對映射到那片內存進行寫操作,LCD屏刷新刷新時就會反應到屏幕上去了.

1. y = 0; 
2.        while (cinfo.output_scanline < cinfo.output_height) { 
3.            jpeg_read_scanlines(&cinfo, &buffer, 1); 
4.            if (fb_depth == 16) { 
5.                unsigned short color; 
6.  
7.                for (x = 0; x < cinfo.output_width; x++) { 
8.                    color = 
9.                        RGB888toRGB565(buffer[x * 3], 
10.                                buffer[x * 3 + 1], buffer[x * 3 + 2]); 
11.                    fb_pixel(fbmem, fb_width, fb_height, x, y, color); 
12.                } 
13.            } else if (fb_depth == 24) { 
14.                memcpy((unsigned char *) fbmem + y * fb_width * 3, 
15.                        buffer, cinfo.output_width * cinfo.output_components); 
16.            } else if (fb_depth == 32) { 
17.                // memcpy((unsigned char *) fbmem + y * fb_width * 4, 
18.                        // buffer, cinfo.output_width * cinfo.output_components); 
19.                for (x = 0; x < cinfo.output_width; x++) { 
20.                    *(fbmem + y * fb_width * 4 + x * 4)     = (unsigned char) buffer[x * 3 + 2]; 
21.                    *(fbmem + y * fb_width * 4 + x * 4 + 1) = (unsigned char) buffer[x * 3 + 1]; 
22.                    *(fbmem + y * fb_width * 4 + x * 4 + 2) = (unsigned char) buffer[x * 3 + 0]; 
23.                    *(fbmem + y * fb_width * 4 + x * 4 + 3) = (unsigned char) 0; 
24.                }  //Vevb.com 
25.            } 
26.            y++;    // next scanline 
27.        } 

卸載映射framebuffer的那部分內存:

1.     /* unmap framebuffer's shared memory */ 
2.     fb_munmap(fbmem, screensize); 
3.  
4. 關閉framebuffer設備: 
5.  
6.     close(fbdev); 

根據以上兩點,可以寫一個測試程序,在不開X-window圖形系統的情況下,將本地的jpeg文件直接顯示到屏幕上.

1. #include    <stdio.h> 
2. #include    <string.h> 
3. #include    <stdlib.h> 
4. #include    <unistd.h> 
5. #include    <sys/ioctl.h> 
6. #include    <sys/types.h> 
7. #include    <sys/stat.h> 
8. #include    <errno.h> 
9. #include    <fcntl.h> 
10. #include    <sys/mman.h> 
11. #include    <linux/fb.h> 
12. #include    "jpeglib.h" 
13. #include    "jerror.h" 
14.  
15. #define FB_DEV  "/dev/fb0" 
16. #define __fnc__ __FUNCTION__ 
17.  
18. #define debug           0 
19. #define debug_printf    0 
20. #define BYREAD          0 
21. #define BYMEM           1 
22.  
23. /* function deciaration */ 
24.  
25. void usage(char *msg); 
26. unsigned short RGB888toRGB565(unsigned char red, 
27.         unsigned char green, unsigned char blue); 
28. int fb_open(char *fb_device); 
29. int fb_close(int fd); 
30. int fb_stat(int fd, unsigned int *width, unsigned int *height, unsigned int *    depth); 
31. void *fb_mmap(int fd, unsigned int screensize); 
32. void *fd_mmap(int fd, unsigned int filesize); 
33. int fb_munmap(void *start, size_t length); 
34. int fb_pixel(void *fbmem, int width, int height, 
35.         int x, int y, unsigned short color); 
36.  
37. #if(debug) 
38. void draw(unsigned char *fbp, 
39.         struct fb_var_screeninfo vinfo, 
40.         struct fb_fix_screeninfo finfo); 
41. #endif 
42.  
43. /* function implementation */ 
44.  
45. int main(int argc, char **argv) 
46. { 
47.     struct jpeg_decompress_struct cinfo; 
48.     struct jpeg_error_mgr jerr; 
49. #if(BYREAD) 
50.     FILE *infile; 
51. #endif 
52.     int fd; 
53.     unsigned char *buffer; 
54.     struct stat st; 
55.  
56.     int fbdev; 
57.     char *fb_device; 
58.     unsigned char *fbmem; 
59.     unsigned char *fdmem; 
60.     unsigned int screensize; 
61.     unsigned int fb_width; 
62.     unsigned int fb_height; 
63.     unsigned int fb_depth; 
64.     register unsigned int x; 
65.     register unsigned int y; 
66.  
67.     /* check auguments */ 
68.     if (argc != 2) { 
69.         usage("insuffient auguments"); 
70.         exit(-1); 
71.     } 
72.  
73.     /* open framebuffer device */ 
74.     if ((fb_device = getenv("FRAMEBUFFER")) == NULL) 
75.         fb_device = FB_DEV; 
76.     fbdev = fb_open(fb_device); 
77.  
78.     /* get status of framebuffer device */ 
79.     fb_stat(fbdev, &fb_width, &fb_height, &fb_depth); 
80.  
81.     /* map framebuffer device to shared memory */ 
82.     screensize = fb_width * fb_height * fb_depth / 8; 
83.     fbmem = fb_mmap(fbdev, screensize); 
84.  
85. #if (BYREAD) 
86.     /* open input jpeg file */ 
87.     if ((infile = fopen(argv[1], "rb")) == NULL) { 
88.         fprintf(stderr, "open %s failedn", argv[1]); 
89.         exit(-1); 
90.     } 
91. #endif 
92.  
93.     if ((fd = open(argv[1], O_RDONLY)) < 0) { 
94.         perror("open"); 
95.         exit(-1); 
96.     } 
97.  
98.     if (fstat(fd, &st) < 0) { 
99.         perror("fstat"); 
100.         exit(-1); 
101.     } 
102.  
103.     fdmem = fd_mmap(fd, st.st_size); 
104.  
105.     /* init jpeg decompress object error handler */ 
106.     cinfo.err = jpeg_std_error(&jerr); 
107.     jpeg_create_decompress(&cinfo); 
108.  
109.     /* bind jpeg decompress object to infile */ 
110. #if (BYREAD) 
111.     jpeg_stdio_src(&cinfo, infile); 
112. #endif 
113.  
114. #if (BYMEM) 
115.     jpeg_mem_src(&cinfo, fdmem, st.st_size); 
116. #endif 
117.  
118.     /* read jpeg header */ 
119.     jpeg_read_header(&cinfo, TRUE); 
120.  
121.     /* decompress process */ 
122.     jpeg_start_decompress(&cinfo); 
123.     if ((cinfo.output_width > fb_width) || 
124.             (cinfo.output_height > fb_height)) { 
125.         printf("too large jpeg file, can't displayn"); 
126. #if (0) 
127.         return -1; 
128. #endif 
129.     } 
130.  
131.     buffer = (unsigned char *) malloc(cinfo.output_width * 
132.             cinfo.output_components); 
133.  
134.     struct fb_fix_screeninfo fb_finfo; 
135.     struct fb_var_screeninfo fb_vinfo; 
136.  
137.     if (ioctl(fbdev, FBIOGET_FSCREENINFO, &fb_finfo)) { 
138.         perror(__fnc__); 
139.         return -1; 
140.     } 
141.  
142.     if (ioctl(fbdev, FBIOGET_VSCREENINFO, &fb_vinfo)) { 
143.         perror(__fnc__); 
144.         return -1; 
145.     } 
146.  
147. #if(debug) 
148.     draw(fbmem, fb_vinfo, fb_finfo); 
149. #endif 
150.     y = 0; 
151.     while (cinfo.output_scanline < cinfo.output_height) { 
152.         jpeg_read_scanlines(&cinfo, &buffer, 1); 
153.         if (fb_depth == 16) { 
154.             unsigned short color; 
155.  
156.             for (x = 0; x < cinfo.output_width; x++) { 
157.                 color = 
158.                     RGB888toRGB565(buffer[x * 3], 
159.                             buffer[x * 3 + 1], buffer[x * 3 + 2]); 
160.                 fb_pixel(fbmem, fb_width, fb_height, x, y, color); 
161.             } 
162.         } else if (fb_depth == 24) { 
163.             memcpy((unsigned char *) fbmem + y * fb_width * 3, 
164.                     buffer, cinfo.output_width * cinfo.output_components); 
165.         } else if (fb_depth == 32) { 
166.             // memcpy((unsigned char *) fbmem + y * fb_width * 4, 
167.                     // buffer, cinfo.output_width * cinfo.output_components); 
168.             for (x = 0; x < cinfo.output_width; x++) { 
169.                 * (fbmem + y * fb_width * 4 + x * 4)     = (unsigned char)       buffer[x * 3 + 2]; 
170.                 * (fbmem + y * fb_width * 4 + x * 4 + 1) = (unsigned char)       buffer[x * 3 + 1]; 
171.                 * (fbmem + y * fb_width * 4 + x * 4 + 2) = (unsigned char)       buffer[x * 3 + 0]; 
172.                 * (fbmem + y * fb_width * 4 + x * 4 + 3) = (unsigned char) 0; 
173.             } 
174.         } 
175.         y++;    // next scanline 
176.     } 
177.  
178.     /* finish decompress, destroy decompress object */ 
179.     jpeg_finish_decompress(&cinfo); 
180.     jpeg_destroy_decompress(&cinfo); 
181.  
182.     /* release memory buffer */ 
183.     free(buffer); 
184.  
185. #if (BYREAD) 
186.     /* close jpeg inputing file */ 
187.     fclose(infile); 
188. #endif 
189.  
190.     /* unmap framebuffer's shared memory */ 
191.     fb_munmap(fbmem, screensize); 
192.  
193. #if (BYMEM) 
194.     munmap(fdmem, (size_t) st.st_size); 
195.     close(fd); 
196. #endif 
197.  
198.     /* close framebuffer device */ 
199.     fb_close(fbdev); 
200.  
201.     return 0; 
202. } 
203.  
204. void usage(char *msg) 
205. { 
206.     fprintf(stderr, "%sn", msg); 
207.     printf("Usage: fv some-jpeg-file.jpgn"); 
208. } 
209.  
210. /* open framebuffer device. 
211.  * return positive file descriptor if success, 
212.  * else return -1 
213.  */ 
214. int fb_open(char *fb_device) 
215. { 
216.     int fd; 
217.  
218.     if ((fd = open(fb_device, O_RDWR)) < 0) { 
219.         perror(__fnc__); 
220.         return -1; 
221.     } 
222.     return fd; 
223. } 
224.  
225. int fb_close(int fd) 
226. { 
227.     return (close(fd)); 
228. } 
229.  
230. /* get framebuffer's width, height, and depth. 
231.  * return 0 if success, else return -1. 
232.  */ 
233. int fb_stat(int fd, unsigned int *width, unsigned int *height, unsigned int *    depth) 
234. { 
235.     struct fb_fix_screeninfo fb_finfo; 
236.     struct fb_var_screeninfo fb_vinfo; 
237.  
238.     if (ioctl(fd, FBIOGET_FSCREENINFO, &fb_finfo)) { 
239.         perror(__fnc__); 
240.         return -1; 
241.     } 
242.  
243.     if (ioctl(fd, FBIOGET_VSCREENINFO, &fb_vinfo)) { 
244.         perror(__fnc__); 
245.         return -1; 
246.     } 
247.  
248.     *width = fb_vinfo.xres; 
249.     *height = fb_vinfo.yres; 
250.     *depth = fb_vinfo.bits_per_pixel; 
251.  
252.     return 0; 
253. } 
254.  
255. /* map shared memory to framebuffer device. 
256.  * return maped memory if success 
257.  * else return -1, as mmap dose 
258.  */ 
259. void *fb_mmap(int fd, unsigned int screensize) 
260. { 
261.     caddr_t fbmem; 
262.  
263.     if ((fbmem = mmap(0, screensize, PROT_READ | PROT_WRITE, 
264.                     MAP_SHARED, fd, 0)) == MAP_FAILED) { 
265.         perror(__func__); 
266.         return (void *) (-1); 
267.     } 
268.  
269.     return fbmem; 
270. } 
271.  
272. /* map shared memmory to a opened file */ 
273. void *fd_mmap(int fd, unsigned int filesize) 
274. { 
275.     caddr_t fdmem; 
276.  
277.     if ((fdmem = mmap(0, filesize, PROT_READ, 
278.                     MAP_SHARED, fd, 0)) == MAP_FAILED) { 
279.         perror(__func__); 
280.         return (void *) (-1); 
281.     } 
282.  
283.     return fdmem; 
284. } 
285.  
286. /* unmap map memory for framebuffer device */ 
287. int fb_munmap(void *start, size_t length) 
288. { 
289.     return (munmap(start, length)); 
290. } 
291.  
292. /* convert 24bit RGB888 to 16bit RGB565 color format */ 
293. unsigned short RGB888toRGB565(unsigned char red, 
294.         unsigned char green, unsigned char blue) 
295. { 
296.     unsigned short B = (blue >> 3) & 0x001F; 
297.     unsigned short G = ((green >> 2) << 5) & 0x07E0; 
298.     unsigned short R = ((red >> 3) << 11) & 0xF800; 
299.  
300.     return (unsigned short) (R | G | B); 
301. } 
302.  
303. /* display a pixel on the framebuffer device. 
304.  * fbmem is the starting memory of framebuffer, 
305.  * width and height are dimension of framebuffer, 
306.  * width and height are dimension of framebuffer, 
307.  * x and y are the coordinates to display, 
308.  * color is the pixel's color value. 
309.  * return 0 if success, otherwise return -1. 
310.  */ 
311. int fb_pixel(void *fbmem, int width, int height, 
312.         int x, int y, unsigned short color) 
313. { 
314.     if ((x > width) || (y > height)) 
315.         return -1; 
316.  
317.     unsigned short *dst = ((unsigned short *) fbmem + y * width + x); 
318.  
319.     *dst = color; 
320.     return 0; 
321. } 

3.LCD驅動

我們用到的是一塊東華3.5寸數字屏,型號為WXCAT35-TG3.下面的驅動程序是韋東山老師課堂上現場寫的,如下:

1. #include <linux/module.h> 
2. #include <linux/kernel.h> 
3. #include <linux/errno.h> 
4. #include <linux/string.h> 
5. #include <linux/mm.h> 
6. #include <linux/slab.h> 
7. #include <linux/delay.h> 
8. #include <linux/interrupt.h> 
9. #include <linux/fb.h> 
10. #include <linux/init.h> 
11. #include <linux/ioport.h> 
12. #include <linux/dma-mapping.h> 
13.  
14. #include <asm/uaccess.h> 
15. #include <asm/system.h> 
16. #include <asm/irq.h> 
17. #include <asm/setup.h> 
18.  
19. /* WXCAT35-TG3 */ 
20. struct s3c_lcd_regs { 
21.     unsigned long    lcdcon1; 
22.     unsigned long    lcdcon2; 
23.     unsigned long    lcdcon3; 
24.     unsigned long    lcdcon4; 
25.     unsigned long    lcdcon5; 
26.     unsigned long    lcdsaddr1; 
27.     unsigned long    lcdsaddr2; 
28.     unsigned long    lcdsaddr3; 
29.     unsigned long    redlut; 
30.     unsigned long    greenlut; 
31.     unsigned long    bluelut; 
32.     unsigned long    reserved[9]; 
33.     unsigned long    dithmode; 
34.     unsigned long    tpal; 
35.     unsigned long    lcdintpnd; 
36.     unsigned long    lcdsrcpnd; 
37.     unsigned long    lcdintmsk; 
38.     unsigned long    lpcsel; 
39. }; 
40.  
41. static u32 colregs[16]; 
42. static struct fb_info *s3c_fb_info; 
43. static dma_addr_t s3c_fb_handle; 
44. static unsigned long fb_va; 
45.  
46. /* from pxafb.c */ 
47. static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf) 
48. { 
49.     chan &= 0xffff; 
50.     chan >>= 16 - bf->length; 
51.     return chan << bf->offset; 
52. } 
53.  
54. static int s3cfb_setcolreg(unsigned regno, 
55.                    unsigned red, unsigned green, unsigned blue, 
56.                    unsigned transp, struct fb_info *info) 
57. { 
58.     unsigned int val; 
59.  
60.     /* dprintk("setcol: regno=%d, rgb=%d,%d,%dn", regno, red, green, blue); */ 
61.  
62.     /* true-colour, use pseuo-palette */ 
63.  
64.     if (regno < 16) { 
65.         u32 *pal = s3c_fb_info->pseudo_palette; 
66.  
67.         val  = chan_to_field(red,   &s3c_fb_info->var.red); 
68.         val |= chan_to_field(green, &s3c_fb_info->var.green); 
69.         val |= chan_to_field(blue,  &s3c_fb_info->var.blue); 
70.  
71.         pal[regno] = val; 
72.     } 
73.  
74.     return 0; 
75. } 
76.  
77. static struct fb_ops s3cfb_ops = { 
78.     .owner        = THIS_MODULE, 
79. //    .fb_check_var    = clps7111fb_check_var, 
80. //    .fb_set_par    = clps7111fb_set_par, 
81. //    .fb_setcolreg    = clps7111fb_setcolreg, 
82. //    .fb_blank    = clps7111fb_blank, 
83.  
84.     .fb_setcolreg    = s3cfb_setcolreg, 
85.     .fb_fillrect    = cfb_fillrect, 
86.     .fb_copyarea    = cfb_copyarea, 
87.     .fb_imageblit    = cfb_imageblit, 
88. }; 
89.  
90. struct s3c_lcd_regs *s3c_lcd_regs; 
91. static volatile unsigned long *gpccon; 
92. static volatile unsigned long *gpdcon; 
93. static volatile unsigned long *gpgcon; 
94.  
95. int s3c_lcd_init(void) 
96. { 
97.     extern int debug_lcd; 
98.     /* 1. 分配一個fb_info結構體 */ 
99.     s3c_fb_info = framebuffer_alloc(0, NULL); 
100.     printk("%s %dn", __FUNCTION__, __LINE__); 
101.  
102.     /* 2. 設置fb_info結構體 */ 
103.     /* 
104.        2.1 設置固定的信息 
105.        2.2 設置可變的信息 
106.        2.3 設置操作函數 
107.     */ 
108.  
109.     /* 24BPP(bits per pixel), 會用到4字節, 其中浪費1字節 */ 
110.     strcpy(s3c_fb_info->fix.id, "WXCAT35-TG3"); 
111.     // s3c_fb_info->fix.smem_start // frame buffer's physical address 
112.     s3c_fb_info->fix.smem_len    = 320*240*32/8; 
113.     s3c_fb_info->fix.type        = FB_TYPE_PACKED_PIXELS; 
114.     s3c_fb_info->fix.visual      = FB_VISUAL_TRUECOLOR; 
115.     s3c_fb_info->fix.line_length = 320 * 4; 
116.  
117.     s3c_fb_info->var.xres             = 320; 
118.     s3c_fb_info->var.yres             = 240; 
119.     s3c_fb_info->var.xres_virtual     = 320; 
120.     s3c_fb_info->var.yres_virtual     = 240; 
121.     s3c_fb_info->var.bits_per_pixel   = 32; 
122.  
123.     s3c_fb_info->var.red.offset       = 16; 
124.     s3c_fb_info->var.red.length       = 8; 
125.  
126.     s3c_fb_info->var.green.offset     = 8; 
127.     s3c_fb_info->var.green.length     = 8; 
128.  
129.     s3c_fb_info->var.blue.offset      = 0; 
130.     s3c_fb_info->var.blue.length      = 8; 
131.  
132.     //s3c_fb_info->var.activate         = FB_ACTIVATE; 
133.  
134.     s3c_fb_info->fbops                = &s3cfb_ops; 
135.     s3c_fb_info->pseudo_palette       = colregs; 
136.  
137.     /* 3. 硬件相關的操作 */ 
138.     /* 配置GPIO */ 
139.     gpccon     = ioremap(0x56000020, 4); 
140.     gpdcon     = ioremap(0x56000030, 4); 
141.     gpgcon     = ioremap(0x56000060, 4); 
142.     *gpccon = 0xaaaaaaaa; 
143.     *gpdcon = 0xaaaaaaaa; 
144.     *gpgcon |= (3<<8);  /* GPG4 use as lcd_pwren */ 
145.     printk("%s %dn", __FUNCTION__, __LINE__); 
146.  
147.     s3c_lcd_regs = ioremap(0X4D000000, sizeof(struct s3c_lcd_regs)); 
148.  
149.     /* 
150.      * VCLK = HCLK / [(CLKVAL+1)x2] = 100M/[(CLKVAL+1)x2] = 6.4 
151.      * CLKVAL = 6.8 = 7 
152.      * TFT LCD panel 
153.      * 24bpp 
154.      */ 
155.     s3c_lcd_regs->lcdcon1 = (7<<8)|(0<<7)|(3<<5)|(0x0d<<1)|(0<<0); 
156.     printk("%s %dn", __FUNCTION__, __LINE__); 
157.  
158.     /* VBPD: 電子槍收到VSYNC信號后,"多長時間"才能跳回第1行 
159.      * VBPD=14,      LCD: tvb=15 
160.      * LINEVAL=239,  LCD: 有240行 
161.      * VFPD=11,      LCD: tvf=12  // 發出最后一行數據后,再過多長時間才發出VSYNC 
162.      * VSPW=2,       LCD: tvp=3   // VSYNC的寬度 
163.      */ 
164.     s3c_lcd_regs->lcdcon2 = (14<<24)|(239<<14)|(11<<6)|(2<<0); 
165.  
166.     /* HBPD: 電子槍收到HSYNC信號后,"多長時間"才能跳回第1列 
167.      * HBPD=37,      LCD: thb=38 
168.      * HORVAL=319,   LCD: 有320行 
169.      * HFPD=19,      LCD: thf=20  // 發出最后一象素數據后,再過多長時間才發出HSYNC 
170.      * HSPW=29,      LCD: thp=30   // VSYNC的寬度 
171.      */ 
172.     s3c_lcd_regs->lcdcon3 = (37<<19)|(319<<8)|(19<<0); 
173.     s3c_lcd_regs->lcdcon4 = 29; 
174.  
175.     /* bit10:  在VCLK上升沿取數據  
176.      * bit9 :  VSYNC低電平有效 
177.      * bit8 :  HSYNC低電平有效 
178.      * bit5 :  PWREN低電平有效 
179.      */     
180.     s3c_lcd_regs->lcdcon5 = (1<<10)|(1<<9)|(1<<8)|(1<<5)|(0<<3); 
181.  
182.     /* 分配frame buffer */ 
183.     fb_va = (unsigned long)dma_alloc_writecombine(NULL, s3c_fb_info->fix.smem_len, &s3c_fb_handle, GFP_KERNEL); 
184.  
185.     printk("fb_va = 0x%x, pa = 0x%xn", fb_va, s3c_fb_handle); 
186.     s3c_fb_info->fix.smem_start = s3c_fb_handle; 
187.     s3c_fb_info->screen_base    = fb_va; 
188.  
189.     /* 把framebuffer的地址告訴LCD控制器 */ 
190.     s3c_lcd_regs->lcdsaddr1 = (s3c_fb_info->fix.smem_start >> 1); 
191.     s3c_lcd_regs->lcdsaddr2 = ((s3c_fb_info->fix.smem_start+320*240*4) >> 1) & 0x1fffff; 
192.     s3c_lcd_regs->lcdsaddr3 = 320*4/2; 
193.  
194.     /* 使能LCD */ 
195.     s3c_lcd_regs->lcdcon1 |= (1<<0); 
196.  
197.     /* 4. register_framebuffer */ 
198.     printk("%s %dn", __FUNCTION__, __LINE__); 
199.     //debug_lcd = 1; 
200.     register_framebuffer(s3c_fb_info); 
201.     printk("%s %dn", __FUNCTION__, __LINE__); 
202.  
203.     return 0;  
204. } 
205.  
206. void s3c_lcd_exit(void) 
207. { 
208.     unregister_framebuffer(s3c_fb_info); 
209.     dma_free_writecombine(NULL, s3c_fb_info->fix.smem_len, fb_va, s3c_fb_handle); 
210.     iounmap(s3c_lcd_regs); 
211.     iounmap(gpccon); 
212.     iounmap(gpdcon); 
213.     iounmap(gpgcon); 
214.     framebuffer_release(s3c_fb_info); 
215. } 
216.  
217. module_init(s3c_lcd_init); 
218. module_exit(s3c_lcd_exit); 
219.  
220. MODULE_LICENSE("GPL"); 

然后把它加入到內核,以靜態加載的模式啟動.最后,可以把讀取內存jpeg格式數據輸出到LCD屏的這部分整合到mjpg-stream或servfox去,就實現了采集圖像本地顯示了.