程序博客网 > bilibili视频编辑软件

S3C2440 LCD framebuffer 显示图像

来源：互联网 发布：bilibili视频编辑软件 编辑：程序博客网 时间：2024/06/08 14:23

先直接给出程序，过两天再写有关framebuffer的内容，主要怕忘了：

代码参考了网上的画图代码，因为画斜线不是那么好画的：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. #include <sys/types.h>  
  4. #include <sys/stat.h>  
  5. #include <fcntl.h>  
  6. #include <linux/fb.h>  
  7. #include <sys/mman.h>  
  8. #include <string.h>  
  9. #include <stdlib.h>  
  10.   
  11. #define XRES 480  
  12.   
  13. char *fb_addr;  
  14. unsigned int fb_size;  
  15. //void drawline(int x1, int y1, int x2, int y2, int c);  
  16. /*  light a pixel   */  
  17. void Pixel(int x, int y, int color)  
  18. {  
  19.     *((unsigned short *)(fb_addr+y*XRES*2+x*2)) = color;  
  20. }  
  21. /*  draw a line */  
  22. void Line(int x1,int y1,int x2,int y2,int color)  
  23. {  
  24.     int dx,dy,e;  
  25.     dx=x2-x1;   
  26.     dy=y2-y1;  
  27.       
  28.     if(dx>=0)  
  29.     {  
  30.         if(dy >= 0) // dy>=0  
  31.         {  
  32.             if(dx>=dy) // 1/8 octant  
  33.             {  
  34.                 e=dy-dx/2;  
  35.                 while(x1<=x2)  
  36.                 {  
  37.                     Pixel(x1,y1,color);  
  38.                     if(e>0){y1+=1;e-=dx;}      
  39.                     x1+=1;  
  40.                     e+=dy;  
  41.                 }  
  42.             }  
  43.             else        // 2/8 octant  
  44.             {  
  45.                 e=dx-dy/2;  
  46.                 while(y1<=y2)  
  47.                 {  
  48.                     Pixel(x1,y1,color);  
  49.                     if(e>0){x1+=1;e-=dy;}      
  50.                     y1+=1;  
  51.                     e+=dx;  
  52.                 }  
  53.             }  
  54.         }  
  55.         else           // dy<0  
  56.         {  
  57.             dy=-dy;   // dy=abs(dy)  
  58.   
  59.             if(dx>=dy) // 8/8 octant  
  60.             {  
  61.                 e=dy-dx/2;  
  62.                 while(x1<=x2)  
  63.                 {  
  64.                     Pixel(x1,y1,color);  
  65.                     if(e>0){y1-=1;e-=dx;}      
  66.                     x1+=1;  
  67.                     e+=dy;  
  68.                 }  
  69.             }  
  70.             else        // 7/8 octant  
  71.             {  
  72.                 e=dx-dy/2;  
  73.                 while(y1>=y2)  
  74.                 {  
  75.                     Pixel(x1,y1,color);  
  76.                     if(e>0){x1+=1;e-=dy;}      
  77.                     y1-=1;  
  78.                     e+=dx;  
  79.                 }  
  80.             }  
  81.         }      
  82.     }  
  83.     else //dx<0  
  84.     {  
  85.         dx=-dx;        //dx=abs(dx)  
  86.         if(dy >= 0) // dy>=0  
  87.         {  
  88.             if(dx>=dy) // 4/8 octant  
  89.             {  
  90.                 e=dy-dx/2;  
  91.                 while(x1>=x2)  
  92.                 {  
  93.                     Pixel(x1,y1,color);  
  94.                     if(e>0){y1+=1;e-=dx;}      
  95.                     x1-=1;  
  96.                     e+=dy;  
  97.                 }  
  98.             }  
  99.             else        // 3/8 octant  
  100.             {  
  101.                 e=dx-dy/2;  
  102.                 while(y1<=y2)  
  103.                 {  
  104.                     Pixel(x1,y1,color);  
  105.                     if(e>0){x1-=1;e-=dy;}      
  106.                     y1+=1;  
  107.                     e+=dx;  
  108.                 }  
  109.             }  
  110.         }  
  111.         else           // dy<0  
  112.         {  
  113.             dy=-dy;   // dy=abs(dy)  
  114.   
  115.             if(dx>=dy) // 5/8 octant  
  116.             {  
  117.                 e=dy-dx/2;  
  118.                 while(x1>=x2)  
  119.                 {  
  120.                     Pixel(x1,y1,color);  
  121.                     if(e>0){y1-=1;e-=dx;}      
  122.                     x1-=1;  
  123.                     e+=dy;  
  124.                 }  
  125.             }  
  126.             else        // 6/8 octant  
  127.             {  
  128.                 e=dx-dy/2;  
  129.                 while(y1>=y2)  
  130.                 {  
  131.                     Pixel(x1,y1,color);  
  132.                     if(e>0){x1-=1;e-=dy;}      
  133.                     y1-=1;  
  134.                     e+=dx;  
  135.                 }  
  136.             }  
  137.         }      
  138.     }  
  139. }  
  140.   
  141. void Rectangle(int x1,int y1,int x2,int y2,int color)  
  142. {  
  143.     Line(x1,y1,x2,y1,color);  
  144.     Line(x2,y1,x2,y2,color);  
  145.     Line(x1,y2,x2,y2,color);  
  146.     Line(x1,y1,x1,y2,color);  
  147. }  
  148. void FilledRectangle(int x1,int y1,int x2,int y2,int color)  
  149. {  
  150.     int i;  
  151.   
  152.     for(i=y1;i<=y2;i++)  
  153.     Line(x1,i,x2,i,color);  
  154. }  
  155. void main()  
  156. {  
  157.     int x1, y1,\  
  158.         x2, y2,\  
  159.         c;  
  160.     int fbd = 0;  
  161.     struct fb_fix_screeninfo fb_fix;  
  162.     struct fb_var_screeninfo fb_var;  
  163.   
  164.     fbd = open("/dev/fb0", O_RDWR);  
  165.   
  166.     ioctl(fbd, FBIOGET_FSCREENINFO, &fb_fix);  
  167.     ioctl(fbd, FBIOGET_VSCREENINFO, &fb_var);  
  168.   
  169.     fb_size = fb_var.yres * fb_fix.line_length;  
  170.       
  171.     printf("xres:%d, yres:%d\n"\  
  172.             "bits_per_pixel:%d\n"\  
  173.             "height:%d, width:%d\n",\  
  174.             fb_var.xres, fb_var.yres,\  
  175.             fb_var.bits_per_pixel,\  
  176.             fb_var.height, fb_var.width);  
  177.     printf("smem_start:%ld\n"\  
  178.             "smem_len:%d\n"\  
  179.             "line_length:%d\n",\  
  180.             fb_fix.smem_start,\  
  181.             fb_fix.smem_len,\  
  182.             fb_fix.line_length);  
  183.   
  184.     fb_addr=(char *)mmap(0, fb_size, PROT_READ|PROT_WRITE, MAP_SHARED, fbd, 0);  
  185.       
  186.     Line(0, 0, 480, 272, 0xF800);  
  187.   
  188.     Rectangle(100, 100, 200, 200, 0x7E00);  
  189.   
  190.     FilledRectangle(300, 5, 480, 10, 0x1F);  
  191.   
  192.    //drawline(136, 100, 136, 300, 0xFFFF);  
  193.     close(fbd);  
  194. }  

