merge mainline into ofwfb
This commit is contained in:
Vladimir 'phcoder' Serbinenko
commit
e190e3d2cc
63 changed files with 7613 additions and 183 deletions
308
video/bitmap_scale.c
Normal file
308
video/bitmap_scale.c
Normal file
|
|
@ -0,0 +1,308 @@
|
|||
/* bitmap_scale.c - Bitmap scaling. */
|
||||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc.
|
||||
*
|
||||
* GRUB is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* GRUB is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <grub/mm.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/video.h>
|
||||
#include <grub/bitmap.h>
|
||||
#include <grub/bitmap_scale.h>
|
||||
#include <grub/types.h>
|
||||
|
||||
/* Prototypes for module-local functions. */
|
||||
static grub_err_t scale_nn (struct grub_video_bitmap *dst,
|
||||
struct grub_video_bitmap *src);
|
||||
static grub_err_t scale_bilinear (struct grub_video_bitmap *dst,
|
||||
struct grub_video_bitmap *src);
|
||||
|
||||
/* This function creates a new scaled version of the bitmap SRC. The new
|
||||
bitmap has dimensions DST_WIDTH by DST_HEIGHT. The scaling algorithm
|
||||
is given by SCALE_METHOD. If an error is encountered, the return code is
|
||||
not equal to GRUB_ERR_NONE, and the bitmap DST is either not created, or
|
||||
it is destroyed before this function returns.
|
||||
|
||||
Supports only direct color modes which have components separated
|
||||
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
|
||||
But because of this simplifying assumption, the implementation is
|
||||
greatly simplified. */
|
||||
grub_err_t
|
||||
grub_video_bitmap_create_scaled (struct grub_video_bitmap **dst,
|
||||
int dst_width, int dst_height,
|
||||
struct grub_video_bitmap *src,
|
||||
enum grub_video_bitmap_scale_method
|
||||
scale_method)
|
||||
{
|
||||
*dst = 0;
|
||||
|
||||
/* Verify the simplifying assumptions. */
|
||||
if (src == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"null src bitmap in grub_video_bitmap_create_scaled");
|
||||
if (src->mode_info.red_field_pos % 8 != 0
|
||||
|| src->mode_info.green_field_pos % 8 != 0
|
||||
|| src->mode_info.blue_field_pos % 8 != 0
|
||||
|| src->mode_info.reserved_field_pos % 8 != 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"src format not supported for scale");
|
||||
if (src->mode_info.width == 0 || src->mode_info.height == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"source bitmap has a zero dimension");
|
||||
if (dst_width <= 0 || dst_height <= 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"requested to scale to a size w/ a zero dimension");
|
||||
if (src->mode_info.bytes_per_pixel * 8 != src->mode_info.bpp)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"bitmap to scale has inconsistent Bpp and bpp");
|
||||
|
||||
/* Create the new bitmap. */
|
||||
grub_err_t ret;
|
||||
ret = grub_video_bitmap_create (dst, dst_width, dst_height,
|
||||
src->mode_info.blit_format);
|
||||
if (ret != GRUB_ERR_NONE)
|
||||
return ret; /* Error. */
|
||||
|
||||
switch (scale_method)
|
||||
{
|
||||
case GRUB_VIDEO_BITMAP_SCALE_METHOD_FASTEST:
|
||||
case GRUB_VIDEO_BITMAP_SCALE_METHOD_NEAREST:
|
||||
ret = scale_nn (*dst, src);
|
||||
break;
|
||||
case GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST:
|
||||
case GRUB_VIDEO_BITMAP_SCALE_METHOD_BILINEAR:
|
||||
ret = scale_bilinear (*dst, src);
|
||||
break;
|
||||
default:
|
||||
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid scale_method value");
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret == GRUB_ERR_NONE)
|
||||
{
|
||||
/* Success: *dst is now a pointer to the scaled bitmap. */
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Destroy the bitmap and return the error code. */
|
||||
grub_video_bitmap_destroy (*dst);
|
||||
*dst = 0;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
/* Nearest neighbor bitmap scaling algorithm.
|
||||
|
||||
Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the
|
||||
dimensions of DST. This function uses the nearest neighbor algorithm to
|
||||
interpolate the pixels.
|
||||
|
||||
Supports only direct color modes which have components separated
|
||||
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
|
||||
But because of this simplifying assumption, the implementation is
|
||||
greatly simplified. */
|
||||
static grub_err_t
|
||||
scale_nn (struct grub_video_bitmap *dst, struct grub_video_bitmap *src)
|
||||
{
|
||||
/* Verify the simplifying assumptions. */
|
||||
if (dst == 0 || src == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "null bitmap in scale_nn");
|
||||
if (dst->mode_info.red_field_pos % 8 != 0
|
||||
|| dst->mode_info.green_field_pos % 8 != 0
|
||||
|| dst->mode_info.blue_field_pos % 8 != 0
|
||||
|| dst->mode_info.reserved_field_pos % 8 != 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst format not supported");
|
||||
if (src->mode_info.red_field_pos % 8 != 0
|
||||
|| src->mode_info.green_field_pos % 8 != 0
|
||||
|| src->mode_info.blue_field_pos % 8 != 0
|
||||
|| src->mode_info.reserved_field_pos % 8 != 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported");
|
||||
if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos
|
||||
|| dst->mode_info.red_mask_size != src->mode_info.red_mask_size
|
||||
|| dst->mode_info.green_field_pos != src->mode_info.green_field_pos
|
||||
|| dst->mode_info.green_mask_size != src->mode_info.green_mask_size
|
||||
|| dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos
|
||||
|| dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size
|
||||
|| dst->mode_info.reserved_field_pos !=
|
||||
src->mode_info.reserved_field_pos
|
||||
|| dst->mode_info.reserved_mask_size !=
|
||||
src->mode_info.reserved_mask_size)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
|
||||
if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
|
||||
if (dst->mode_info.width == 0 || dst->mode_info.height == 0
|
||||
|| src->mode_info.width == 0 || src->mode_info.height == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap has a zero dimension");
|
||||
|
||||
grub_uint8_t *ddata = dst->data;
|
||||
grub_uint8_t *sdata = src->data;
|
||||
int dw = dst->mode_info.width;
|
||||
int dh = dst->mode_info.height;
|
||||
int sw = src->mode_info.width;
|
||||
int sh = src->mode_info.height;
|
||||
int dstride = dst->mode_info.pitch;
|
||||
int sstride = src->mode_info.pitch;
|
||||
/* bytes_per_pixel is the same for both src and dst. */
|
||||
int bytes_per_pixel = dst->mode_info.bytes_per_pixel;
|
||||
|
||||
int dy;
|
||||
for (dy = 0; dy < dh; dy++)
|
||||
{
|
||||
int dx;
|
||||
for (dx = 0; dx < dw; dx++)
|
||||
{
|
||||
grub_uint8_t *dptr;
|
||||
grub_uint8_t *sptr;
|
||||
int sx;
|
||||
int sy;
|
||||
int comp;
|
||||
|
||||
/* Compute the source coordinate that the destination coordinate
|
||||
maps to. Note: sx/sw = dx/dw => sx = sw*dx/dw. */
|
||||
sx = sw * dx / dw;
|
||||
sy = sh * dy / dh;
|
||||
|
||||
/* Get the address of the pixels in src and dst. */
|
||||
dptr = ddata + dy * dstride + dx * bytes_per_pixel;
|
||||
sptr = sdata + sy * sstride + sx * bytes_per_pixel;
|
||||
|
||||
/* Copy the pixel color value. */
|
||||
for (comp = 0; comp < bytes_per_pixel; comp++)
|
||||
dptr[comp] = sptr[comp];
|
||||
}
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Bilinear interpolation image scaling algorithm.
|
||||
|
||||
Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the
|
||||
dimensions of DST. This function uses the bilinear interpolation algorithm
|
||||
to interpolate the pixels.
|
||||
|
||||
Supports only direct color modes which have components separated
|
||||
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
|
||||
But because of this simplifying assumption, the implementation is
|
||||
greatly simplified. */
|
||||
static grub_err_t
|
||||
scale_bilinear (struct grub_video_bitmap *dst, struct grub_video_bitmap *src)
|
||||
{
|
||||
/* Verify the simplifying assumptions. */
|
||||
if (dst == 0 || src == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "null bitmap in scale func");
|
||||
if (dst->mode_info.red_field_pos % 8 != 0
|
||||
|| dst->mode_info.green_field_pos % 8 != 0
|
||||
|| dst->mode_info.blue_field_pos % 8 != 0
|
||||
|| dst->mode_info.reserved_field_pos % 8 != 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst format not supported");
|
||||
if (src->mode_info.red_field_pos % 8 != 0
|
||||
|| src->mode_info.green_field_pos % 8 != 0
|
||||
|| src->mode_info.blue_field_pos % 8 != 0
|
||||
|| src->mode_info.reserved_field_pos % 8 != 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported");
|
||||
if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos
|
||||
|| dst->mode_info.red_mask_size != src->mode_info.red_mask_size
|
||||
|| dst->mode_info.green_field_pos != src->mode_info.green_field_pos
|
||||
|| dst->mode_info.green_mask_size != src->mode_info.green_mask_size
|
||||
|| dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos
|
||||
|| dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size
|
||||
|| dst->mode_info.reserved_field_pos !=
|
||||
src->mode_info.reserved_field_pos
|
||||
|| dst->mode_info.reserved_mask_size !=
|
||||
src->mode_info.reserved_mask_size)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
|
||||
if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
|
||||
if (dst->mode_info.width == 0 || dst->mode_info.height == 0
|
||||
|| src->mode_info.width == 0 || src->mode_info.height == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap has a zero dimension");
|
||||
|
||||
grub_uint8_t *ddata = dst->data;
|
||||
grub_uint8_t *sdata = src->data;
|
||||
int dw = dst->mode_info.width;
|
||||
int dh = dst->mode_info.height;
|
||||
int sw = src->mode_info.width;
|
||||
int sh = src->mode_info.height;
|
||||
int dstride = dst->mode_info.pitch;
|
||||
int sstride = src->mode_info.pitch;
|
||||
/* bytes_per_pixel is the same for both src and dst. */
|
||||
int bytes_per_pixel = dst->mode_info.bytes_per_pixel;
|
||||
|
||||
int dy;
|
||||
for (dy = 0; dy < dh; dy++)
|
||||
{
|
||||
int dx;
|
||||
for (dx = 0; dx < dw; dx++)
|
||||
{
|
||||
grub_uint8_t *dptr;
|
||||
grub_uint8_t *sptr;
|
||||
int sx;
|
||||
int sy;
|
||||
int comp;
|
||||
|
||||
/* Compute the source coordinate that the destination coordinate
|
||||
maps to. Note: sx/sw = dx/dw => sx = sw*dx/dw. */
|
||||
sx = sw * dx / dw;
|
||||
sy = sh * dy / dh;
|
||||
|
||||
/* Get the address of the pixels in src and dst. */
|
||||
dptr = ddata + dy * dstride + dx * bytes_per_pixel;
|
||||
sptr = sdata + sy * sstride + sx * bytes_per_pixel;
|
||||
|
||||
/* If we have enough space to do so, use bilinear interpolation.
|
||||
Otherwise, fall back to nearest neighbor for this pixel. */
|
||||
if (sx < sw - 1 && sy < sh - 1)
|
||||
{
|
||||
/* Do bilinear interpolation. */
|
||||
|
||||
/* Fixed-point .8 numbers representing the fraction of the
|
||||
distance in the x (u) and y (v) direction within the
|
||||
box of 4 pixels in the source. */
|
||||
int u = (256 * sw * dx / dw) - (sx * 256);
|
||||
int v = (256 * sh * dy / dh) - (sy * 256);
|
||||
|
||||
for (comp = 0; comp < bytes_per_pixel; comp++)
|
||||
{
|
||||
/* Get the component's values for the
|
||||
four source corner pixels. */
|
||||
grub_uint8_t f00 = sptr[comp];
|
||||
grub_uint8_t f10 = sptr[comp + bytes_per_pixel];
|
||||
grub_uint8_t f01 = sptr[comp + sstride];
|
||||
grub_uint8_t f11 = sptr[comp + sstride + bytes_per_pixel];
|
||||
|
||||
/* Do linear interpolations along the top and bottom
|
||||
rows of the box. */
|
||||
grub_uint8_t f0y = (256 - v) * f00 / 256 + v * f01 / 256;
|
||||
grub_uint8_t f1y = (256 - v) * f10 / 256 + v * f11 / 256;
|
||||
|
||||
/* Interpolate vertically. */
|
||||
grub_uint8_t fxy = (256 - u) * f0y / 256 + u * f1y / 256;
|
||||
|
||||
dptr[comp] = fxy;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Fall back to nearest neighbor interpolation. */
|
||||
/* Copy the pixel color value. */
|
||||
for (comp = 0; comp < bytes_per_pixel; comp++)
|
||||
dptr[comp] = sptr[comp];
|
||||
}
|
||||
}
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
|
@ -66,6 +66,8 @@ grub_video_fb_init (void)
|
|||
grub_err_t
|
||||
grub_video_fb_fini (void)
|
||||
{
|
||||
/* TODO: destroy render targets. */
|
||||
|
||||
grub_free (palette);
|
||||
render_target = 0;
|
||||
palette = 0;
|
||||
|
|
@ -1233,3 +1235,53 @@ grub_video_fb_get_active_render_target (struct grub_video_fbrender_target **targ
|
|||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
doublebuf_blit_update_screen (struct grub_video_fbrender_target *front,
|
||||
struct grub_video_fbrender_target *back)
|
||||
{
|
||||
grub_memcpy (front->data, back->data,
|
||||
front->mode_info.pitch * front->mode_info.height);
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_video_fb_doublebuf_blit_init (struct grub_video_fbrender_target **front,
|
||||
struct grub_video_fbrender_target **back,
|
||||
grub_video_fb_doublebuf_update_screen_t *update_screen,
|
||||
struct grub_video_mode_info mode_info,
|
||||
void *framebuf)
|
||||
{
|
||||
grub_err_t err;
|
||||
int page_size = mode_info.pitch * mode_info.height;
|
||||
void *offscreen_buffer;
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (front, &mode_info,
|
||||
framebuf);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
offscreen_buffer = grub_malloc (page_size);
|
||||
if (! offscreen_buffer)
|
||||
{
|
||||
grub_video_fb_delete_render_target (*front);
|
||||
*front = 0;
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (back, &mode_info,
|
||||
offscreen_buffer);
|
||||
|
||||
if (err)
|
||||
{
|
||||
grub_video_fb_delete_render_target (*front);
|
||||
grub_free (offscreen_buffer);
|
||||
*front = 0;
|
||||
return grub_errno;
|
||||
}
|
||||
(*back)->is_allocated = 1;
|
||||
|
||||
*update_screen = doublebuf_blit_update_screen;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,13 +39,25 @@ static grub_uint32_t last_set_mode = 3;
|
|||
static struct
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
struct grub_video_render_target *render_target;
|
||||
struct grub_video_render_target *front_target;
|
||||
struct grub_video_render_target *back_target;
|
||||
|
||||
unsigned int bytes_per_scan_line;
|
||||
unsigned int bytes_per_pixel;
|
||||
grub_uint32_t active_vbe_mode;
|
||||
grub_uint8_t *ptr;
|
||||
int index_color_mode;
|
||||
|
||||
char *offscreen_buffer;
|
||||
|
||||
grub_size_t page_size; /* The size of a page in bytes. */
|
||||
|
||||
/* For page flipping strategy. */
|
||||
int displayed_page; /* The page # that is the front buffer. */
|
||||
int render_page; /* The page # that is the back buffer. */
|
||||
|
||||
/* Virtual functions. */
|
||||
grub_video_fb_doublebuf_update_screen_t update_screen;
|
||||
} framebuffer;
|
||||
|
||||
static grub_uint32_t initial_vbe_mode;
|
||||
|
|
@ -350,6 +362,7 @@ static grub_err_t
|
|||
grub_video_vbe_fini (void)
|
||||
{
|
||||
grub_vbe_status_t status;
|
||||
grub_err_t err;
|
||||
|
||||
/* Restore old video mode. */
|
||||
status = grub_vbe_bios_set_mode (initial_vbe_mode, 0);
|
||||
|
|
@ -362,11 +375,190 @@ grub_video_vbe_fini (void)
|
|||
grub_free (vbe_mode_list);
|
||||
vbe_mode_list = NULL;
|
||||
|
||||
/* TODO: destroy render targets. */
|
||||
|
||||
return grub_video_fb_fini ();
|
||||
err = grub_video_fb_fini ();
|
||||
grub_free (framebuffer.offscreen_buffer);
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
Set framebuffer render target page and display the proper page, based on
|
||||
`doublebuf_state.render_page' and `doublebuf_state.displayed_page',
|
||||
respectively.
|
||||
*/
|
||||
static grub_err_t
|
||||
doublebuf_pageflipping_commit (void)
|
||||
{
|
||||
/* Tell the video adapter to display the new front page. */
|
||||
int display_start_line
|
||||
= framebuffer.mode_info.height * framebuffer.displayed_page;
|
||||
|
||||
grub_vbe_status_t vbe_err =
|
||||
grub_vbe_bios_set_display_start (0, display_start_line);
|
||||
|
||||
if (vbe_err != GRUB_VBE_STATUS_OK)
|
||||
return grub_error (GRUB_ERR_IO, "couldn't commit pageflip");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
doublebuf_pageflipping_update_screen (struct grub_video_fbrender_target *front
|
||||
__attribute__ ((unused)),
|
||||
struct grub_video_fbrender_target *back
|
||||
__attribute__ ((unused)))
|
||||
{
|
||||
int new_displayed_page;
|
||||
struct grub_video_fbrender_target *target;
|
||||
grub_err_t err;
|
||||
|
||||
/* Swap the page numbers in the framebuffer struct. */
|
||||
new_displayed_page = framebuffer.render_page;
|
||||
framebuffer.render_page = framebuffer.displayed_page;
|
||||
framebuffer.displayed_page = new_displayed_page;
|
||||
|
||||
err = doublebuf_pageflipping_commit ();
|
||||
if (err)
|
||||
{
|
||||
/* Restore previous state. */
|
||||
framebuffer.render_page = framebuffer.displayed_page;
|
||||
framebuffer.displayed_page = new_displayed_page;
|
||||
return err;
|
||||
}
|
||||
|
||||
if (framebuffer.mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP)
|
||||
grub_memcpy (framebuffer.ptr + framebuffer.render_page
|
||||
* framebuffer.page_size, framebuffer.ptr
|
||||
+ framebuffer.displayed_page * framebuffer.page_size,
|
||||
framebuffer.page_size);
|
||||
|
||||
target = framebuffer.back_target;
|
||||
framebuffer.back_target = framebuffer.front_target;
|
||||
framebuffer.front_target = target;
|
||||
|
||||
err = grub_video_fb_get_active_render_target (&target);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (target == framebuffer.back_target)
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.front_target);
|
||||
else if (target == framebuffer.front_target)
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.back_target);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
doublebuf_pageflipping_init (void)
|
||||
{
|
||||
/* Get video RAM size in bytes. */
|
||||
grub_size_t vram_size = controller_info.total_memory << 16;
|
||||
grub_err_t err;
|
||||
|
||||
framebuffer.page_size =
|
||||
framebuffer.mode_info.pitch * framebuffer.mode_info.height;
|
||||
|
||||
if (2 * framebuffer.page_size > vram_size)
|
||||
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
|
||||
"Not enough video memory for double buffering.");
|
||||
|
||||
framebuffer.displayed_page = 0;
|
||||
framebuffer.render_page = 1;
|
||||
|
||||
framebuffer.update_screen = doublebuf_pageflipping_update_screen;
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (&framebuffer.front_target, &framebuffer.mode_info, framebuffer.ptr);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (&framebuffer.back_target, &framebuffer.mode_info, framebuffer.ptr + framebuffer.page_size);
|
||||
if (err)
|
||||
{
|
||||
grub_video_fb_delete_render_target (framebuffer.front_target);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Set the framebuffer memory data pointer and display the right page. */
|
||||
err = doublebuf_pageflipping_commit ();
|
||||
if (err)
|
||||
{
|
||||
grub_video_fb_delete_render_target (framebuffer.front_target);
|
||||
grub_video_fb_delete_render_target (framebuffer.back_target);
|
||||
return err;
|
||||
}
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Select the best double buffering mode available. */
|
||||
static grub_err_t
|
||||
double_buffering_init (unsigned int mode_type, unsigned int mode_mask)
|
||||
{
|
||||
grub_err_t err;
|
||||
int updating_swap_needed;
|
||||
|
||||
updating_swap_needed
|
||||
= grub_video_check_mode_flag (mode_type, mode_mask,
|
||||
GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP, 0);
|
||||
|
||||
/* Do double buffering only if it's either requested or efficient. */
|
||||
if (grub_video_check_mode_flag (mode_type, mode_mask,
|
||||
GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED,
|
||||
!updating_swap_needed))
|
||||
{
|
||||
framebuffer.mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED;
|
||||
if (updating_swap_needed)
|
||||
framebuffer.mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP;
|
||||
err = doublebuf_pageflipping_init ();
|
||||
if (!err)
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
framebuffer.mode_info.mode_type
|
||||
&= ~(GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED
|
||||
| GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP);
|
||||
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
if (grub_video_check_mode_flag (mode_type, mode_mask,
|
||||
GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED,
|
||||
0))
|
||||
{
|
||||
framebuffer.mode_info.mode_type
|
||||
|= (GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED
|
||||
| GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP);
|
||||
|
||||
err = grub_video_fb_doublebuf_blit_init (&framebuffer.front_target,
|
||||
&framebuffer.back_target,
|
||||
&framebuffer.update_screen,
|
||||
framebuffer.mode_info,
|
||||
framebuffer.ptr);
|
||||
|
||||
if (!err)
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
framebuffer.mode_info.mode_type
|
||||
&= ~(GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED
|
||||
| GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP);
|
||||
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Fall back to no double buffering. */
|
||||
err = grub_video_fb_create_render_target_from_pointer (&framebuffer.front_target, &framebuffer.mode_info, framebuffer.ptr);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
framebuffer.back_target = framebuffer.front_target;
|
||||
framebuffer.update_screen = 0;
|
||||
|
||||
framebuffer.mode_info.mode_type &= ~GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static grub_err_t
|
||||
grub_video_vbe_setup (unsigned int width, unsigned int height,
|
||||
unsigned int mode_type, unsigned int mode_mask)
|
||||
|
|
@ -491,12 +683,12 @@ grub_video_vbe_setup (unsigned int width, unsigned int height,
|
|||
|
||||
framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (&framebuffer.render_target, &framebuffer.mode_info, framebuffer.ptr);
|
||||
|
||||
/* Set up double buffering and targets. */
|
||||
err = double_buffering_init (mode_type, mode_mask);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.back_target);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
|
@ -533,7 +725,15 @@ grub_video_vbe_set_palette (unsigned int start, unsigned int count,
|
|||
static grub_err_t
|
||||
grub_video_vbe_swap_buffers (void)
|
||||
{
|
||||
/* TODO: Implement buffer swapping. */
|
||||
grub_err_t err;
|
||||
if (!framebuffer.update_screen)
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
err = framebuffer.update_screen (framebuffer.front_target,
|
||||
framebuffer.back_target);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
|
|
@ -541,27 +741,42 @@ static grub_err_t
|
|||
grub_video_vbe_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
|
||||
target = framebuffer.render_target;
|
||||
target = framebuffer.back_target;
|
||||
|
||||
return grub_video_fb_set_active_render_target (target);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_vbe_get_active_render_target (struct grub_video_render_target **target)
|
||||
{
|
||||
grub_err_t err;
|
||||
err = grub_video_fb_get_active_render_target (target);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (*target == framebuffer.back_target)
|
||||
*target = GRUB_VIDEO_RENDER_TARGET_DISPLAY;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_vbe_get_info_and_fini (struct grub_video_mode_info *mode_info,
|
||||
void **framebuf)
|
||||
{
|
||||
grub_memcpy (mode_info, &(framebuffer.mode_info), sizeof (*mode_info));
|
||||
*framebuf = (char *) framebuffer.ptr;
|
||||
*framebuf = (char *) framebuffer.ptr
|
||||
+ framebuffer.displayed_page * framebuffer.page_size;
|
||||
|
||||
grub_free (vbe_mode_list);
|
||||
vbe_mode_list = NULL;
|
||||
|
||||
grub_video_fb_fini ();
|
||||
grub_free (framebuffer.offscreen_buffer);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
|
||||
static struct grub_video_adapter grub_video_vbe_adapter =
|
||||
{
|
||||
.name = "VESA BIOS Extension Video Driver",
|
||||
|
|
@ -588,7 +803,7 @@ static struct grub_video_adapter grub_video_vbe_adapter =
|
|||
.create_render_target = grub_video_fb_create_render_target,
|
||||
.delete_render_target = grub_video_fb_delete_render_target,
|
||||
.set_active_render_target = grub_video_vbe_set_active_render_target,
|
||||
.get_active_render_target = grub_video_fb_get_active_render_target,
|
||||
.get_active_render_target = grub_video_vbe_get_active_render_target,
|
||||
|
||||
.next = 0
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue