首页 > 代码库 > Framebuffer的配置及应用——先转载留着，以后一定要弄懂

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

2024-08-29 22:53:38   221人阅读

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
        width: -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
            Bandwidth: 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:\n"
    22.             "\tid: %s\n"
    23.             "\tsmem_start: 0x%lx\n"
    24.             "\tsmem_len: %d\n"
    25.             "\ttype: %d\n"
    26.             "\ttype_aux: %d\n"
    27.             "\tvisual: %d\n"
    28.             "\txpanstep: %d\n"
    29.             "\typanstep: %d\n"
    30.             "\tywrapstep: %d\n"
    31.             "\tline_length: %d\n"
    32.             "\tmmio_start: 0x%lx\n"
    33.             "\tmmio_len: %d\n"
    34.             "\taccel: %d\n"
    35.             "\n",
    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:\n"
    47.             "\txres: %d\n"
    48.             "\tyres: %d\n"
    49.             "\txres_virtual: %d\n"
    50.             "\tyres_virtual: %d\n"
    51.             "\tyoffset: %d\n"
    52.             "\txoffset: %d\n"
    53.             "\tbits_per_pixel: %d\n"
    54.             "\tgrayscale: %d\n"
    55.             "\tred: offset: %2d, length: %2d, msb_right: %2d\n"
    56.             "\tgreen: offset: %2d, length: %2d, msb_right: %2d\n"
    57.             "\tblue: offset: %2d, length: %2d, msb_right: %2d\n"
    58.             "\ttransp: offset: %2d, length: %2d, msb_right: %2d\n"
    59.             "\tnonstd: %d\n"
    60.             "\tactivate: %d\n"
    61.             "\theight: %d\n"
    62.             "\twidth: %d\n"
    63.             "\taccel_flags: 0x%x\n"
    64.             "\tpixclock: %d\n"
    65.             "\tleft_margin: %d\n"
    66.             "\tright_margin: %d\n"
    67.             "\tupper_margin: %d\n"
    68.             "\tlower_margin: %d\n"
    69.             "\thsync_len: %d\n"
    70.             "\tvsync_len: %d\n"
    71.             "\tsync: %d\n"
    72.             "\tvmode: %d\n"
    73.             "\n",
    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\n",
    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...\n");
    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\n", average);
    227.     printf (" Bandwidth: %.03f MByte/Sec\n",
    228.             (fbSize / 1048576.0) / ((double) average / 1000000.0));
    229.     printf (" Max. FPS: %.03f fps\n\n",
    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,\n"
    284.             "they should be colored red, green and blue (in that order).\n");
    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.\n");
    295.     munmap (frameBuffer, screensize);    //解除内存映射，与mmap对应
    297.     close (fbFd);
    298.     return 0;
    299. }
    复制代码
 
顶
0
踩

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


联系
我们