下面再给出大神的彩色渐变测试程序：

[cpp] view plain copy
  1. #include <unistd.h>    
  2. #include <stdlib.h>    
  3. #include <stdio.h>    
  4. #include <fcntl.h>    
  5. #include <linux/fb.h>    
  6. #include <sys/mman.h>    
  7.     
  8. int main(int argc, char *argv[])    
  9. {    
  10.     int fbfd = 0;    
  11.     struct fb_var_screeninfo vinfo;    
  12.     unsigned long screensize = 0;    
  13.     unsigned long location = 0;    
  14.     char *fbp = 0;    
  15.     int x = 0, y = 0;    
  16.     int seg_len = 0;    
  17.     int tmp_seg_len = 0;    
  18.     int seg_num = 0;    
  19.     unsigned short rgb = 0;    
  20.     unsigned int r = 0, g = 0, b = 0;    
  21.     
  22.     // Open the file for reading and writing    
  23.     fbfd = open("/dev/fb0", O_RDWR);    
  24.     if (!fbfd) {    
  25.         printf("Error: cannot open framebuffer device.\n");    
  26.         exit(1);    
  27.     }    
  28.     printf("The framebuffer device was opened successfully.\n");    
  29.     
  30.     // Get variable screen information    
  31.     if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) {    
  32.         printf("Error reading variable information.\n");    
  33.         exit(1);    
  34.     }    
  35.     
  36.     printf("%dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);    
  37.     if (vinfo.bits_per_pixel != 16) {    
  38.         printf("Error: not supported bits_per_pixel, it only supports 16 bit color\n");    
  39.         exit(1);    
  40.     }    
  41.     
  42.     // Figure out the size of the screen in bytes    
  43.     screensize = vinfo.xres * vinfo.yres * 2;    
  44.     
  45.     // Map the device to memory    
  46.     fbp = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED,    
  47.         fbfd, 0);    
  48.     if ((int)fbp == -1) {    
  49.         printf("Error: failed to map framebuffer device to memory.\n");    
  50.         exit(4);    
  51.     }    
  52.     printf("The framebuffer device was mapped to memory successfully.\n");    
  53.     
  54.     seg_len = vinfo.yres/6;    
  55. #if 1    
  56.     seg_len = vinfo.yres/6;    
  57.     for (seg_num = 0; seg_num < 6; seg_num++) {    
  58.         if (seg_num == 5)     
  59.             tmp_seg_len = vinfo.yres - seg_len*5;    
  60.         else     
  61.             tmp_seg_len = seg_len;    
  62.             
  63.         for (y = 0; y < tmp_seg_len; y++) {    
  64.             for (x = 0; x < vinfo.xres; x++) {    
  65.                 location = seg_num*seg_len*vinfo.xres*2 + (y*vinfo.xres+ x)*2;    
  66.                 switch (seg_num) {    
  67.                     case 0:    
  68.                     r = 0xff;    
  69.                     g = (0xff/seg_len)*y;    
  70.                     b = 0;    
  71.                     break;    
  72.                     case 1:    
  73.                     r = (0xff/seg_len)*(seg_len-y);    
  74.                     g = 0xff;    
  75.                     b = 0;    
  76.                     break;    
  77.                     case 2:    
  78.                     r = 0;    
  79.                     g = 0xff;    
  80.                     b = (0xff/seg_len)*y;     
  81.                     break;    
  82.                     case 3:    
  83.                     r = 0;    
  84.                     g = (0xff/seg_len)*(seg_len-y);    
  85.                     b = 0xff;    
  86.                     break;    
  87.                     case 4:    
  88.                     r =  (0xff/seg_len)*y;      
  89.                     g = 0;    
  90.                     b = 0xff;    
  91.                     break;    
  92.                     case 5:    
  93.                     r = 0xff;    
  94.                     b = (0xff/seg_len)*(seg_len-y);     
  95.                     g = 0;    
  96.                     break;    
  97.                     default:    
  98.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);    
  99.                     break;    
  100.                 }    
  101.     
  102.                 r = (r*0x1f)/0xff;    
  103.                 g = (g*0x3f)/0xff;    
  104.                 b = (b*0x1f)/0xff;    
  105.                 rgb = (r << 11) | (g << 5) | b;    
  106.                 *((unsigned short*)(fbp + location)) = rgb;    
  107.             }    
  108.         }    
  109.     }    
  110.         
  111.     sleep(2);    
  112.         
  113.     seg_len = vinfo.yres/6;    
  114.     for (seg_num = 0; seg_num < 6; seg_num++) {    
  115.         if (seg_num == 5)     
  116.             tmp_seg_len = vinfo.yres - seg_len*5;    
  117.         else     
  118.             tmp_seg_len = seg_len;    
  119.     
  120.         for (y = 0; y < tmp_seg_len; y++) {    
  121.             for (x = 0; x < vinfo.xres; x++) {    
  122.                 location = seg_num*seg_len*vinfo.xres*2 + (y*vinfo.xres+ x)*2;    
  123.                 switch (seg_num) {    
  124.                     case 0://grey    
  125.                     r = 100;    
  126.                     g = 100;    
  127.                     b = 100;     
  128.                     break;    
  129.                     case 1: //black    
  130.                     r = 0x00;    
  131.                     g = 0x00;    
  132.                     b = 0x00;    
  133.                     break;    
  134.                     case 2://white    
  135.                     r = 0xff;    
  136.                     g = 0xff;    
  137.                     b = 0xff;    
  138.                     break;    
  139.                     case 3://red    
  140.                     r = 0xff;    
  141.                     g = 0;    
  142.                     b = 0;    
  143.                     break;    
  144.                     case 4: //green    
  145.                     r =  0;         
  146.                     g = 0xff;    
  147.                     b = 0;    
  148.                     break;    
  149.                     case 5: //blue    
  150.                     r = 0;    
  151.                     g = 0;    
  152.                     b = 0xff;     
  153.                     break;    
  154.                     default:    
  155.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);    
  156.                     break;      
  157.                 }    
  158.     
  159.                 r = (r*0x1f)/0xff;    
  160.                 g = (g*0x3f)/0xff;    
  161.                 b = (b*0x1f)/0xff;    
  162.                 rgb = (r << 11) | (g << 5) | b;    
  163.                 *((unsigned short*)(fbp + location)) = rgb;    
  164.             }    
  165.         }    
  166.     }    
  167. #endif    
  168.     
  169. #if 1    
  170.     sleep(2);    
  171.     
  172.     seg_len = vinfo.xres/6;    
  173.     for (seg_num = 0; seg_num < 6; seg_num++) {      
  174.         if (seg_num == 5)     
  175.             tmp_seg_len = vinfo.xres - seg_len*5;    
  176.         else     
  177.             tmp_seg_len = seg_len;    
  178.     
  179.         for (x = 0; x < tmp_seg_len; x++) {    
  180.             for (y = 0; y < vinfo.yres; y++) {    
  181.                 location = y*vinfo.xres*2 + (seg_num*seg_len + x)*2;    
  182.                     
  183.                 switch (seg_num) {    
  184.                     case 0:    
  185.                     r = 0xff;    
  186.                     g = (0xff/seg_len)*x;    
  187.                     b = 0;    
  188.                     break;    
  189.                     case 1:    
  190.                     r = (0xff/seg_len)*(seg_len-x);    
  191.                     g = 0xff;    
  192.                     b = 0;    
  193.                     break;    
  194.                     case 2:    
  195.                     r = 0;    
  196.                     g = 0xff;    
  197.                     b = (0xff/seg_len)*x;     
  198.                     break;    
  199.                     case 3:    
  200.                     r = 0;    
  201.                     g = (0xff/seg_len)*(seg_len-x);    
  202.                     b = 0xff;    
  203.                     break;    
  204.                     case 4:    
  205.                     r =  (0xff/seg_len)*x;      
  206.                     g = 0;    
  207.                     b = 0xff;    
  208.                     break;    
  209.                     case 5:    
  210.                     r = 0xff;    
  211.                     g = 0;    
  212.                     b = (0xff/seg_len)*(seg_len-x);     
  213.                     break;    
  214.                     default:    
  215.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);    
  216.                     break;    
  217.                 }    
  218.     
  219.                 r = (r*0x1f)/0xff;    
  220.                 g = (g*0x3f)/0xff;    
  221.                 b = (b*0x1f)/0xff;    
  222.                 rgb = (r << 11) | (g << 5) | b;    
  223.                 *((unsigned short*)(fbp + location)) = rgb;    
  224.             }    
  225.         }    
  226.     }    
  227.     
  228.     sleep(2);    
  229.     
  230.     seg_len = vinfo.xres/6;    
  231.     /* white black gray red green blue */    
  232.     for (seg_num = 0; seg_num < 6; seg_num++) {    
  233.         if (seg_num == 5)     
  234.             tmp_seg_len = vinfo.xres - seg_len*5;    
  235.         else     
  236.             tmp_seg_len = seg_len;    
  237.     
  238.         for (x = 0; x < tmp_seg_len; x++) {    
  239.             for (y = 0; y < vinfo.yres; y++) {    
  240.                 location = y*vinfo.xres*2 + (seg_num*seg_len + x)*2;    
  241.                     
  242.                 switch (seg_num) {    
  243.                     case 0://grey    
  244.                     r = 100;    
  245.                     g = 100;    
  246.                     b = 100;     
  247.                     break;    
  248.                     case 1://black    
  249.                     r = 0;    
  250.                     g = 0;    
  251.                     b = 0;    
  252.                     break;    
  253.                     case 2: //white    
  254.                     r = 0xff;    
  255.                     g = 0xff;    
  256.                     b = 0xff;    
  257.                     break;    
  258.                     case 3://red    
  259.                     r = 0xff;    
  260.                     g = 0;    
  261.                     b = 0;    
  262.                     break;    
  263.                     case 4: //green    
  264.                     r =  0;         
  265.                     g = 0xff;    
  266.                     b = 0;    
  267.                     break;    
  268.                     case 5: //blue    
  269.                     r = 0;    
  270.                     g = 0;    
  271.                     b = 0xff;     
  272.                     break;    
  273.                     default:    
  274.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);    
  275.                     break;    
  276.                 }    
  277.                     
  278.                 r = (r*0x1f)/0xff;    
  279.                 g = (g*0x3f)/0xff;    
  280.                 b = (b*0x1f)/0xff;    
  281.                 rgb = (r << 11) | (g << 5) | b;    
  282.                 *((unsigned short*)(fbp + location)) = rgb;    
  283.             }    
  284.         }    
  285.     }    
  286. #endif    
  287.     
  288.     munmap(fbp, screensize);    
  289.     close(fbfd);    
  290.     return 0;    
  291. }    



