Framebuffer的配置及应用——先转载留着，以后一定要弄懂

http://blog.csdn.net/tju355/article/details/6881389

 

借助于framebuffer，我们能够在console下面作很多事情。首先下载framebuffer的配置工具fbset:
# apt-get install fbset 下载完毕后，配置文件/etc/fb.modes随之产生。

比较简单的作法是用万能的vesafb，如果它被编译进了内核，如：
Device Drivers -> Graphics support ->

• VESA VGA graphics support
  那么在grub内核引导那一行的后面加上vga=791 它的含义是VESA framebuffer console @ 1024x768x64k，进入系统后可以直接使用framebuffer，看一下这种情况下的各项数据：
  # fbset -s
  mode "1024x768-76"
      # D: 78.653 MHz, H: 59.949 kHz, V: 75.694 Hz
      geometry 1024 768 1024 768 16
      timings 12714 128 32 16 4 128 4
      rgba 5/11,6/5,5/0,0/0
  endmode
  
  用具体显卡的framebuffer驱动是另一种选择，拿Nvidia显卡为例，Nvidia显卡的xorg驱动模块与其framebuffer的驱动模块是互相排斥的，如果要用一个就必须清除另一个：
  # rmmod nvidia
  装载nvidia的framebuffer驱动：
  # modprobe nvidiafb
  装载成功的时候，会产生/dev/fb0设备，console屏幕上的字体会有变化。
  看一下当前的配置：
  # fbset -s
  mode "1024x768-85"
      # D: 94.500 MHz, H: 68.677 kHz, V: 84.997 Hz
      geometry 1024 768 1024 32767 8
      timings 10582 208 48 36 1 96 3
      hsync high
      vsync high
      accel true
      rgba 8/0,8/0,8/0,0/0
  endmode
  
  需要改变一下geometry及色深：
  # fbset -g 1024 768 1024 768 32
  # fbset -s
  mode "1024x768-85"
      # D: 94.500 MHz, H: 68.677 kHz, V: 84.997 Hz
      geometry 1024 768 1024 768 32
      timings 10582 208 48 36 1 96 3
      hsync high
      vsync high
      accel true
      rgba 8/16,8/8,8/0,8/24
  endmode
  
  我们把它与使用VESA ramebuffer后的数据比较一下,显然，根据具体的显卡来驱动framebuffer可以在颜色上达到最佳值，好，现在我们在console下面能够作的事情：
  一、视频播放，可以用mplayer 或者 fbxine：
  # mplayer -vo fbdev -vf scale=1024:768 video_file.avi
  -vo fbdev 是告诉mplayer用framebuffer作视频驱动.
  -vf scale=1024:768 是全屏的方法，可按屏幕的具体情况作调整
  用fbxine的话需要下载：
  # apt-get install xine-console
  二、图片文件与pdf文件浏览：
  # apt-get install fbi
  用这个软件包里的fbi可以浏览图片，fbgs可以观看pdf文件：
  # fbi -a *jpg
  # fbgs -c *pdf
  三、中文显示：
  # apt-get install jfbterm
  # jfbterm
  中文显示的效果完美。
  
  文章出处：飞诺网(http://www.diybl.com/course/6_system/linux/Linuxjs/2008721/133651.html)
  
  ------------------------------------------------------------------------
  在内核Documentation/fb/vesafb.txt文件中,有如下vesa-framebuffer的说明
  Switching modes is done using the vga=... boot parameter. Read
  Documentation/svga.txt for details.
  You should compile in both vgacon (for text mode) and vesafb (for
  graphics mode). Which of them takes over the console depends on
  whenever the specified mode is text or graphics.
  The graphic modes are NOT in the list which you get if you boot with
  vga=ask and hit return. The mode you wish to use is derived from the
  VESA mode number. Here are those VESA mode numbers:
  | 640x480 800x600 1024x768 1280x1024
  ----+-------------------------------------
  256 | 0x101 0x103 0x105 0x107 8位色
  32k | 0x110 0x113 0x116 0x119 15位色
  64k | 0x111 0x114 0x117 0x11A 16位色
  16M | 0x112 0x115 0x118 0x11B 24位色
  The video mode number of the Linux kernel is the VESA mode number plus
  0x200.
  Linux_kernel_mode_number = VESA_mode_number + 0x200
  So the table for the Kernel mode numbers are:
  | 640x480 800x600 1024x768 1280x1024
  ----+-------------------------------------
  256 | 0x301 0x303 0x305 0x307 8位色
  32k | 0x310 0x313 0x316 0x319 15位色
  64k | 0x311 0x314 0x317 0x31A 16位色
  16M | 0x312 0x315 0x318 0x31B 24位色
  To enable one of those modes you have to specify "vga=ask" in the
  lilo.conf file and rerun LILO. Then you can type in the desired
  mode at the "vga=ask" prompt. For example if you like to use 
  1024x768x256 colors you have to say "305" at this prompt.
  If this does not work, this might be because your BIOS does not support
  linear framebuffers or because it does not support this mode at all.
  Even if your board does, it might be the BIOS which does not. VESA BIOS
  Extensions v2.0 are required, 1.2 is NOT sufficient. You will get a
  "bad mode number" message if something goes wrong.
  1. Note: LILO cannot handle hex, for booting directly with 
  "vga=mode-number" you have to transform the numbers to decimal.
  2. Note: Some newer versions of LILO appear to work with those hex values,
  if you set the 0x in front of the numbers.
  本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/songbohr/archive/2010/03/25/5415637.aspx

• 这两天拾起以前做过的Framebuffer，不相同的是以前在嵌入式上做的，现在在自己电脑上Debian上进行测试，不过都类似罢了，嵌入式里要初始化很多东西。下面具体列一下步骤。至于Framebuffer的原理，就我的理解是比较简单的，无非往mmap好的fb上填写显示数据罢了，不对这些数据进行处理，FrameBuffer 只是一个提供显示内存和显示芯片寄存器从物理内存映射到进程地址空间中的设备，它需要真正的显卡驱动的支持。在这次测试中，我用了默认就安装的vesafb，好像又被称为万能Fb驱动。

  1、   首先在系统Grub启动时按e进入命令启动行的编辑模式，改为：kernel /boot/vmlinuz-2.6.18-5-686 root=/dev/sda6 ro vga=791（vga=791表示fb用1024 * 768 * 16bpp，其他模式的参数可以上网查查）；

  2、   进入系统的命令行模式，编译fb测试例子：gcc fb_test.c；

  3、   允许测试例子：sudo ./a.out >> fb.txt（必须要用超级用户权限，>>将屏幕打印写到fb.txt中），效果如下：

  

  打印如下：

  Fixed screen info:
      id: VESA VGA
      smem_start: 0xf0000000
      smem_len: 3145728
      type: 0
      type_aux: 0
      visual: 2
      xpanstep: 0
      ypanstep: 0
      ywrapstep: 0
      line_length: 2048
      mmio_start: 0x0
      mmio_len: 0
      accel: 0
  
  Variable screen info:
      xres: 1024
      yres: 768
      xres_virtual: 1024
      yres_virtual: 768
      yoffset: 0
      xoffset: 0
      bits_per_pixel: 16
      grayscale: 0
      red: offset: 11, length: 5, msb_right: 0
      green: offset: 5, length: 6, msb_right: 0
      blue: offset: 0, length: 5, msb_right: 0
      transp: offset: 0, length: 0, msb_right: 0
      nonstd: 0
      activate: 0
      height: -1
       -1
      accel_flags: 0x0
      pixclock: 12714
      left_margin: 128
      right_margin: 32
      upper_margin: 16
      lower_margin: 4
      hsync_len: 128
      vsync_len: 4
      sync: 0
      vmode: 0
  
  Frame Buffer Performance test...
          Average: 2508 usecs
          Band 1196.172 MByte/Sec
          Max. FPS: 398.724 fps

  4、还可以通过fb在命令行模式下看视频，如：sudo mplayer –vo fbdev ./air_nessesity.mpg。

  1. #include <stdlib.h>
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <fcntl.h>
  5. #include <linux/fb.h>
  6. #include <linux/kd.h>
  7. #include <sys/mman.h>
  8. #include <sys/ioctl.h>
  9. #include <sys/time.h>
  10. #include <string.h>
  11. #include <errno.h>
  13. struct fb_var_screeninfo vinfo;
  14. struct fb_fix_screeninfo finfo;
  15. char *frameBuffer = 0;
  17. //打印fb驱动中fix结构信息，注：在fb驱动加载后，fix结构不可被修改。
  18. void
  19. printFixedInfo ()
  20. {
  21.     printf ("Fixed screen info: "
  22.             " id: %s "
  23.             " smem_start: 0x%lx "
  24.             " smem_len: %d "
  25.             " type: %d "
  26.             " type_aux: %d "
  27.             " visual: %d "
  28.             " xpanstep: %d "
  29.             " ypanstep: %d "
  30.             " ywrapstep: %d "
  31.             " line_length: %d "
  32.             " mmio_start: 0x%lx "
  33.             " mmio_len: %d "
  34.             " accel: %d "
  35.             " ",
  36.             finfo.id, finfo.smem_start, finfo.smem_len, finfo.type,
  37.             finfo.type_aux, finfo.visual, finfo.xpanstep, finfo.ypanstep,
  38.             finfo.ywrapstep, finfo.line_length, finfo.mmio_start,
  39.             finfo.mmio_len, finfo.accel);
  40. }
  42. //打印fb驱动中var结构信息，注：fb驱动加载后，var结构可根据实际需要被重置
  43. void
  44. printVariableInfo ()
  45. {
  46.     printf ("Variable screen info: "
  47.             " xres: %d "
  48.             " yres: %d "
  49.             " xres_virtual: %d "
  50.             " yres_virtual: %d "
  51.             " yoffset: %d "
  52.             " xoffset: %d "
  53.             " bits_per_pixel: %d "
  54.             " grayscale: %d "
  55.             " red: offset: %2d, length: %2d, msb_right: %2d "
  56.             " green: offset: %2d, length: %2d, msb_right: %2d "
  57.             " blue: offset: %2d, length: %2d, msb_right: %2d "
  58.             " transp: offset: %2d, length: %2d, msb_right: %2d "
  59.             " nonstd: %d "
  60.             " activate: %d "
  61.             " height: %d "
  62.             " %d "
  63.             " accel_flags: 0x%x "
  64.             " pixclock: %d "
  65.             " left_margin: %d "
  66.             " right_margin: %d "
  67.             " upper_margin: %d "
  68.             " lower_margin: %d "
  69.             " hsync_len: %d "
  70.             " vsync_len: %d "
  71.             " sync: %d "
  72.             " vmode: %d "
  73.             " ",
  74.             vinfo.xres, vinfo.yres, vinfo.xres_virtual, vinfo.yres_virtual,
  75.             vinfo.xoffset, vinfo.yoffset, vinfo.bits_per_pixel,
  76.             vinfo.grayscale, vinfo.red.offset, vinfo.red.length,
  77.             vinfo.red.msb_right, vinfo.green.offset, vinfo.green.length,
  78.             vinfo.green.msb_right, vinfo.blue.offset, vinfo.blue.length,
  79.             vinfo.blue.msb_right, vinfo.transp.offset, vinfo.transp.length,
  80.             vinfo.transp.msb_right, vinfo.nonstd, vinfo.activate,
  81.             vinfo.height, vinfo.width, vinfo.accel_flags, vinfo.pixclock,
  82.             vinfo.left_margin, vinfo.right_margin, vinfo.upper_margin,
  83.             vinfo.lower_margin, vinfo.hsync_len, vinfo.vsync_len,
  84.             vinfo.sync, vinfo.vmode);
  85. }
  87. //画大小为width*height的同色矩阵，8alpha+8reds+8greens+8blues
  88. void
  89. drawRect_rgb32 (int x0, int y0, int width, int height, int color)
  90. {
  91.     const int bytesPerPixel = 4;
  92.     const int stride = finfo.line_length / bytesPerPixel;
  94.     int *dest = (int *) (frameBuffer)
  95.         + (y0 + vinfo.yoffset) * stride + (x0 + vinfo.xoffset);
  97.     int x, y;
  98.     for (y = 0; y < height; ++y)
  99.     {
  100.         for (x = 0; x < width; ++x)
  101.         {
  102.             dest[x] = color;
  103.         }
  104.         dest += stride;
  105.     }
  106. }
  108. //画大小为width*height的同色矩阵，5reds+6greens+5blues
  109. void
  110. drawRect_rgb16 (int x0, int y0, int width, int height, int color)
  111. {
  112.     const int bytesPerPixel = 2;
  113.     const int stride = finfo.line_length / bytesPerPixel;
  114.     const int red = (color & 0xff0000) >> (16 + 3);
  115.     const int green = (color & 0xff00) >> (8 + 2);
  116.     const int blue = (color & 0xff) >> 3;
  117.     const short color16 = blue | (green << 5) | (red << (5 + 6));
  119.     short *dest = (short *) (frameBuffer)
  120.         + (y0 + vinfo.yoffset) * stride + (x0 + vinfo.xoffset);
  122.     int x, y;
  123.     for (y = 0; y < height; ++y)
  124.     {
  125.         for (x = 0; x < width; ++x)
  126.         {
  127.             dest[x] = color16;
  128.         }
  129.         dest += stride;
  130.     }
  131. }
  133. //画大小为width*height的同色矩阵，5reds+5greens+5blues
  134. void
  135. drawRect_rgb15 (int x0, int y0, int width, int height, int color)
  136. {
  137.     const int bytesPerPixel = 2;
  138.     const int stride = finfo.line_length / bytesPerPixel;
  139.     const int red = (color & 0xff0000) >> (16 + 3);
  140.     const int green = (color & 0xff00) >> (8 + 3);
  141.     const int blue = (color & 0xff) >> 3;
  142.     const short color15 = blue | (green << 5) | (red << (5 + 5)) | 0x8000;
  144.     short *dest = (short *) (frameBuffer)
  145.         + (y0 + vinfo.yoffset) * stride + (x0 + vinfo.xoffset);
  147.     int x, y;
  148.     for (y = 0; y < height; ++y)
  149.     {
  150.         for (x = 0; x < width; ++x)
  151.         {
  152.             dest[x] = color15;
  153.         }
  154.         dest += stride;
  155.     }
  156. }
  158. void
  159. drawRect (int x0, int y0, int width, int height, int color)
  160. {
  161.     switch (vinfo.bits_per_pixel)
  162.     {
  163.     case 32:
  164.         drawRect_rgb32 (x0, y0, width, height, color);
  165.         break;
  166.     case 16:
  167.         drawRect_rgb16 (x0, y0, width, height, color);
  168.         break;
  169.     case 15:
  170.         drawRect_rgb15 (x0, y0, width, height, color);
  171.         break;
  172.     default:
  173.         printf ("Warning: drawRect() not implemented for color depth %i ",
  174.                 vinfo.bits_per_pixel);
  175.         break;
  176.     }
  177. }
  179. #define PERFORMANCE_RUN_COUNT 5
  180. void
  181. performSpeedTest (void *fb, int fbSize)
  182. {
  183.     int i, j, run;
  184.     struct timeval startTime, endTime;
  185.     unsigned long long results[PERFORMANCE_RUN_COUNT];
  186.     unsigned long long average;
  187.     unsigned int *testImage;
  189.     unsigned int randData[17] = {
  190.         0x3A428472, 0x724B84D3, 0x26B898AB, 0x7D980E3C, 0x5345A084,
  191.         0x6779B66B, 0x791EE4B4, 0x6E8EE3CC, 0x63AF504A, 0x18A21B33,
  192.         0x0E26EB73, 0x022F708E, 0x1740F3B0, 0x7E2C699D, 0x0E8A570B,
  193.         0x5F2C22FB, 0x6A742130
  194.     };
  196.     printf ("Frame Buffer Performance test... ");
  197.     for (run = 0; run < PERFORMANCE_RUN_COUNT; ++run)
  198.     {
  199.         /* Generate test image with random(ish) data: */
  200.         testImage = (unsigned int *) malloc (fbSize);
  201.         j = run;
  202.         for (i = 0; i < (int) (fbSize / sizeof (int)); ++i)
  203.         {
  204.             testImage[i] = randData[j];
  205.             j++;
  206.             if (j >= 17)
  207.                 j = 0;
  208.         }
  210.         gettimeofday (&startTime, NULL);
  211.         memcpy (fb, testImage, fbSize);
  212.         gettimeofday (&endTime, NULL);
  214.         long secsDiff = endTime.tv_sec - startTime.tv_sec;
  215.         results[run] =
  216.             secsDiff * 1000000 + (endTime.tv_usec - startTime.tv_usec);
  218.         free (testImage);
  219.     }
  221.     average = 0;
  222.     for (i = 0; i < PERFORMANCE_RUN_COUNT; ++i)
  223.         average += results[i];
  224.     average = average / PERFORMANCE_RUN_COUNT;
  226.     printf (" Average: %llu usecs ", average);
  227.     printf (" Band %.03f MByte/Sec ",
  228.             (fbSize / 1048576.0) / ((double) average / 1000000.0));
  229.     printf (" Max. FPS: %.03f fps ",
  230.             1000000.0 / (double) average);
  232.     /* Clear the framebuffer back to black again: */
  233.     memset (fb, 0, fbSize);
  234. }
  236. int
  237. main (int argc, char **argv)
  238. {
  239.     const char *devfile = "/dev/fb0";
  240.     long int screensize = 0;
  241.     int fbFd = 0;
  244.     /* Open the file for reading and writing */
  245.     fbFd = open (devfile, O_RDWR);
  246.     if (fbFd == -1)
  247.     {
  248.         perror ("Error: cannot open framebuffer device");
  249.         exit (1);
  250.     }
  252.     //获取finfo信息并显示
  253.     if (ioctl (fbFd, FBIOGET_FSCREENINFO, &finfo) == -1)
  254.     {
  255.         perror ("Error reading fixed information");
  256.         exit (2);
  257.     }
  258.     printFixedInfo ();
  259.     //获取vinfo信息并显示
  260.     if (ioctl (fbFd, FBIOGET_VSCREENINFO, &vinfo) == -1)
  261.     {
  262.         perror ("Error reading variable information");
  263.         exit (3);
  264.     }
  265.     printVariableInfo ();
  267.     /* Figure out the size of the screen in bytes */
  268.     screensize = finfo.smem_len;
  270.     /* Map the device to memory */
  271.     frameBuffer =
  272.         (char *) mmap (0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED,
  273.                      fbFd, 0);
  274.     if (frameBuffer == MAP_FAILED)
  275.     {
  276.         perror ("Error: Failed to map framebuffer device to memory");
  277.         exit (4);
  278.     }
  280.     //测试virt fb的性能
  281.     performSpeedTest (frameBuffer, screensize);
  283.     printf ("Will draw 3 rectangles on the screen, "
  284.             "they should be colored red, green and blue (in that order). ");
  285.     drawRect (vinfo.xres / 8, vinfo.yres / 8,
  286.              vinfo.xres / 4, vinfo.yres / 4, 0xffff0000);
  287.     drawRect (vinfo.xres * 3 / 8, vinfo.yres * 3 / 8,
  288.              vinfo.xres / 4, vinfo.yres / 4, 0xff00ff00);
  289.     drawRect (vinfo.xres * 5 / 8, vinfo.yres * 5 / 8,
  290.              vinfo.xres / 4, vinfo.yres / 4, 0xff0000ff);
  292.     sleep (5);
  293.     printf (" Done. ");
  295.     munmap (frameBuffer, screensize);    //解除内存映射，与mmap对应
  297.     close (fbFd);
  298.     return 0;
  299. }
  复制代码

 

顶

0

踩