最后我自己用程序转了一副自己做的图片，显示到板子上

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. #include <sys/types.h>  
  4. #include <sys/stat.h>  
  5. #include <fcntl.h>  
  6. #include <linux/fb.h>  
  7. #include <sys/mman.h>  
  8. #include <string.h>  
  9. #include <stdlib.h>  
  10.   
  11. #define XRES 480  
  12. char *fb_addr;  
  13. unsigned int fb_size;  
  14.   
  15.   
  16. const unsigned short logo[] = {/*内容省略，因为数据实在太长了*/  
  17.         
  18. };  
  19.   
  20.   
  21.   
  22.   
  23. void main()  
  24. {  
  25.     int x1, y1,\  
  26.         x2, y2,\  
  27.         c, i, j;  
  28.     int fbd = 0;  
  29.     struct fb_fix_screeninfo fb_fix;  
  30.     struct fb_var_screeninfo fb_var;  
  31.   
  32.     fbd = open("/dev/fb0", O_RDWR);  
  33.   
  34.     ioctl(fbd, FBIOGET_FSCREENINFO, &fb_fix);  
  35.     ioctl(fbd, FBIOGET_VSCREENINFO, &fb_var);  
  36.   
  37.     fb_size = fb_var.yres * fb_fix.line_length;  
  38.       
  39.     printf("xres:%d, yres:%d\n"\  
  40.             "bits_per_pixel:%d\n"\  
  41.             "height:%d, width:%d\n",\  
  42.             fb_var.xres, fb_var.yres,\  
  43.             fb_var.bits_per_pixel,\  
  44.             fb_var.height, fb_var.width);  
  45.     printf("smem_start:%ld\n"\  
  46.             "smem_len:%d\n"\  
  47.             "line_length:%d\n",\  
  48.             fb_fix.smem_start,\  
  49.             fb_fix.smem_len,\  
  50.             fb_fix.line_length);  
  51.   
  52.     fb_addr=(char *)mmap(0, fb_size, PROT_READ|PROT_WRITE, MAP_SHARED, fbd, 0);  
  53.       
  54.     for(i=0; i<130560; i++)  
  55.     {  
  56.         *((unsigned short *)(fb_addr+i*2)) = logo[i];  
  57.     }  
  58.    // Line(0, 0, 480, 272, 0xF800);  
  59.   
  60.     //Rectangle(100, 100, 200, 200, 0x7E00);  
  61.   
  62.     //FilledRectangle(300, 5, 480, 10, 0x1F);  
  63.   
  64.    //drawline(136, 100, 136, 300, 0xFFFF);  
  65.     close(fbd);  
  66. }  




0 0
bilibili视频编辑软件 bilibili视频编辑软件
原创粉丝点击
热门IT博客
网易新闻客户端源码网易新闻客户端源码
python3源码剖析 pdfpython3源码剖析 pdf
成都知言科技有限公司
淘宝直通车投放技巧
淘宝开户流程
示范电子口岸网络
iphone监控软件
sql攻击 政府网站
nginx配置虚拟主机
阳台收缩躺椅 知乎
淘宝达人 微淘号达人
儿童护眼灯 知乎
excel做数据分析
最简单交通灯单片机c51
淘宝主图尺寸大小
淘宝店怎么开通客服
cocos2d js 骨骼动画
ubuntu怎么查看用户名
好奇心日报 知乎
淘宝衣服代购是真的吗
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 龙猫重度中暑怎么办 小孩中暑后咳嗽怎么办 狗重度中暑昏迷怎么办 孩子中暑了呕吐怎么办 一岁宝宝中暑怎么办 骑摩托车下雨了怎么办 棉袄脏了不想洗怎么办 棉袄袖口特别脏怎么办 没有扣眼的腰带怎么办 消防部队改革士兵怎么办 84洗衣服手剥皮怎么办 羊毛裤水洗了怎么办 小公司开支亏损怎么办 带上耳塞后耳鸣怎么办 鞋子拉链磨脚怎么办 科目三系统误判怎么办 遇到障碍物老熄火怎么办 高速上遇到动物怎么办 高速上有障碍物怎么办 雨刮器工作遇到障碍物怎么办 高速路上遇到障碍物怎么办 开车撞到柱子怎么办 喝酒撞了护栏怎么办 漏电保护器过载怎么办 不停有国外电话怎么办 身体铅含量高怎么办 洗衣机买大了怎么办 三角插头坏了怎么办 移动硬盘读不出来怎么办 高压线断落地面怎么办 水冷螺杆机制热怎么办 施工升降机突然停电怎么办 高压锅煮饭响了怎么办 美的高压锅漏气怎么办 电压力锅盖漏气怎么办 电饭锅焦粘锅底怎么办 电饭锅煮焦了怎么办 九阳压力锅漏气怎么办 高压锅排气阀漏气怎么办 电锅漏电麻手怎么办 美的pss5032漏气怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里