automake commit without merge history
This commit is contained in:
parent
265d68cd10
commit
8c41176882
810 changed files with 4980 additions and 2508 deletions
253
grub-core/video/bitmap.c
Normal file
253
grub-core/video/bitmap.c
Normal file
|
@ -0,0 +1,253 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2006,2007 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/video.h>
|
||||
#include <grub/bitmap.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/misc.h>
|
||||
|
||||
/* List of bitmap readers registered to system. */
|
||||
static grub_video_bitmap_reader_t bitmap_readers_list;
|
||||
|
||||
/* Register bitmap reader. */
|
||||
void
|
||||
grub_video_bitmap_reader_register (grub_video_bitmap_reader_t reader)
|
||||
{
|
||||
reader->next = bitmap_readers_list;
|
||||
bitmap_readers_list = reader;
|
||||
}
|
||||
|
||||
/* Unregister bitmap reader. */
|
||||
void
|
||||
grub_video_bitmap_reader_unregister (grub_video_bitmap_reader_t reader)
|
||||
{
|
||||
grub_video_bitmap_reader_t *p, q;
|
||||
|
||||
for (p = &bitmap_readers_list, q = *p; q; p = &(q->next), q = q->next)
|
||||
if (q == reader)
|
||||
{
|
||||
*p = q->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Creates new bitmap, saves created bitmap on success to *bitmap. */
|
||||
grub_err_t
|
||||
grub_video_bitmap_create (struct grub_video_bitmap **bitmap,
|
||||
unsigned int width, unsigned int height,
|
||||
enum grub_video_blit_format blit_format)
|
||||
{
|
||||
struct grub_video_mode_info *mode_info;
|
||||
unsigned int size;
|
||||
|
||||
if (!bitmap)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
|
||||
|
||||
*bitmap = 0;
|
||||
|
||||
if (width == 0 || height == 0)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
|
||||
|
||||
*bitmap = (struct grub_video_bitmap *)grub_malloc (sizeof (struct grub_video_bitmap));
|
||||
if (! *bitmap)
|
||||
return grub_errno;
|
||||
|
||||
mode_info = &((*bitmap)->mode_info);
|
||||
|
||||
/* Populate mode_info. */
|
||||
mode_info->width = width;
|
||||
mode_info->height = height;
|
||||
mode_info->blit_format = blit_format;
|
||||
|
||||
switch (blit_format)
|
||||
{
|
||||
case GRUB_VIDEO_BLIT_FORMAT_RGBA_8888:
|
||||
mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_RGB
|
||||
| GRUB_VIDEO_MODE_TYPE_ALPHA;
|
||||
mode_info->bpp = 32;
|
||||
mode_info->bytes_per_pixel = 4;
|
||||
mode_info->number_of_colors = 256;
|
||||
mode_info->red_mask_size = 8;
|
||||
mode_info->red_field_pos = 0;
|
||||
mode_info->green_mask_size = 8;
|
||||
mode_info->green_field_pos = 8;
|
||||
mode_info->blue_mask_size = 8;
|
||||
mode_info->blue_field_pos = 16;
|
||||
mode_info->reserved_mask_size = 8;
|
||||
mode_info->reserved_field_pos = 24;
|
||||
break;
|
||||
|
||||
case GRUB_VIDEO_BLIT_FORMAT_RGB_888:
|
||||
mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
mode_info->bpp = 24;
|
||||
mode_info->bytes_per_pixel = 3;
|
||||
mode_info->number_of_colors = 256;
|
||||
mode_info->red_mask_size = 8;
|
||||
mode_info->red_field_pos = 0;
|
||||
mode_info->green_mask_size = 8;
|
||||
mode_info->green_field_pos = 8;
|
||||
mode_info->blue_mask_size = 8;
|
||||
mode_info->blue_field_pos = 16;
|
||||
mode_info->reserved_mask_size = 0;
|
||||
mode_info->reserved_field_pos = 0;
|
||||
break;
|
||||
|
||||
case GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR:
|
||||
mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
|
||||
mode_info->bpp = 8;
|
||||
mode_info->bytes_per_pixel = 1;
|
||||
mode_info->number_of_colors = 256;
|
||||
mode_info->red_mask_size = 0;
|
||||
mode_info->red_field_pos = 0;
|
||||
mode_info->green_mask_size = 0;
|
||||
mode_info->green_field_pos = 0;
|
||||
mode_info->blue_mask_size = 0;
|
||||
mode_info->blue_field_pos = 0;
|
||||
mode_info->reserved_mask_size = 0;
|
||||
mode_info->reserved_field_pos = 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
grub_free (*bitmap);
|
||||
*bitmap = 0;
|
||||
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"unsupported bitmap format");
|
||||
}
|
||||
|
||||
mode_info->pitch = width * mode_info->bytes_per_pixel;
|
||||
|
||||
/* Calculate size needed for the data. */
|
||||
size = (width * mode_info->bytes_per_pixel) * height;
|
||||
|
||||
(*bitmap)->data = grub_zalloc (size);
|
||||
if (! (*bitmap)->data)
|
||||
{
|
||||
grub_free (*bitmap);
|
||||
*bitmap = 0;
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Frees all resources allocated by bitmap. */
|
||||
grub_err_t
|
||||
grub_video_bitmap_destroy (struct grub_video_bitmap *bitmap)
|
||||
{
|
||||
if (! bitmap)
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
grub_free (bitmap->data);
|
||||
grub_free (bitmap);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Match extension to filename. */
|
||||
static int
|
||||
match_extension (const char *filename, const char *ext)
|
||||
{
|
||||
int pos;
|
||||
int ext_len;
|
||||
|
||||
pos = grub_strlen (filename);
|
||||
ext_len = grub_strlen (ext);
|
||||
|
||||
if (! pos || ! ext_len || ext_len > pos)
|
||||
return 0;
|
||||
|
||||
pos -= ext_len;
|
||||
|
||||
return grub_strcmp (filename + pos, ext) == 0;
|
||||
}
|
||||
|
||||
/* Loads bitmap using registered bitmap readers. */
|
||||
grub_err_t
|
||||
grub_video_bitmap_load (struct grub_video_bitmap **bitmap,
|
||||
const char *filename)
|
||||
{
|
||||
grub_video_bitmap_reader_t reader = bitmap_readers_list;
|
||||
|
||||
if (!bitmap)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
|
||||
|
||||
*bitmap = 0;
|
||||
|
||||
while (reader)
|
||||
{
|
||||
if (match_extension (filename, reader->extension))
|
||||
return reader->reader (bitmap, filename);
|
||||
|
||||
reader = reader->next;
|
||||
}
|
||||
|
||||
return grub_error(GRUB_ERR_BAD_FILE_TYPE, "unsupported bitmap format");
|
||||
}
|
||||
|
||||
/* Return bitmap width. */
|
||||
unsigned int
|
||||
grub_video_bitmap_get_width (struct grub_video_bitmap *bitmap)
|
||||
{
|
||||
if (!bitmap)
|
||||
return 0;
|
||||
|
||||
return bitmap->mode_info.width;
|
||||
}
|
||||
|
||||
/* Return bitmap height. */
|
||||
unsigned int
|
||||
grub_video_bitmap_get_height (struct grub_video_bitmap *bitmap)
|
||||
{
|
||||
if (!bitmap)
|
||||
return 0;
|
||||
|
||||
return bitmap->mode_info.height;
|
||||
}
|
||||
|
||||
/* Return mode info for bitmap. */
|
||||
void grub_video_bitmap_get_mode_info (struct grub_video_bitmap *bitmap,
|
||||
struct grub_video_mode_info *mode_info)
|
||||
{
|
||||
if (!bitmap)
|
||||
return;
|
||||
|
||||
*mode_info = bitmap->mode_info;
|
||||
}
|
||||
|
||||
/* Return pointer to bitmap's raw data. */
|
||||
void *grub_video_bitmap_get_data (struct grub_video_bitmap *bitmap)
|
||||
{
|
||||
if (!bitmap)
|
||||
return 0;
|
||||
|
||||
return bitmap->data;
|
||||
}
|
||||
|
||||
/* Initialize bitmap module. */
|
||||
GRUB_MOD_INIT(bitmap)
|
||||
{
|
||||
}
|
||||
|
||||
/* Finalize bitmap module. */
|
||||
GRUB_MOD_FINI(bitmap)
|
||||
{
|
||||
}
|
308
grub-core/video/bitmap_scale.c
Normal file
308
grub-core/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;
|
||||
}
|
399
grub-core/video/efi_gop.c
Normal file
399
grub-core/video/efi_gop.c
Normal file
|
@ -0,0 +1,399 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2005,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/>.
|
||||
*/
|
||||
|
||||
#define grub_video_render_target grub_video_fbrender_target
|
||||
|
||||
#include <grub/err.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/video.h>
|
||||
#include <grub/video_fb.h>
|
||||
#include <grub/efi/api.h>
|
||||
#include <grub/efi/efi.h>
|
||||
#include <grub/efi/graphics_output.h>
|
||||
|
||||
static grub_efi_guid_t graphics_output_guid = GRUB_EFI_GOP_GUID;
|
||||
static struct grub_efi_gop *gop;
|
||||
static unsigned old_mode;
|
||||
static int restore_needed;
|
||||
|
||||
static struct
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
struct grub_video_render_target *render_target;
|
||||
grub_uint8_t *ptr;
|
||||
} framebuffer;
|
||||
|
||||
|
||||
static int
|
||||
check_protocol (void)
|
||||
{
|
||||
gop = grub_efi_locate_protocol (&graphics_output_guid, 0);
|
||||
if (gop)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_init (void)
|
||||
{
|
||||
grub_memset (&framebuffer, 0, sizeof(framebuffer));
|
||||
return grub_video_fb_init ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_fini (void)
|
||||
{
|
||||
if (restore_needed)
|
||||
{
|
||||
efi_call_2 (gop->set_mode, gop, old_mode);
|
||||
restore_needed = 0;
|
||||
}
|
||||
return grub_video_fb_fini ();
|
||||
}
|
||||
|
||||
static int
|
||||
grub_video_gop_get_bpp (struct grub_efi_gop_mode_info *in)
|
||||
{
|
||||
grub_uint32_t total_mask;
|
||||
int i;
|
||||
switch (in->pixel_format)
|
||||
{
|
||||
case GRUB_EFI_GOT_BGRA8:
|
||||
case GRUB_EFI_GOT_RGBA8:
|
||||
return 32;
|
||||
|
||||
case GRUB_EFI_GOT_BITMASK:
|
||||
/* Check overlaps. */
|
||||
if ((in->pixel_bitmask.r & in->pixel_bitmask.g)
|
||||
|| (in->pixel_bitmask.r & in->pixel_bitmask.b)
|
||||
|| (in->pixel_bitmask.g & in->pixel_bitmask.b)
|
||||
|| (in->pixel_bitmask.r & in->pixel_bitmask.a)
|
||||
|| (in->pixel_bitmask.g & in->pixel_bitmask.a)
|
||||
|| (in->pixel_bitmask.b & in->pixel_bitmask.a))
|
||||
return 0;
|
||||
|
||||
total_mask = in->pixel_bitmask.r | in->pixel_bitmask.g
|
||||
| in->pixel_bitmask.b | in->pixel_bitmask.a;
|
||||
|
||||
for (i = 31; i >= 0; i--)
|
||||
if (total_mask & (1 << i))
|
||||
return i + 1;
|
||||
|
||||
/* Fall through. */
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
grub_video_gop_get_bitmask (grub_uint32_t mask, unsigned int *mask_size,
|
||||
unsigned int *field_pos)
|
||||
{
|
||||
int i;
|
||||
int last_p;
|
||||
for (i = 31; i >= 0; i--)
|
||||
if (mask & (1 << i))
|
||||
break;
|
||||
if (i == -1)
|
||||
{
|
||||
*mask_size = *field_pos = 0;
|
||||
return;
|
||||
}
|
||||
last_p = i;
|
||||
for (; i >= 0; i--)
|
||||
if (!(mask & (1 << i)))
|
||||
break;
|
||||
*field_pos = i + 1;
|
||||
*mask_size = last_p - *field_pos + 1;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_fill_mode_info (struct grub_efi_gop_mode_info *in,
|
||||
struct grub_video_mode_info *out)
|
||||
{
|
||||
out->number_of_colors = 256;
|
||||
out->width = in->width;
|
||||
out->height = in->height;
|
||||
out->mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
out->bpp = grub_video_gop_get_bpp (in);
|
||||
out->bytes_per_pixel = out->bpp >> 3;
|
||||
if (!out->bpp)
|
||||
return grub_error (GRUB_ERR_IO, "unsupported video mode");
|
||||
out->pitch = in->pixels_per_scanline * out->bytes_per_pixel;
|
||||
|
||||
switch (in->pixel_format)
|
||||
{
|
||||
case GRUB_EFI_GOT_RGBA8:
|
||||
out->red_mask_size = 8;
|
||||
out->red_field_pos = 0;
|
||||
out->green_mask_size = 8;
|
||||
out->green_field_pos = 8;
|
||||
out->blue_mask_size = 8;
|
||||
out->blue_field_pos = 16;
|
||||
out->reserved_mask_size = 8;
|
||||
out->reserved_field_pos = 24;
|
||||
break;
|
||||
|
||||
case GRUB_EFI_GOT_BGRA8:
|
||||
out->red_mask_size = 8;
|
||||
out->red_field_pos = 16;
|
||||
out->green_mask_size = 8;
|
||||
out->green_field_pos = 8;
|
||||
out->blue_mask_size = 8;
|
||||
out->blue_field_pos = 0;
|
||||
out->reserved_mask_size = 8;
|
||||
out->reserved_field_pos = 24;
|
||||
break;
|
||||
|
||||
case GRUB_EFI_GOT_BITMASK:
|
||||
grub_video_gop_get_bitmask (in->pixel_bitmask.r, &out->red_mask_size,
|
||||
&out->red_field_pos);
|
||||
grub_video_gop_get_bitmask (in->pixel_bitmask.g, &out->green_mask_size,
|
||||
&out->green_field_pos);
|
||||
grub_video_gop_get_bitmask (in->pixel_bitmask.b, &out->blue_mask_size,
|
||||
&out->blue_field_pos);
|
||||
grub_video_gop_get_bitmask (in->pixel_bitmask.a, &out->reserved_mask_size,
|
||||
&out->reserved_field_pos);
|
||||
break;
|
||||
|
||||
default:
|
||||
return grub_error (GRUB_ERR_IO, "unsupported video mode");
|
||||
}
|
||||
|
||||
out->blit_format = grub_video_get_blit_format (out);
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_setup (unsigned int width, unsigned int height,
|
||||
unsigned int mode_type, unsigned int mode_mask __attribute__ ((unused)))
|
||||
{
|
||||
unsigned int depth;
|
||||
struct grub_efi_gop_mode_info *info = NULL;
|
||||
unsigned best_mode = 0;
|
||||
grub_err_t err;
|
||||
unsigned bpp;
|
||||
int found = 0;
|
||||
unsigned long long best_volume = 0;
|
||||
|
||||
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
|
||||
|
||||
/* Keep current mode if possible. */
|
||||
if (gop->mode->info)
|
||||
{
|
||||
bpp = grub_video_gop_get_bpp (gop->mode->info);
|
||||
if (bpp && ((width == gop->mode->info->width
|
||||
&& height == gop->mode->info->height)
|
||||
|| (width == 0 && height == 0))
|
||||
&& (depth == bpp || depth == 0))
|
||||
{
|
||||
grub_dprintf ("video", "GOP: keeping mode %d\n", gop->mode->mode);
|
||||
best_mode = gop->mode->mode;
|
||||
found = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
{
|
||||
unsigned mode;
|
||||
grub_dprintf ("video", "GOP: %d modes detected\n", gop->mode->max_mode);
|
||||
for (mode = 0; mode < gop->mode->max_mode; mode++)
|
||||
{
|
||||
grub_efi_uintn_t size;
|
||||
grub_efi_status_t status;
|
||||
|
||||
status = efi_call_4 (gop->query_mode, gop, mode, &size, &info);
|
||||
if (status)
|
||||
{
|
||||
info = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
grub_dprintf ("video", "GOP: mode %d: %dx%d\n", mode, info->width,
|
||||
info->height);
|
||||
|
||||
bpp = grub_video_gop_get_bpp (info);
|
||||
if (!bpp)
|
||||
{
|
||||
grub_dprintf ("video", "GOP: mode %d: incompatible pixel mode\n",
|
||||
mode);
|
||||
continue;
|
||||
}
|
||||
|
||||
grub_dprintf ("video", "GOP: mode %d: depth %d\n", mode, bpp);
|
||||
|
||||
if (!(((info->width == width && info->height == height)
|
||||
|| (width == 0 && height == 0))
|
||||
&& (bpp == depth || depth == 0)))
|
||||
{
|
||||
grub_dprintf ("video", "GOP: mode %d: rejected\n", mode);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (best_volume < ((unsigned long long) info->width)
|
||||
* ((unsigned long long) info->height)
|
||||
* ((unsigned long long) bpp))
|
||||
{
|
||||
best_volume = ((unsigned long long) info->width)
|
||||
* ((unsigned long long) info->height)
|
||||
* ((unsigned long long) bpp);
|
||||
best_mode = mode;
|
||||
}
|
||||
found = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
{
|
||||
grub_dprintf ("video", "GOP: no mode found\n");
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
|
||||
}
|
||||
|
||||
if (best_mode != gop->mode->mode)
|
||||
{
|
||||
if (!restore_needed)
|
||||
{
|
||||
old_mode = gop->mode->mode;
|
||||
restore_needed = 1;
|
||||
}
|
||||
efi_call_2 (gop->set_mode, gop, best_mode);
|
||||
}
|
||||
|
||||
info = gop->mode->info;
|
||||
|
||||
err = grub_video_gop_fill_mode_info (info, &framebuffer.mode_info);
|
||||
if (err)
|
||||
{
|
||||
grub_dprintf ("video", "GOP: couldn't fill mode info\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
framebuffer.ptr = (void *) (grub_addr_t) gop->mode->fb_base;
|
||||
|
||||
grub_dprintf ("video", "GOP: initialising FB @ %p %dx%dx%d\n",
|
||||
framebuffer.ptr, framebuffer.mode_info.width,
|
||||
framebuffer.mode_info.height, framebuffer.mode_info.bpp);
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer
|
||||
(&framebuffer.render_target, &framebuffer.mode_info, framebuffer.ptr);
|
||||
|
||||
if (err)
|
||||
{
|
||||
grub_dprintf ("video", "GOP: Couldn't create FB target\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
|
||||
|
||||
if (err)
|
||||
{
|
||||
grub_dprintf ("video", "GOP: Couldn't set FB target\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
|
||||
if (err)
|
||||
grub_dprintf ("video", "GOP: Couldn't set palette\n");
|
||||
else
|
||||
grub_dprintf ("video", "GOP: Success\n");
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_swap_buffers (void)
|
||||
{
|
||||
/* TODO: Implement buffer swapping. */
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
|
||||
target = framebuffer.render_target;
|
||||
|
||||
return grub_video_fb_set_active_render_target (target);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_gop_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;
|
||||
|
||||
grub_video_fb_fini ();
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static struct grub_video_adapter grub_video_gop_adapter =
|
||||
{
|
||||
.name = "EFI GOP driver",
|
||||
.id = GRUB_VIDEO_DRIVER_EFI_GOP,
|
||||
|
||||
.init = grub_video_gop_init,
|
||||
.fini = grub_video_gop_fini,
|
||||
.setup = grub_video_gop_setup,
|
||||
.get_info = grub_video_fb_get_info,
|
||||
.get_info_and_fini = grub_video_gop_get_info_and_fini,
|
||||
.set_palette = grub_video_fb_set_palette,
|
||||
.get_palette = grub_video_fb_get_palette,
|
||||
.set_viewport = grub_video_fb_set_viewport,
|
||||
.get_viewport = grub_video_fb_get_viewport,
|
||||
.map_color = grub_video_fb_map_color,
|
||||
.map_rgb = grub_video_fb_map_rgb,
|
||||
.map_rgba = grub_video_fb_map_rgba,
|
||||
.unmap_color = grub_video_fb_unmap_color,
|
||||
.fill_rect = grub_video_fb_fill_rect,
|
||||
.blit_bitmap = grub_video_fb_blit_bitmap,
|
||||
.blit_render_target = grub_video_fb_blit_render_target,
|
||||
.scroll = grub_video_fb_scroll,
|
||||
.swap_buffers = grub_video_gop_swap_buffers,
|
||||
.create_render_target = grub_video_fb_create_render_target,
|
||||
.delete_render_target = grub_video_fb_delete_render_target,
|
||||
.set_active_render_target = grub_video_gop_set_active_render_target,
|
||||
.get_active_render_target = grub_video_fb_get_active_render_target,
|
||||
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(efi_gop)
|
||||
{
|
||||
if (check_protocol ())
|
||||
grub_video_register (&grub_video_gop_adapter);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(efi_gop)
|
||||
{
|
||||
if (restore_needed)
|
||||
{
|
||||
efi_call_2 (gop->set_mode, gop, old_mode);
|
||||
restore_needed = 0;
|
||||
}
|
||||
if (gop)
|
||||
grub_video_unregister (&grub_video_gop_adapter);
|
||||
}
|
339
grub-core/video/efi_uga.c
Normal file
339
grub-core/video/efi_uga.c
Normal file
|
@ -0,0 +1,339 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2005,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/>.
|
||||
*/
|
||||
|
||||
#define grub_video_render_target grub_video_fbrender_target
|
||||
|
||||
#include <grub/err.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/video.h>
|
||||
#include <grub/video_fb.h>
|
||||
#include <grub/efi/api.h>
|
||||
#include <grub/efi/efi.h>
|
||||
#include <grub/efi/uga_draw.h>
|
||||
#include <grub/pci.h>
|
||||
|
||||
static grub_efi_guid_t uga_draw_guid = GRUB_EFI_UGA_DRAW_GUID;
|
||||
static struct grub_efi_uga_draw_protocol *uga;
|
||||
static grub_uint32_t uga_fb;
|
||||
static grub_uint32_t uga_pitch;
|
||||
|
||||
static struct
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
struct grub_video_render_target *render_target;
|
||||
grub_uint8_t *ptr;
|
||||
} framebuffer;
|
||||
|
||||
#define RGB_MASK 0xffffff
|
||||
#define RGB_MAGIC 0x121314
|
||||
#define LINE_MIN 800
|
||||
#define LINE_MAX 4096
|
||||
#define FBTEST_STEP (0x10000 >> 2)
|
||||
#define FBTEST_COUNT 8
|
||||
|
||||
static int
|
||||
find_line_len (grub_uint32_t *fb_base, grub_uint32_t *line_len)
|
||||
{
|
||||
grub_uint32_t *base = (grub_uint32_t *) (grub_target_addr_t) *fb_base;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < FBTEST_COUNT; i++, base += FBTEST_STEP)
|
||||
{
|
||||
if ((*base & RGB_MASK) == RGB_MAGIC)
|
||||
{
|
||||
int j;
|
||||
|
||||
for (j = LINE_MIN; j <= LINE_MAX; j++)
|
||||
{
|
||||
if ((base[j] & RGB_MASK) == RGB_MAGIC)
|
||||
{
|
||||
*fb_base = (grub_uint32_t) (grub_target_addr_t) base;
|
||||
*line_len = j << 2;
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
find_framebuf (grub_uint32_t *fb_base, grub_uint32_t *line_len)
|
||||
{
|
||||
int found = 0;
|
||||
|
||||
auto int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev,
|
||||
grub_pci_id_t pciid);
|
||||
|
||||
int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev,
|
||||
grub_pci_id_t pciid)
|
||||
{
|
||||
grub_pci_address_t addr;
|
||||
|
||||
addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
|
||||
if (grub_pci_read (addr) >> 24 == 0x3)
|
||||
{
|
||||
int i;
|
||||
|
||||
grub_dprintf ("fb", "Display controller: %d:%d.%d\nDevice id: %x\n",
|
||||
grub_pci_get_bus (dev), grub_pci_get_device (dev),
|
||||
grub_pci_get_function (dev), pciid);
|
||||
addr += 8;
|
||||
for (i = 0; i < 6; i++, addr += 4)
|
||||
{
|
||||
grub_uint32_t old_bar1, old_bar2, type;
|
||||
grub_uint64_t base64;
|
||||
|
||||
old_bar1 = grub_pci_read (addr);
|
||||
if ((! old_bar1) || (old_bar1 & GRUB_PCI_ADDR_SPACE_IO))
|
||||
continue;
|
||||
|
||||
type = old_bar1 & GRUB_PCI_ADDR_MEM_TYPE_MASK;
|
||||
if (type == GRUB_PCI_ADDR_MEM_TYPE_64)
|
||||
{
|
||||
if (i == 5)
|
||||
break;
|
||||
|
||||
old_bar2 = grub_pci_read (addr + 4);
|
||||
}
|
||||
else
|
||||
old_bar2 = 0;
|
||||
|
||||
base64 = old_bar2;
|
||||
base64 <<= 32;
|
||||
base64 |= (old_bar1 & GRUB_PCI_ADDR_MEM_MASK);
|
||||
|
||||
grub_dprintf ("fb", "%s(%d): 0x%llx\n",
|
||||
((old_bar1 & GRUB_PCI_ADDR_MEM_PREFETCH) ?
|
||||
"VMEM" : "MMIO"), i,
|
||||
(unsigned long long) base64);
|
||||
|
||||
if ((old_bar1 & GRUB_PCI_ADDR_MEM_PREFETCH) && (! found))
|
||||
{
|
||||
*fb_base = base64;
|
||||
if (find_line_len (fb_base, line_len))
|
||||
found++;
|
||||
}
|
||||
|
||||
if (type == GRUB_PCI_ADDR_MEM_TYPE_64)
|
||||
{
|
||||
i++;
|
||||
addr += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
grub_pci_iterate (find_card);
|
||||
return found;
|
||||
}
|
||||
|
||||
static int
|
||||
check_protocol (void)
|
||||
{
|
||||
grub_efi_uga_draw_protocol_t *c;
|
||||
|
||||
c = grub_efi_locate_protocol (&uga_draw_guid, 0);
|
||||
if (c)
|
||||
{
|
||||
grub_uint32_t width, height, depth, rate, pixel;
|
||||
int ret;
|
||||
|
||||
if (efi_call_5 (c->get_mode, c, &width, &height, &depth, &rate))
|
||||
return 0;
|
||||
|
||||
grub_efi_set_text_mode (0);
|
||||
pixel = RGB_MAGIC;
|
||||
efi_call_10 (c->blt, c, (struct grub_efi_uga_pixel *) &pixel,
|
||||
GRUB_EFI_UGA_VIDEO_FILL, 0, 0, 0, 0, 1, height, 0);
|
||||
ret = find_framebuf (&uga_fb, &uga_pitch);
|
||||
grub_efi_set_text_mode (1);
|
||||
|
||||
if (ret)
|
||||
{
|
||||
uga = c;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_uga_init (void)
|
||||
{
|
||||
grub_memset (&framebuffer, 0, sizeof(framebuffer));
|
||||
return grub_video_fb_init ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_uga_fini (void)
|
||||
{
|
||||
return grub_video_fb_fini ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_uga_setup (unsigned int width, unsigned int height,
|
||||
unsigned int mode_type, unsigned int mode_mask __attribute__ ((unused)))
|
||||
{
|
||||
unsigned int depth;
|
||||
int found = 0;
|
||||
|
||||
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
|
||||
|
||||
{
|
||||
grub_uint32_t w;
|
||||
grub_uint32_t h;
|
||||
grub_uint32_t d;
|
||||
grub_uint32_t r;
|
||||
|
||||
if ((! efi_call_5 (uga->get_mode, uga, &w, &h, &d, &r)) &&
|
||||
((! width) || (width == w)) &&
|
||||
((! height) || (height == h)) &&
|
||||
((! depth) || (depth == d)))
|
||||
{
|
||||
framebuffer.mode_info.width = w;
|
||||
framebuffer.mode_info.height = h;
|
||||
framebuffer.mode_info.pitch = uga_pitch;
|
||||
framebuffer.ptr = (grub_uint8_t *) (grub_target_addr_t) uga_fb;
|
||||
|
||||
found = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (found)
|
||||
{
|
||||
grub_err_t err;
|
||||
|
||||
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
framebuffer.mode_info.bpp = 32;
|
||||
framebuffer.mode_info.bytes_per_pixel = 4;
|
||||
framebuffer.mode_info.number_of_colors = 256; /* TODO: fix me. */
|
||||
framebuffer.mode_info.red_mask_size = 8;
|
||||
framebuffer.mode_info.red_field_pos = 16;
|
||||
framebuffer.mode_info.green_mask_size = 8;
|
||||
framebuffer.mode_info.green_field_pos = 8;
|
||||
framebuffer.mode_info.blue_mask_size = 8;
|
||||
framebuffer.mode_info.blue_field_pos = 0;
|
||||
framebuffer.mode_info.reserved_mask_size = 8;
|
||||
framebuffer.mode_info.reserved_field_pos = 24;
|
||||
|
||||
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);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_video_fb_set_active_render_target
|
||||
(framebuffer.render_target);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_uga_swap_buffers (void)
|
||||
{
|
||||
/* TODO: Implement buffer swapping. */
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_uga_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
|
||||
target = framebuffer.render_target;
|
||||
|
||||
return grub_video_fb_set_active_render_target (target);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_uga_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;
|
||||
|
||||
grub_video_fb_fini ();
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static struct grub_video_adapter grub_video_uga_adapter =
|
||||
{
|
||||
.name = "EFI UGA driver",
|
||||
.id = GRUB_VIDEO_DRIVER_EFI_UGA,
|
||||
|
||||
.init = grub_video_uga_init,
|
||||
.fini = grub_video_uga_fini,
|
||||
.setup = grub_video_uga_setup,
|
||||
.get_info = grub_video_fb_get_info,
|
||||
.get_info_and_fini = grub_video_uga_get_info_and_fini,
|
||||
.set_palette = grub_video_fb_set_palette,
|
||||
.get_palette = grub_video_fb_get_palette,
|
||||
.set_viewport = grub_video_fb_set_viewport,
|
||||
.get_viewport = grub_video_fb_get_viewport,
|
||||
.map_color = grub_video_fb_map_color,
|
||||
.map_rgb = grub_video_fb_map_rgb,
|
||||
.map_rgba = grub_video_fb_map_rgba,
|
||||
.unmap_color = grub_video_fb_unmap_color,
|
||||
.fill_rect = grub_video_fb_fill_rect,
|
||||
.blit_bitmap = grub_video_fb_blit_bitmap,
|
||||
.blit_render_target = grub_video_fb_blit_render_target,
|
||||
.scroll = grub_video_fb_scroll,
|
||||
.swap_buffers = grub_video_uga_swap_buffers,
|
||||
.create_render_target = grub_video_fb_create_render_target,
|
||||
.delete_render_target = grub_video_fb_delete_render_target,
|
||||
.set_active_render_target = grub_video_uga_set_active_render_target,
|
||||
.get_active_render_target = grub_video_fb_get_active_render_target,
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(efi_uga)
|
||||
{
|
||||
if (check_protocol ())
|
||||
grub_video_register (&grub_video_uga_adapter);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(efi_uga)
|
||||
{
|
||||
if (uga)
|
||||
grub_video_unregister (&grub_video_uga_adapter);
|
||||
}
|
237
grub-core/video/emu/sdl.c
Normal file
237
grub-core/video/emu/sdl.c
Normal file
|
@ -0,0 +1,237 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2005,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/>.
|
||||
*/
|
||||
|
||||
#define grub_video_render_target grub_video_fbrender_target
|
||||
|
||||
#include <grub/err.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/video.h>
|
||||
#include <grub/video_fb.h>
|
||||
#include <SDL/SDL.h>
|
||||
|
||||
static SDL_Surface *window = 0;
|
||||
static struct grub_video_render_target *sdl_render_target;
|
||||
static struct grub_video_mode_info mode_info;
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data);
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_init (void)
|
||||
{
|
||||
window = 0;
|
||||
|
||||
if (SDL_Init (SDL_INIT_VIDEO) < 0)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "Couldn't init SDL: %s",
|
||||
SDL_GetError ());
|
||||
|
||||
grub_memset (&mode_info, 0, sizeof (mode_info));
|
||||
|
||||
return grub_video_fb_init ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_fini (void)
|
||||
{
|
||||
SDL_Quit ();
|
||||
window = 0;
|
||||
|
||||
grub_memset (&mode_info, 0, sizeof (mode_info));
|
||||
|
||||
return grub_video_fb_fini ();
|
||||
}
|
||||
|
||||
static inline unsigned int
|
||||
get_mask_size (grub_uint32_t mask)
|
||||
{
|
||||
unsigned i;
|
||||
for (i = 0; mask > 1U << i; i++);
|
||||
return i;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_setup (unsigned int width, unsigned int height,
|
||||
unsigned int mode_type, unsigned int mode_mask)
|
||||
{
|
||||
int depth;
|
||||
int flags = 0;
|
||||
grub_err_t err;
|
||||
|
||||
/* Decode depth from mode_type. If it is zero, then autodetect. */
|
||||
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
|
||||
|
||||
if (depth == 0)
|
||||
depth = 32;
|
||||
|
||||
if (width == 0 && height == 0)
|
||||
{
|
||||
width = 800;
|
||||
height = 600;
|
||||
}
|
||||
|
||||
if ((mode_type & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED)
|
||||
|| !(mode_mask & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED))
|
||||
flags |= SDL_DOUBLEBUF;
|
||||
|
||||
window = SDL_SetVideoMode (width, height, depth, flags | SDL_HWSURFACE);
|
||||
if (! window)
|
||||
window = SDL_SetVideoMode (width, height, depth, flags | SDL_SWSURFACE);
|
||||
if (! window)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "Couldn't open window: %s",
|
||||
SDL_GetError ());
|
||||
|
||||
grub_memset (&sdl_render_target, 0, sizeof (sdl_render_target));
|
||||
|
||||
mode_info.width = window->w;
|
||||
mode_info.height = window->h;
|
||||
mode_info.mode_type = 0;
|
||||
if (window->flags & SDL_DOUBLEBUF)
|
||||
mode_info.mode_type
|
||||
|= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED;
|
||||
if (window->format->palette)
|
||||
mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
|
||||
else
|
||||
mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
|
||||
mode_info.bpp = window->format->BitsPerPixel;
|
||||
mode_info.bytes_per_pixel = window->format->BytesPerPixel;
|
||||
mode_info.pitch = window->pitch;
|
||||
|
||||
/* In index color mode, number of colors. In RGB mode this is 256. */
|
||||
if (window->format->palette)
|
||||
mode_info.number_of_colors
|
||||
= 1 << window->format->BitsPerPixel;
|
||||
else
|
||||
mode_info.number_of_colors = 256;
|
||||
|
||||
if (! window->format->palette)
|
||||
{
|
||||
mode_info.red_mask_size
|
||||
= get_mask_size (window->format->Rmask >> window->format->Rshift);
|
||||
mode_info.red_field_pos = window->format->Rshift;
|
||||
mode_info.green_mask_size
|
||||
= get_mask_size (window->format->Gmask >> window->format->Gshift);
|
||||
mode_info.green_field_pos = window->format->Gshift;
|
||||
mode_info.blue_mask_size
|
||||
= get_mask_size (window->format->Bmask >> window->format->Bshift);
|
||||
mode_info.blue_field_pos = window->format->Bshift;
|
||||
mode_info.reserved_mask_size
|
||||
= get_mask_size (window->format->Amask >> window->format->Ashift);
|
||||
mode_info.reserved_field_pos = window->format->Ashift;
|
||||
mode_info.blit_format
|
||||
= grub_video_get_blit_format (&mode_info);
|
||||
}
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (&sdl_render_target,
|
||||
&mode_info,
|
||||
window->pixels);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Copy default palette to initialize emulated palette. */
|
||||
grub_video_sdl_set_palette (0, (sizeof (grub_video_fbstd_colors)
|
||||
/ sizeof (grub_video_fbstd_colors[0])),
|
||||
grub_video_fbstd_colors);
|
||||
|
||||
/* Reset render target to SDL one. */
|
||||
return grub_video_fb_set_active_render_target (sdl_render_target);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data)
|
||||
{
|
||||
unsigned i;
|
||||
if (window->format->palette)
|
||||
{
|
||||
SDL_Color *tmp = grub_malloc (count * sizeof (tmp[0]));
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
tmp[i].r = palette_data[i].r;
|
||||
tmp[i].g = palette_data[i].g;
|
||||
tmp[i].b = palette_data[i].b;
|
||||
tmp[i].unused = palette_data[i].a;
|
||||
}
|
||||
SDL_SetColors (window, tmp, start, count);
|
||||
grub_free (tmp);
|
||||
}
|
||||
|
||||
return grub_video_fb_set_palette (start, count, palette_data);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_swap_buffers (void)
|
||||
{
|
||||
if (SDL_Flip (window) < 0)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "couldn't swap buffers: %s",
|
||||
SDL_GetError ());
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sdl_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
|
||||
return grub_video_fb_set_active_render_target (sdl_render_target);
|
||||
|
||||
return grub_video_fb_set_active_render_target (target);
|
||||
}
|
||||
|
||||
static struct grub_video_adapter grub_video_sdl_adapter =
|
||||
{
|
||||
.name = "SDL Video Driver",
|
||||
|
||||
.init = grub_video_sdl_init,
|
||||
.fini = grub_video_sdl_fini,
|
||||
.setup = grub_video_sdl_setup,
|
||||
.get_info = grub_video_fb_get_info,
|
||||
.set_palette = grub_video_sdl_set_palette,
|
||||
.get_palette = grub_video_fb_get_palette,
|
||||
.set_viewport = grub_video_fb_set_viewport,
|
||||
.get_viewport = grub_video_fb_get_viewport,
|
||||
.map_color = grub_video_fb_map_color,
|
||||
.map_rgb = grub_video_fb_map_rgb,
|
||||
.map_rgba = grub_video_fb_map_rgba,
|
||||
.unmap_color = grub_video_fb_unmap_color,
|
||||
.fill_rect = grub_video_fb_fill_rect,
|
||||
.blit_bitmap = grub_video_fb_blit_bitmap,
|
||||
.blit_render_target = grub_video_fb_blit_render_target,
|
||||
.scroll = grub_video_fb_scroll,
|
||||
.swap_buffers = grub_video_sdl_swap_buffers,
|
||||
.create_render_target = grub_video_fb_create_render_target,
|
||||
.delete_render_target = grub_video_fb_delete_render_target,
|
||||
.set_active_render_target = grub_video_sdl_set_active_render_target,
|
||||
.get_active_render_target = grub_video_fb_get_active_render_target,
|
||||
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(sdl)
|
||||
{
|
||||
grub_video_register (&grub_video_sdl_adapter);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(sdl)
|
||||
{
|
||||
grub_video_unregister (&grub_video_sdl_adapter);
|
||||
}
|
1420
grub-core/video/fb/fbblit.c
Normal file
1420
grub-core/video/fb/fbblit.c
Normal file
File diff suppressed because it is too large
Load diff
177
grub-core/video/fb/fbfill.c
Normal file
177
grub-core/video/fb/fbfill.c
Normal file
|
@ -0,0 +1,177 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2006,2007,2008 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/>.
|
||||
*/
|
||||
|
||||
/* SPECIAL NOTES!
|
||||
|
||||
Please note following when reading the code below:
|
||||
|
||||
- In this driver we assume that every memory can be accessed by same memory
|
||||
bus. If there are different address spaces do not use this code as a base
|
||||
code for other archs.
|
||||
|
||||
- Every function in this code assumes that bounds checking has been done in
|
||||
previous phase and they are opted out in here. */
|
||||
|
||||
#include <grub/video_fb.h>
|
||||
#include <grub/fbfill.h>
|
||||
#include <grub/fbutil.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/video.h>
|
||||
|
||||
/* Generic filler that works for every supported mode. */
|
||||
void
|
||||
grub_video_fbfill (struct grub_video_fbblit_info *dst,
|
||||
grub_video_color_t color, int x, int y,
|
||||
int width, int height)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < height; j++)
|
||||
for (i = 0; i < width; i++)
|
||||
set_pixel (dst, x + i, y + j, color);
|
||||
}
|
||||
|
||||
/* Optimized filler for direct color 32 bit modes. It is assumed that color
|
||||
is already mapped to destination format. */
|
||||
void
|
||||
grub_video_fbfill_direct32 (struct grub_video_fbblit_info *dst,
|
||||
grub_video_color_t color, int x, int y,
|
||||
int width, int height)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
grub_uint32_t *dstptr;
|
||||
grub_size_t rowskip;
|
||||
|
||||
/* Calculate the number of bytes to advance from the end of one line
|
||||
to the beginning of the next line. */
|
||||
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
|
||||
|
||||
/* Get the start address. */
|
||||
dstptr = (grub_uint32_t *) grub_video_fb_get_video_ptr (dst, x, y);
|
||||
|
||||
for (j = 0; j < height; j++)
|
||||
{
|
||||
for (i = 0; i < width; i++)
|
||||
*dstptr++ = color;
|
||||
|
||||
/* Advance the dest pointer to the right location on the next line. */
|
||||
dstptr = (grub_uint32_t *) (((char *) dstptr) + rowskip);
|
||||
}
|
||||
}
|
||||
|
||||
/* Optimized filler for direct color 24 bit modes. It is assumed that color
|
||||
is already mapped to destination format. */
|
||||
void
|
||||
grub_video_fbfill_direct24 (struct grub_video_fbblit_info *dst,
|
||||
grub_video_color_t color, int x, int y,
|
||||
int width, int height)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
grub_size_t rowskip;
|
||||
grub_uint8_t *dstptr;
|
||||
grub_uint8_t fill0 = (grub_uint8_t)((color >> 0) & 0xFF);
|
||||
grub_uint8_t fill1 = (grub_uint8_t)((color >> 8) & 0xFF);
|
||||
grub_uint8_t fill2 = (grub_uint8_t)((color >> 16) & 0xFF);
|
||||
|
||||
/* Calculate the number of bytes to advance from the end of one line
|
||||
to the beginning of the next line. */
|
||||
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
|
||||
|
||||
/* Get the start address. */
|
||||
dstptr = (grub_uint8_t *) grub_video_fb_get_video_ptr (dst, x, y);
|
||||
|
||||
for (j = 0; j < height; j++)
|
||||
{
|
||||
for (i = 0; i < width; i++)
|
||||
{
|
||||
*dstptr++ = fill0;
|
||||
*dstptr++ = fill1;
|
||||
*dstptr++ = fill2;
|
||||
}
|
||||
|
||||
/* Advance the dest pointer to the right location on the next line. */
|
||||
dstptr += rowskip;
|
||||
}
|
||||
}
|
||||
|
||||
/* Optimized filler for direct color 16 bit modes. It is assumed that color
|
||||
is already mapped to destination format. */
|
||||
void
|
||||
grub_video_fbfill_direct16 (struct grub_video_fbblit_info *dst,
|
||||
grub_video_color_t color, int x, int y,
|
||||
int width, int height)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
grub_size_t rowskip;
|
||||
grub_uint8_t *dstptr;
|
||||
grub_uint8_t fill0 = (grub_uint8_t)((color >> 0) & 0xFF);
|
||||
grub_uint8_t fill1 = (grub_uint8_t)((color >> 8) & 0xFF);
|
||||
|
||||
/* Calculate the number of bytes to advance from the end of one line
|
||||
to the beginning of the next line. */
|
||||
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
|
||||
|
||||
/* Get the start address. */
|
||||
dstptr = (grub_uint8_t *) grub_video_fb_get_video_ptr (dst, x, y);
|
||||
|
||||
for (j = 0; j < height; j++)
|
||||
{
|
||||
for (i = 0; i < width; i++)
|
||||
{
|
||||
*dstptr++ = fill0;
|
||||
*dstptr++ = fill1;
|
||||
}
|
||||
|
||||
/* Advance the dest pointer to the right location on the next line. */
|
||||
dstptr += rowskip;
|
||||
}
|
||||
}
|
||||
|
||||
/* Optimized filler for index color. It is assumed that color
|
||||
is already mapped to destination format. */
|
||||
void
|
||||
grub_video_fbfill_direct8 (struct grub_video_fbblit_info *dst,
|
||||
grub_video_color_t color, int x, int y,
|
||||
int width, int height)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
grub_size_t rowskip;
|
||||
grub_uint8_t *dstptr;
|
||||
grub_uint8_t fill = (grub_uint8_t)color & 0xFF;
|
||||
|
||||
/* Calculate the number of bytes to advance from the end of one line
|
||||
to the beginning of the next line. */
|
||||
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
|
||||
|
||||
/* Get the start address. */
|
||||
dstptr = (grub_uint8_t *) grub_video_fb_get_video_ptr (dst, x, y);
|
||||
|
||||
for (j = 0; j < height; j++)
|
||||
{
|
||||
for (i = 0; i < width; i++)
|
||||
*dstptr++ = fill;
|
||||
|
||||
/* Advance the dest pointer to the right location on the next line. */
|
||||
dstptr += rowskip;
|
||||
}
|
||||
}
|
178
grub-core/video/fb/fbutil.c
Normal file
178
grub-core/video/fb/fbutil.c
Normal file
|
@ -0,0 +1,178 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2006,2007,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/>.
|
||||
*/
|
||||
|
||||
/* SPECIAL NOTES!
|
||||
|
||||
Please note following when reading the code below:
|
||||
|
||||
- In this driver we assume that every memory can be accessed by same memory
|
||||
bus. If there are different address spaces do not use this code as a base
|
||||
code for other archs.
|
||||
|
||||
- Every function in this code assumes that bounds checking has been done in
|
||||
previous phase and they are opted out in here. */
|
||||
|
||||
#include <grub/fbutil.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/video.h>
|
||||
|
||||
grub_uint8_t *
|
||||
grub_video_fb_get_video_ptr (struct grub_video_fbblit_info *source,
|
||||
unsigned int x, unsigned int y)
|
||||
{
|
||||
grub_uint8_t *ptr = 0;
|
||||
|
||||
switch (source->mode_info->bpp)
|
||||
{
|
||||
case 32:
|
||||
ptr = source->data + y * source->mode_info->pitch + x * 4;
|
||||
break;
|
||||
|
||||
case 24:
|
||||
ptr = source->data + y * source->mode_info->pitch + x * 3;
|
||||
break;
|
||||
|
||||
case 16:
|
||||
case 15:
|
||||
ptr = source->data + y * source->mode_info->pitch + x * 2;
|
||||
break;
|
||||
|
||||
case 8:
|
||||
ptr = source->data + y * source->mode_info->pitch + x;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
/* For 1-bit bitmaps, addressing needs to be done at the bit level
|
||||
and it doesn't make sense, in general, to ask for a pointer
|
||||
to a particular pixel's data. */
|
||||
break;
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
grub_video_color_t
|
||||
get_pixel (struct grub_video_fbblit_info *source,
|
||||
unsigned int x, unsigned int y)
|
||||
{
|
||||
grub_video_color_t color = 0;
|
||||
|
||||
switch (source->mode_info->bpp)
|
||||
{
|
||||
case 32:
|
||||
color = *(grub_uint32_t *)grub_video_fb_get_video_ptr (source, x, y);
|
||||
break;
|
||||
|
||||
case 24:
|
||||
{
|
||||
grub_uint8_t *ptr;
|
||||
ptr = grub_video_fb_get_video_ptr (source, x, y);
|
||||
color = ptr[0] | (ptr[1] << 8) | (ptr[2] << 16);
|
||||
}
|
||||
break;
|
||||
|
||||
case 16:
|
||||
case 15:
|
||||
color = *(grub_uint16_t *)grub_video_fb_get_video_ptr (source, x, y);
|
||||
break;
|
||||
|
||||
case 8:
|
||||
color = *(grub_uint8_t *)grub_video_fb_get_video_ptr (source, x, y);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if (source->mode_info->blit_format == GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED)
|
||||
{
|
||||
int bit_index = y * source->mode_info->width + x;
|
||||
grub_uint8_t *ptr = source->data + bit_index / 8;
|
||||
int bit_pos = 7 - bit_index % 8;
|
||||
color = (*ptr >> bit_pos) & 0x01;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
void
|
||||
set_pixel (struct grub_video_fbblit_info *source,
|
||||
unsigned int x, unsigned int y, grub_video_color_t color)
|
||||
{
|
||||
switch (source->mode_info->bpp)
|
||||
{
|
||||
case 32:
|
||||
{
|
||||
grub_uint32_t *ptr;
|
||||
|
||||
ptr = (grub_uint32_t *)grub_video_fb_get_video_ptr (source, x, y);
|
||||
|
||||
*ptr = color;
|
||||
}
|
||||
break;
|
||||
|
||||
case 24:
|
||||
{
|
||||
grub_uint8_t *ptr;
|
||||
grub_uint8_t *colorptr = (grub_uint8_t *)&color;
|
||||
|
||||
ptr = grub_video_fb_get_video_ptr (source, x, y);
|
||||
|
||||
ptr[0] = colorptr[0];
|
||||
ptr[1] = colorptr[1];
|
||||
ptr[2] = colorptr[2];
|
||||
}
|
||||
break;
|
||||
|
||||
case 16:
|
||||
case 15:
|
||||
{
|
||||
grub_uint16_t *ptr;
|
||||
|
||||
ptr = (grub_uint16_t *)grub_video_fb_get_video_ptr (source, x, y);
|
||||
|
||||
*ptr = (grub_uint16_t) (color & 0xFFFF);
|
||||
}
|
||||
break;
|
||||
|
||||
case 8:
|
||||
{
|
||||
grub_uint8_t *ptr;
|
||||
|
||||
ptr = (grub_uint8_t *)grub_video_fb_get_video_ptr (source, x, y);
|
||||
|
||||
*ptr = (grub_uint8_t) (color & 0xFF);
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if (source->mode_info->blit_format == GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED)
|
||||
{
|
||||
int bit_index = y * source->mode_info->width + x;
|
||||
grub_uint8_t *ptr = source->data + bit_index / 8;
|
||||
int bit_pos = 7 - bit_index % 8;
|
||||
*ptr = (*ptr & ~(1 << bit_pos)) | ((color & 0x01) << bit_pos);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
1289
grub-core/video/fb/video_fb.c
Normal file
1289
grub-core/video/fb/video_fb.c
Normal file
File diff suppressed because it is too large
Load diff
820
grub-core/video/i386/pc/vbe.c
Normal file
820
grub-core/video/i386/pc/vbe.c
Normal file
|
@ -0,0 +1,820 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2005,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/>.
|
||||
*/
|
||||
|
||||
#define grub_video_render_target grub_video_fbrender_target
|
||||
|
||||
#include <grub/err.h>
|
||||
#include <grub/machine/memory.h>
|
||||
#include <grub/machine/vga.h>
|
||||
#include <grub/machine/vbe.h>
|
||||
#include <grub/video_fb.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/video.h>
|
||||
|
||||
static int vbe_detected = -1;
|
||||
|
||||
static struct grub_vbe_info_block controller_info;
|
||||
static struct grub_vbe_mode_info_block active_vbe_mode_info;
|
||||
|
||||
/* Track last mode to support cards which fail on get_mode. */
|
||||
static grub_uint32_t last_set_mode = 3;
|
||||
|
||||
static struct
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
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;
|
||||
static grub_uint16_t *vbe_mode_list;
|
||||
|
||||
static void *
|
||||
real2pm (grub_vbe_farptr_t ptr)
|
||||
{
|
||||
return (void *) ((((unsigned long) ptr & 0xFFFF0000) >> 12UL)
|
||||
+ ((unsigned long) ptr & 0x0000FFFF));
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_vbe_probe (struct grub_vbe_info_block *info_block)
|
||||
{
|
||||
struct grub_vbe_info_block *vbe_ib;
|
||||
grub_vbe_status_t status;
|
||||
|
||||
/* Clear caller's controller info block. */
|
||||
if (info_block)
|
||||
grub_memset (info_block, 0, sizeof (*info_block));
|
||||
|
||||
/* Do not probe more than one time, if not necessary. */
|
||||
if (vbe_detected == -1 || info_block)
|
||||
{
|
||||
/* Clear old copy of controller info block. */
|
||||
grub_memset (&controller_info, 0, sizeof (controller_info));
|
||||
|
||||
/* Mark VESA BIOS extension as undetected. */
|
||||
vbe_detected = 0;
|
||||
|
||||
/* Use low memory scratch area as temporary storage
|
||||
for VESA BIOS call. */
|
||||
vbe_ib = (struct grub_vbe_info_block *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
|
||||
|
||||
/* Prepare info block. */
|
||||
grub_memset (vbe_ib, 0, sizeof (*vbe_ib));
|
||||
|
||||
vbe_ib->signature[0] = 'V';
|
||||
vbe_ib->signature[1] = 'B';
|
||||
vbe_ib->signature[2] = 'E';
|
||||
vbe_ib->signature[3] = '2';
|
||||
|
||||
/* Try to get controller info block. */
|
||||
status = grub_vbe_bios_get_controller_info (vbe_ib);
|
||||
if (status == GRUB_VBE_STATUS_OK)
|
||||
{
|
||||
/* Copy it for later usage. */
|
||||
grub_memcpy (&controller_info, vbe_ib, sizeof (controller_info));
|
||||
|
||||
/* Mark VESA BIOS extension as detected. */
|
||||
vbe_detected = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (! vbe_detected)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "VESA BIOS Extension not found");
|
||||
|
||||
/* Make copy of controller info block to caller. */
|
||||
if (info_block)
|
||||
grub_memcpy (info_block, &controller_info, sizeof (*info_block));
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_vbe_set_video_mode (grub_uint32_t vbe_mode,
|
||||
struct grub_vbe_mode_info_block *vbe_mode_info)
|
||||
{
|
||||
grub_vbe_status_t status;
|
||||
grub_uint32_t old_vbe_mode;
|
||||
struct grub_vbe_mode_info_block new_vbe_mode_info;
|
||||
grub_err_t err;
|
||||
|
||||
/* Make sure that VBE is supported. */
|
||||
grub_vbe_probe (0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* Try to get mode info. */
|
||||
grub_vbe_get_video_mode_info (vbe_mode, &new_vbe_mode_info);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* For all VESA BIOS modes, force linear frame buffer. */
|
||||
if (vbe_mode >= 0x100)
|
||||
{
|
||||
/* We only want linear frame buffer modes. */
|
||||
vbe_mode |= 1 << 14;
|
||||
|
||||
/* Determine frame buffer pixel format. */
|
||||
switch (new_vbe_mode_info.memory_model)
|
||||
{
|
||||
case GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL:
|
||||
framebuffer.index_color_mode = 1;
|
||||
break;
|
||||
|
||||
case GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR:
|
||||
framebuffer.index_color_mode = 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
|
||||
"unsupported pixel format 0x%x",
|
||||
new_vbe_mode_info.memory_model);
|
||||
}
|
||||
}
|
||||
|
||||
/* Get current mode. */
|
||||
grub_vbe_get_video_mode (&old_vbe_mode);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* Try to set video mode. */
|
||||
status = grub_vbe_bios_set_mode (vbe_mode, 0);
|
||||
if (status != GRUB_VBE_STATUS_OK)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "cannot set VBE mode %x", vbe_mode);
|
||||
last_set_mode = vbe_mode;
|
||||
|
||||
/* Save information for later usage. */
|
||||
framebuffer.active_vbe_mode = vbe_mode;
|
||||
grub_memcpy (&active_vbe_mode_info, &new_vbe_mode_info, sizeof (active_vbe_mode_info));
|
||||
|
||||
if (vbe_mode < 0x100)
|
||||
{
|
||||
/* If this is not a VESA mode, guess address. */
|
||||
framebuffer.ptr = (grub_uint8_t *) GRUB_MEMORY_MACHINE_VGA_ADDR;
|
||||
framebuffer.index_color_mode = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
framebuffer.ptr = (grub_uint8_t *) new_vbe_mode_info.phys_base_addr;
|
||||
|
||||
if (controller_info.version >= 0x300)
|
||||
framebuffer.bytes_per_scan_line = new_vbe_mode_info.lin_bytes_per_scan_line;
|
||||
else
|
||||
framebuffer.bytes_per_scan_line = new_vbe_mode_info.bytes_per_scan_line;
|
||||
}
|
||||
|
||||
/* Check whether mode is text mode or graphics mode. */
|
||||
if (new_vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_TEXT)
|
||||
{
|
||||
/* Text mode. */
|
||||
|
||||
/* No special action needed for text mode as it is not supported for
|
||||
graphical support. */
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Graphics mode. */
|
||||
|
||||
/* Calculate bytes_per_pixel value. */
|
||||
switch(new_vbe_mode_info.bits_per_pixel)
|
||||
{
|
||||
case 32: framebuffer.bytes_per_pixel = 4; break;
|
||||
case 24: framebuffer.bytes_per_pixel = 3; break;
|
||||
case 16: framebuffer.bytes_per_pixel = 2; break;
|
||||
case 15: framebuffer.bytes_per_pixel = 2; break;
|
||||
case 8: framebuffer.bytes_per_pixel = 1; break;
|
||||
default:
|
||||
grub_vbe_bios_set_mode (old_vbe_mode, 0);
|
||||
last_set_mode = old_vbe_mode;
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE,
|
||||
"cannot set VBE mode %x",
|
||||
vbe_mode);
|
||||
break;
|
||||
}
|
||||
|
||||
/* If video mode is in indexed color, setup default VGA palette. */
|
||||
if (framebuffer.index_color_mode)
|
||||
{
|
||||
struct grub_vbe_palette_data *palette
|
||||
= (struct grub_vbe_palette_data *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
|
||||
unsigned i;
|
||||
|
||||
/* Make sure that the BIOS can reach the palette. */
|
||||
for (i = 0; i < GRUB_VIDEO_FBSTD_NUMCOLORS; i++)
|
||||
{
|
||||
palette[i].red = grub_video_fbstd_colors[i].r;
|
||||
palette[i].green = grub_video_fbstd_colors[i].g;
|
||||
palette[i].blue = grub_video_fbstd_colors[i].b;
|
||||
palette[i].alignment = 0;
|
||||
}
|
||||
|
||||
status = grub_vbe_bios_set_palette_data (GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
0, palette);
|
||||
|
||||
/* Just ignore the status. */
|
||||
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/* Copy mode info for caller. */
|
||||
if (vbe_mode_info)
|
||||
grub_memcpy (vbe_mode_info, &new_vbe_mode_info, sizeof (*vbe_mode_info));
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_vbe_get_video_mode (grub_uint32_t *mode)
|
||||
{
|
||||
grub_vbe_status_t status;
|
||||
|
||||
/* Make sure that VBE is supported. */
|
||||
grub_vbe_probe (0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* Try to query current mode from VESA BIOS. */
|
||||
status = grub_vbe_bios_get_mode (mode);
|
||||
/* XXX: ATI cards don't support get_mode. */
|
||||
if (status != GRUB_VBE_STATUS_OK)
|
||||
*mode = last_set_mode;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_vbe_get_video_mode_info (grub_uint32_t mode,
|
||||
struct grub_vbe_mode_info_block *mode_info)
|
||||
{
|
||||
struct grub_vbe_mode_info_block *mi_tmp
|
||||
= (struct grub_vbe_mode_info_block *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
|
||||
grub_vbe_status_t status;
|
||||
|
||||
/* Make sure that VBE is supported. */
|
||||
grub_vbe_probe (0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* If mode is not VESA mode, skip mode info query. */
|
||||
if (mode >= 0x100)
|
||||
{
|
||||
/* Try to get mode info from VESA BIOS. */
|
||||
status = grub_vbe_bios_get_mode_info (mode, mi_tmp);
|
||||
if (status != GRUB_VBE_STATUS_OK)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE,
|
||||
"cannot get information on the mode %x", mode);
|
||||
|
||||
/* Make copy of mode info block. */
|
||||
grub_memcpy (mode_info, mi_tmp, sizeof (*mode_info));
|
||||
}
|
||||
else
|
||||
/* Just clear mode info block if it isn't a VESA mode. */
|
||||
grub_memset (mode_info, 0, sizeof (*mode_info));
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_vbe_init (void)
|
||||
{
|
||||
grub_uint16_t *rm_vbe_mode_list;
|
||||
grub_uint16_t *p;
|
||||
grub_size_t vbe_mode_list_size;
|
||||
struct grub_vbe_info_block info_block;
|
||||
|
||||
/* Check if there is adapter present.
|
||||
|
||||
Firmware note: There has been a report that some cards store video mode
|
||||
list in temporary memory. So we must first use vbe probe to get
|
||||
refreshed information to receive valid pointers and data, and then
|
||||
copy this information to somewhere safe. */
|
||||
grub_vbe_probe (&info_block);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* Copy modelist to local memory. */
|
||||
p = rm_vbe_mode_list = real2pm (info_block.video_mode_ptr);
|
||||
while(*p++ != 0xFFFF)
|
||||
;
|
||||
|
||||
vbe_mode_list_size = (grub_addr_t) p - (grub_addr_t) rm_vbe_mode_list;
|
||||
vbe_mode_list = grub_malloc (vbe_mode_list_size);
|
||||
if (! vbe_mode_list)
|
||||
return grub_errno;
|
||||
grub_memcpy (vbe_mode_list, rm_vbe_mode_list, vbe_mode_list_size);
|
||||
|
||||
/* Adapter could be found, figure out initial video mode. */
|
||||
grub_vbe_get_video_mode (&initial_vbe_mode);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
/* Free allocated resources. */
|
||||
grub_free (vbe_mode_list);
|
||||
vbe_mode_list = NULL;
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
/* Reset frame buffer. */
|
||||
grub_memset (&framebuffer, 0, sizeof(framebuffer));
|
||||
|
||||
return grub_video_fb_init ();
|
||||
}
|
||||
|
||||
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);
|
||||
if (status != GRUB_VBE_STATUS_OK)
|
||||
/* TODO: Decide, is this something we want to do. */
|
||||
return grub_errno;
|
||||
last_set_mode = initial_vbe_mode;
|
||||
|
||||
/* TODO: Free any resources allocated by driver. */
|
||||
grub_free (vbe_mode_list);
|
||||
vbe_mode_list = NULL;
|
||||
|
||||
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)
|
||||
{
|
||||
grub_uint16_t *p;
|
||||
struct grub_vbe_mode_info_block vbe_mode_info;
|
||||
struct grub_vbe_mode_info_block best_vbe_mode_info;
|
||||
grub_uint32_t best_vbe_mode = 0;
|
||||
int depth;
|
||||
|
||||
/* Decode depth from mode_type. If it is zero, then autodetect. */
|
||||
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
|
||||
|
||||
/* Walk thru mode list and try to find matching mode. */
|
||||
for (p = vbe_mode_list; *p != 0xFFFF; p++)
|
||||
{
|
||||
grub_uint32_t vbe_mode = *p;
|
||||
|
||||
grub_vbe_get_video_mode_info (vbe_mode, &vbe_mode_info);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
/* Could not retrieve mode info, retreat. */
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
break;
|
||||
}
|
||||
|
||||
if ((vbe_mode_info.mode_attributes & 0x001) == 0)
|
||||
/* If not available, skip it. */
|
||||
continue;
|
||||
|
||||
if ((vbe_mode_info.mode_attributes & 0x008) == 0)
|
||||
/* Monochrome is unusable. */
|
||||
continue;
|
||||
|
||||
if ((vbe_mode_info.mode_attributes & 0x080) == 0)
|
||||
/* We support only linear frame buffer modes. */
|
||||
continue;
|
||||
|
||||
if ((vbe_mode_info.mode_attributes & 0x010) == 0)
|
||||
/* We allow only graphical modes. */
|
||||
continue;
|
||||
|
||||
if ((vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
|
||||
&& (vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR))
|
||||
/* Not compatible memory model. */
|
||||
continue;
|
||||
|
||||
if (((vbe_mode_info.x_resolution != width)
|
||||
|| (vbe_mode_info.y_resolution != height)) && width != 0 && height != 0)
|
||||
/* Non matching resolution. */
|
||||
continue;
|
||||
|
||||
/* Check if user requested RGB or index color mode. */
|
||||
if ((mode_mask & GRUB_VIDEO_MODE_TYPE_COLOR_MASK) != 0)
|
||||
{
|
||||
unsigned my_mode_type = 0;
|
||||
|
||||
if (vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
|
||||
my_mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
|
||||
|
||||
if (vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR)
|
||||
my_mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
|
||||
if ((my_mode_type & mode_mask
|
||||
& (GRUB_VIDEO_MODE_TYPE_RGB | GRUB_VIDEO_MODE_TYPE_INDEX_COLOR))
|
||||
!= (mode_type & mode_mask
|
||||
& (GRUB_VIDEO_MODE_TYPE_RGB
|
||||
| GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)))
|
||||
continue;
|
||||
}
|
||||
|
||||
/* If there is a request for specific depth, ignore others. */
|
||||
if ((depth != 0) && (vbe_mode_info.bits_per_pixel != depth))
|
||||
continue;
|
||||
|
||||
/* Select mode with most of "volume" (size of framebuffer in bits). */
|
||||
if (best_vbe_mode != 0)
|
||||
if ((grub_uint64_t) vbe_mode_info.bits_per_pixel
|
||||
* vbe_mode_info.x_resolution * vbe_mode_info.y_resolution
|
||||
< (grub_uint64_t) best_vbe_mode_info.bits_per_pixel
|
||||
* best_vbe_mode_info.x_resolution * best_vbe_mode_info.y_resolution)
|
||||
continue;
|
||||
|
||||
/* Save so far best mode information for later use. */
|
||||
best_vbe_mode = vbe_mode;
|
||||
grub_memcpy (&best_vbe_mode_info, &vbe_mode_info, sizeof (vbe_mode_info));
|
||||
}
|
||||
|
||||
/* Try to initialize best mode found. */
|
||||
if (best_vbe_mode != 0)
|
||||
{
|
||||
grub_err_t err;
|
||||
/* If this fails, then we have mode selection heuristics problem,
|
||||
or adapter failure. */
|
||||
/* grub_vbe_set_video_mode already sets active_vbe_mode_info. */
|
||||
grub_vbe_set_video_mode (best_vbe_mode, NULL);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
/* Fill mode info details. */
|
||||
framebuffer.mode_info.width = active_vbe_mode_info.x_resolution;
|
||||
framebuffer.mode_info.height = active_vbe_mode_info.y_resolution;
|
||||
|
||||
if (framebuffer.index_color_mode)
|
||||
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
|
||||
else
|
||||
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
|
||||
framebuffer.mode_info.bpp = active_vbe_mode_info.bits_per_pixel;
|
||||
framebuffer.mode_info.bytes_per_pixel = framebuffer.bytes_per_pixel;
|
||||
framebuffer.mode_info.pitch = framebuffer.bytes_per_scan_line;
|
||||
framebuffer.mode_info.number_of_colors = 256; /* TODO: fix me. */
|
||||
framebuffer.mode_info.red_mask_size = active_vbe_mode_info.red_mask_size;
|
||||
framebuffer.mode_info.red_field_pos = active_vbe_mode_info.red_field_position;
|
||||
framebuffer.mode_info.green_mask_size = active_vbe_mode_info.green_mask_size;
|
||||
framebuffer.mode_info.green_field_pos = active_vbe_mode_info.green_field_position;
|
||||
framebuffer.mode_info.blue_mask_size = active_vbe_mode_info.blue_mask_size;
|
||||
framebuffer.mode_info.blue_field_pos = active_vbe_mode_info.blue_field_position;
|
||||
framebuffer.mode_info.reserved_mask_size = active_vbe_mode_info.rsvd_mask_size;
|
||||
framebuffer.mode_info.reserved_field_pos = active_vbe_mode_info.rsvd_field_position;
|
||||
|
||||
framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
|
||||
|
||||
/* 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.back_target);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Copy default palette to initialize emulated palette. */
|
||||
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Couldn't found matching mode. */
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_vbe_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data)
|
||||
{
|
||||
if (framebuffer.index_color_mode)
|
||||
{
|
||||
/* TODO: Implement setting indexed color mode palette to hardware. */
|
||||
//status = grub_vbe_bios_set_palette_data (sizeof (vga_colors)
|
||||
// / sizeof (struct grub_vbe_palette_data),
|
||||
// 0,
|
||||
// palette);
|
||||
|
||||
}
|
||||
|
||||
/* Then set color to emulated palette. */
|
||||
|
||||
return grub_video_fb_set_palette (start, count, palette_data);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_vbe_swap_buffers (void)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
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.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
|
||||
+ 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",
|
||||
.id = GRUB_VIDEO_DRIVER_VBE,
|
||||
|
||||
.init = grub_video_vbe_init,
|
||||
.fini = grub_video_vbe_fini,
|
||||
.setup = grub_video_vbe_setup,
|
||||
.get_info = grub_video_fb_get_info,
|
||||
.get_info_and_fini = grub_video_vbe_get_info_and_fini,
|
||||
.set_palette = grub_video_vbe_set_palette,
|
||||
.get_palette = grub_video_fb_get_palette,
|
||||
.set_viewport = grub_video_fb_set_viewport,
|
||||
.get_viewport = grub_video_fb_get_viewport,
|
||||
.map_color = grub_video_fb_map_color,
|
||||
.map_rgb = grub_video_fb_map_rgb,
|
||||
.map_rgba = grub_video_fb_map_rgba,
|
||||
.unmap_color = grub_video_fb_unmap_color,
|
||||
.fill_rect = grub_video_fb_fill_rect,
|
||||
.blit_bitmap = grub_video_fb_blit_bitmap,
|
||||
.blit_render_target = grub_video_fb_blit_render_target,
|
||||
.scroll = grub_video_fb_scroll,
|
||||
.swap_buffers = grub_video_vbe_swap_buffers,
|
||||
.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_vbe_get_active_render_target,
|
||||
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(video_i386_pc_vbe)
|
||||
{
|
||||
grub_video_register (&grub_video_vbe_adapter);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(video_i386_pc_vbe)
|
||||
{
|
||||
grub_video_unregister (&grub_video_vbe_adapter);
|
||||
}
|
300
grub-core/video/ieee1275.c
Normal file
300
grub-core/video/ieee1275.c
Normal file
|
@ -0,0 +1,300 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2005,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/>.
|
||||
*/
|
||||
|
||||
#define grub_video_render_target grub_video_fbrender_target
|
||||
|
||||
#include <grub/err.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/video.h>
|
||||
#include <grub/video_fb.h>
|
||||
#include <grub/ieee1275/ieee1275.h>
|
||||
|
||||
/* Only 8-bit indexed color is supported for now. */
|
||||
|
||||
static unsigned old_width, old_height;
|
||||
static int restore_needed;
|
||||
static char *display;
|
||||
|
||||
static struct
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
struct grub_video_render_target *render_target;
|
||||
grub_uint8_t *ptr;
|
||||
} framebuffer;
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data);
|
||||
|
||||
static void
|
||||
set_video_mode (unsigned width __attribute__ ((unused)),
|
||||
unsigned height __attribute__ ((unused)))
|
||||
{
|
||||
/* TODO */
|
||||
}
|
||||
|
||||
static void
|
||||
find_display (void)
|
||||
{
|
||||
auto int hook (struct grub_ieee1275_devalias *alias);
|
||||
int hook (struct grub_ieee1275_devalias *alias)
|
||||
{
|
||||
if (grub_strcmp (alias->type, "display") == 0)
|
||||
{
|
||||
grub_dprintf ("video", "Found display %s\n", alias->path);
|
||||
display = grub_strdup (alias->path);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_ieee1275_devices_iterate (hook);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_init (void)
|
||||
{
|
||||
grub_memset (&framebuffer, 0, sizeof(framebuffer));
|
||||
return grub_video_fb_init ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_fini (void)
|
||||
{
|
||||
if (restore_needed)
|
||||
{
|
||||
set_video_mode (old_width, old_height);
|
||||
restore_needed = 0;
|
||||
}
|
||||
return grub_video_fb_fini ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_fill_mode_info (grub_ieee1275_phandle_t dev,
|
||||
struct grub_video_mode_info *out)
|
||||
{
|
||||
grub_uint32_t tmp;
|
||||
|
||||
grub_memset (out, 0, sizeof (*out));
|
||||
|
||||
if (grub_ieee1275_get_integer_property (dev, "width", &tmp,
|
||||
sizeof (tmp), 0))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display width.");
|
||||
out->width = tmp;
|
||||
|
||||
if (grub_ieee1275_get_integer_property (dev, "height", &tmp,
|
||||
sizeof (tmp), 0))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display height.");
|
||||
out->height = tmp;
|
||||
|
||||
if (grub_ieee1275_get_integer_property (dev, "linebytes", &tmp,
|
||||
sizeof (tmp), 0))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display pitch.");
|
||||
out->pitch = tmp;
|
||||
|
||||
out->mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
|
||||
out->bpp = 8;
|
||||
out->bytes_per_pixel = 1;
|
||||
out->number_of_colors = 256;
|
||||
|
||||
out->blit_format = grub_video_get_blit_format (out);
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_setup (unsigned int width, unsigned int height,
|
||||
unsigned int mode_type __attribute__ ((unused)),
|
||||
unsigned int mode_mask __attribute__ ((unused)))
|
||||
{
|
||||
grub_uint32_t current_width, current_height, address;
|
||||
grub_err_t err;
|
||||
grub_ieee1275_phandle_t dev;
|
||||
|
||||
if (!display)
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't find display device.");
|
||||
|
||||
if (grub_ieee1275_finddevice (display, &dev))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't open display device.");
|
||||
|
||||
if (grub_ieee1275_get_integer_property (dev, "width", ¤t_width,
|
||||
sizeof (current_width), 0))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display width.");
|
||||
|
||||
if (grub_ieee1275_get_integer_property (dev, "height", ¤t_height,
|
||||
sizeof (current_width), 0))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display height.");
|
||||
|
||||
if ((width == current_width && height == current_height)
|
||||
|| (width == 0 && height == 0))
|
||||
{
|
||||
grub_dprintf ("video", "IEEE1275: keeping current mode %dx%d\n",
|
||||
current_width, current_height);
|
||||
}
|
||||
else
|
||||
{
|
||||
grub_dprintf ("video", "IEEE1275: Setting mode %dx%d\n", width, height);
|
||||
/* TODO. */
|
||||
return grub_error (GRUB_ERR_IO, "can't set mode %dx%d", width, height);
|
||||
}
|
||||
|
||||
err = grub_video_ieee1275_fill_mode_info (dev, &framebuffer.mode_info);
|
||||
if (err)
|
||||
{
|
||||
grub_dprintf ("video", "IEEE1275: couldn't fill mode info\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
if (grub_ieee1275_get_integer_property (dev, "address", (void *) &address,
|
||||
sizeof (address), 0))
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display address.");
|
||||
|
||||
/* For some reason sparc64 uses 32-bit pointer too. */
|
||||
framebuffer.ptr = (void *) (grub_addr_t) address;
|
||||
|
||||
grub_video_ieee1275_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
|
||||
grub_dprintf ("video", "IEEE1275: initialising FB @ %p %dx%dx%d\n",
|
||||
framebuffer.ptr, framebuffer.mode_info.width,
|
||||
framebuffer.mode_info.height, framebuffer.mode_info.bpp);
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer
|
||||
(&framebuffer.render_target, &framebuffer.mode_info, framebuffer.ptr);
|
||||
|
||||
if (err)
|
||||
{
|
||||
grub_dprintf ("video", "IEEE1275: Couldn't create FB target\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
|
||||
|
||||
if (err)
|
||||
{
|
||||
grub_dprintf ("video", "IEEE1275: Couldn't set FB target\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
|
||||
if (err)
|
||||
grub_dprintf ("video", "IEEE1275: Couldn't set palette\n");
|
||||
else
|
||||
grub_dprintf ("video", "IEEE1275: Success\n");
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_swap_buffers (void)
|
||||
{
|
||||
/* TODO: Implement buffer swapping. */
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
|
||||
target = framebuffer.render_target;
|
||||
|
||||
return grub_video_fb_set_active_render_target (target);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_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;
|
||||
|
||||
grub_video_fb_fini ();
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_ieee1275_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data)
|
||||
{
|
||||
grub_err_t err;
|
||||
struct grub_video_palette_data fb_palette_data[256];
|
||||
|
||||
err = grub_video_fb_set_palette (start, count, palette_data);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
grub_video_fb_get_palette (0, 256, fb_palette_data);
|
||||
|
||||
/* TODO. */
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static struct grub_video_adapter grub_video_ieee1275_adapter =
|
||||
{
|
||||
.name = "IEEE1275 video driver",
|
||||
|
||||
.init = grub_video_ieee1275_init,
|
||||
.fini = grub_video_ieee1275_fini,
|
||||
.setup = grub_video_ieee1275_setup,
|
||||
.get_info = grub_video_fb_get_info,
|
||||
.get_info_and_fini = grub_video_ieee1275_get_info_and_fini,
|
||||
.set_palette = grub_video_ieee1275_set_palette,
|
||||
.get_palette = grub_video_fb_get_palette,
|
||||
.set_viewport = grub_video_fb_set_viewport,
|
||||
.get_viewport = grub_video_fb_get_viewport,
|
||||
.map_color = grub_video_fb_map_color,
|
||||
.map_rgb = grub_video_fb_map_rgb,
|
||||
.map_rgba = grub_video_fb_map_rgba,
|
||||
.unmap_color = grub_video_fb_unmap_color,
|
||||
.fill_rect = grub_video_fb_fill_rect,
|
||||
.blit_bitmap = grub_video_fb_blit_bitmap,
|
||||
.blit_render_target = grub_video_fb_blit_render_target,
|
||||
.scroll = grub_video_fb_scroll,
|
||||
.swap_buffers = grub_video_ieee1275_swap_buffers,
|
||||
.create_render_target = grub_video_fb_create_render_target,
|
||||
.delete_render_target = grub_video_fb_delete_render_target,
|
||||
.set_active_render_target = grub_video_ieee1275_set_active_render_target,
|
||||
.get_active_render_target = grub_video_fb_get_active_render_target,
|
||||
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(ieee1275_fb)
|
||||
{
|
||||
find_display ();
|
||||
if (display)
|
||||
grub_video_register (&grub_video_ieee1275_adapter);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(ieee1275_fb)
|
||||
{
|
||||
if (restore_needed)
|
||||
{
|
||||
set_video_mode (old_width, old_height);
|
||||
restore_needed = 0;
|
||||
}
|
||||
if (display)
|
||||
grub_video_unregister (&grub_video_ieee1275_adapter);
|
||||
grub_free (display);
|
||||
}
|
750
grub-core/video/readers/jpeg.c
Normal file
750
grub-core/video/readers/jpeg.c
Normal file
|
@ -0,0 +1,750 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2008 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/bitmap.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/normal.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/bufio.h>
|
||||
|
||||
/* Uncomment following define to enable JPEG debug. */
|
||||
//#define JPEG_DEBUG
|
||||
|
||||
#define JPEG_ESC_CHAR 0xFF
|
||||
|
||||
#define JPEG_SAMPLING_1x1 0x11
|
||||
|
||||
#define JPEG_MARKER_SOI 0xd8
|
||||
#define JPEG_MARKER_EOI 0xd9
|
||||
#define JPEG_MARKER_DHT 0xc4
|
||||
#define JPEG_MARKER_DQT 0xdb
|
||||
#define JPEG_MARKER_SOF0 0xc0
|
||||
#define JPEG_MARKER_SOS 0xda
|
||||
|
||||
#define SHIFT_BITS 8
|
||||
#define CONST(x) ((int) ((x) * (1L << SHIFT_BITS) + 0.5))
|
||||
|
||||
#define JPEG_UNIT_SIZE 8
|
||||
|
||||
static const grub_uint8_t jpeg_zigzag_order[64] = {
|
||||
0, 1, 8, 16, 9, 2, 3, 10,
|
||||
17, 24, 32, 25, 18, 11, 4, 5,
|
||||
12, 19, 26, 33, 40, 48, 41, 34,
|
||||
27, 20, 13, 6, 7, 14, 21, 28,
|
||||
35, 42, 49, 56, 57, 50, 43, 36,
|
||||
29, 22, 15, 23, 30, 37, 44, 51,
|
||||
58, 59, 52, 45, 38, 31, 39, 46,
|
||||
53, 60, 61, 54, 47, 55, 62, 63
|
||||
};
|
||||
|
||||
#ifdef JPEG_DEBUG
|
||||
static grub_command_t cmd;
|
||||
#endif
|
||||
|
||||
typedef int jpeg_data_unit_t[64];
|
||||
|
||||
struct grub_jpeg_data
|
||||
{
|
||||
grub_file_t file;
|
||||
struct grub_video_bitmap **bitmap;
|
||||
|
||||
int image_width;
|
||||
int image_height;
|
||||
|
||||
grub_uint8_t *huff_value[4];
|
||||
int huff_offset[4][16];
|
||||
int huff_maxval[4][16];
|
||||
|
||||
grub_uint8_t quan_table[2][64];
|
||||
int comp_index[3][3];
|
||||
|
||||
jpeg_data_unit_t ydu[4];
|
||||
jpeg_data_unit_t crdu;
|
||||
jpeg_data_unit_t cbdu;
|
||||
|
||||
int vs, hs;
|
||||
|
||||
int dc_value[3];
|
||||
|
||||
int bit_mask, bit_save;
|
||||
};
|
||||
|
||||
static grub_uint8_t
|
||||
grub_jpeg_get_byte (struct grub_jpeg_data *data)
|
||||
{
|
||||
grub_uint8_t r;
|
||||
|
||||
r = 0;
|
||||
grub_file_read (data->file, &r, 1);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static grub_uint16_t
|
||||
grub_jpeg_get_word (struct grub_jpeg_data *data)
|
||||
{
|
||||
grub_uint16_t r;
|
||||
|
||||
r = 0;
|
||||
grub_file_read (data->file, &r, sizeof (grub_uint16_t));
|
||||
|
||||
return grub_be_to_cpu16 (r);
|
||||
}
|
||||
|
||||
static int
|
||||
grub_jpeg_get_bit (struct grub_jpeg_data *data)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (data->bit_mask == 0)
|
||||
{
|
||||
data->bit_save = grub_jpeg_get_byte (data);
|
||||
if (data->bit_save == JPEG_ESC_CHAR)
|
||||
{
|
||||
if (grub_jpeg_get_byte (data) != 0)
|
||||
{
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: invalid 0xFF in data stream");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
data->bit_mask = 0x80;
|
||||
}
|
||||
|
||||
ret = ((data->bit_save & data->bit_mask) != 0);
|
||||
data->bit_mask >>= 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
grub_jpeg_get_number (struct grub_jpeg_data *data, int num)
|
||||
{
|
||||
int value, i, msb;
|
||||
|
||||
if (num == 0)
|
||||
return 0;
|
||||
|
||||
msb = value = grub_jpeg_get_bit (data);
|
||||
for (i = 1; i < num; i++)
|
||||
value = (value << 1) + (grub_jpeg_get_bit (data) != 0);
|
||||
if (!msb)
|
||||
value += 1 - (1 << num);
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
static int
|
||||
grub_jpeg_get_huff_code (struct grub_jpeg_data *data, int id)
|
||||
{
|
||||
int code, i;
|
||||
|
||||
code = 0;
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
code <<= 1;
|
||||
if (grub_jpeg_get_bit (data))
|
||||
code++;
|
||||
if (code < data->huff_maxval[id][i])
|
||||
return data->huff_value[id][code + data->huff_offset[id][i]];
|
||||
}
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: huffman decode fails");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_jpeg_decode_huff_table (struct grub_jpeg_data *data)
|
||||
{
|
||||
int id, ac, i, n, base, ofs;
|
||||
grub_uint32_t next_marker;
|
||||
grub_uint8_t count[16];
|
||||
|
||||
next_marker = data->file->offset;
|
||||
next_marker += grub_jpeg_get_word (data);
|
||||
|
||||
id = grub_jpeg_get_byte (data);
|
||||
ac = (id >> 4);
|
||||
id &= 0xF;
|
||||
if (id > 1)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: too many huffman tables");
|
||||
|
||||
if (grub_file_read (data->file, &count, sizeof (count)) !=
|
||||
sizeof (count))
|
||||
return grub_errno;
|
||||
|
||||
n = 0;
|
||||
for (i = 0; i < 16; i++)
|
||||
n += count[i];
|
||||
|
||||
id += ac * 2;
|
||||
data->huff_value[id] = grub_malloc (n);
|
||||
if (grub_errno)
|
||||
return grub_errno;
|
||||
|
||||
if (grub_file_read (data->file, data->huff_value[id], n) != n)
|
||||
return grub_errno;
|
||||
|
||||
base = 0;
|
||||
ofs = 0;
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
base += count[i];
|
||||
ofs += count[i];
|
||||
|
||||
data->huff_maxval[id][i] = base;
|
||||
data->huff_offset[id][i] = ofs - base;
|
||||
|
||||
base <<= 1;
|
||||
}
|
||||
|
||||
if (data->file->offset != next_marker)
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in huffman table");
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_jpeg_decode_quan_table (struct grub_jpeg_data *data)
|
||||
{
|
||||
int id;
|
||||
grub_uint32_t next_marker;
|
||||
|
||||
next_marker = data->file->offset;
|
||||
next_marker += grub_jpeg_get_word (data);
|
||||
|
||||
id = grub_jpeg_get_byte (data);
|
||||
if (id >= 0x10) /* Upper 4-bit is precision. */
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: only 8-bit precision is supported");
|
||||
|
||||
if (id > 1)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: too many quantization tables");
|
||||
|
||||
if (grub_file_read (data->file, &data->quan_table[id], 64) != 64)
|
||||
return grub_errno;
|
||||
|
||||
if (data->file->offset != next_marker)
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: extra byte in quantization table");
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_jpeg_decode_sof (struct grub_jpeg_data *data)
|
||||
{
|
||||
int i, cc;
|
||||
grub_uint32_t next_marker;
|
||||
|
||||
next_marker = data->file->offset;
|
||||
next_marker += grub_jpeg_get_word (data);
|
||||
|
||||
if (grub_jpeg_get_byte (data) != 8)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: only 8-bit precision is supported");
|
||||
|
||||
data->image_height = grub_jpeg_get_word (data);
|
||||
data->image_width = grub_jpeg_get_word (data);
|
||||
|
||||
if ((!data->image_height) || (!data->image_width))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid image size");
|
||||
|
||||
cc = grub_jpeg_get_byte (data);
|
||||
if (cc != 3)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: component count must be 3");
|
||||
|
||||
for (i = 0; i < cc; i++)
|
||||
{
|
||||
int id, ss;
|
||||
|
||||
id = grub_jpeg_get_byte (data) - 1;
|
||||
if ((id < 0) || (id >= 3))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
|
||||
|
||||
ss = grub_jpeg_get_byte (data); /* Sampling factor. */
|
||||
if (!id)
|
||||
{
|
||||
data->vs = ss & 0xF; /* Vertical sampling. */
|
||||
data->hs = ss >> 4; /* Horizontal sampling. */
|
||||
if ((data->vs > 2) || (data->hs > 2))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: sampling method not supported");
|
||||
}
|
||||
else if (ss != JPEG_SAMPLING_1x1)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: sampling method not supported");
|
||||
data->comp_index[id][0] = grub_jpeg_get_byte (data);
|
||||
}
|
||||
|
||||
if (data->file->offset != next_marker)
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sof");
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static void
|
||||
grub_jpeg_idct_transform (jpeg_data_unit_t du)
|
||||
{
|
||||
int *pd;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7;
|
||||
int v0, v1, v2, v3, v4;
|
||||
|
||||
pd = du;
|
||||
for (i = 0; i < JPEG_UNIT_SIZE; i++, pd++)
|
||||
{
|
||||
if ((pd[JPEG_UNIT_SIZE * 1] | pd[JPEG_UNIT_SIZE * 2] |
|
||||
pd[JPEG_UNIT_SIZE * 3] | pd[JPEG_UNIT_SIZE * 4] |
|
||||
pd[JPEG_UNIT_SIZE * 5] | pd[JPEG_UNIT_SIZE * 6] |
|
||||
pd[JPEG_UNIT_SIZE * 7]) == 0)
|
||||
{
|
||||
pd[JPEG_UNIT_SIZE * 0] <<= SHIFT_BITS;
|
||||
|
||||
pd[JPEG_UNIT_SIZE * 1] = pd[JPEG_UNIT_SIZE * 2]
|
||||
= pd[JPEG_UNIT_SIZE * 3] = pd[JPEG_UNIT_SIZE * 4]
|
||||
= pd[JPEG_UNIT_SIZE * 5] = pd[JPEG_UNIT_SIZE * 6]
|
||||
= pd[JPEG_UNIT_SIZE * 7] = pd[JPEG_UNIT_SIZE * 0];
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
t0 = pd[JPEG_UNIT_SIZE * 0];
|
||||
t1 = pd[JPEG_UNIT_SIZE * 2];
|
||||
t2 = pd[JPEG_UNIT_SIZE * 4];
|
||||
t3 = pd[JPEG_UNIT_SIZE * 6];
|
||||
|
||||
v4 = (t1 + t3) * CONST (0.541196100);
|
||||
|
||||
v0 = ((t0 + t2) << SHIFT_BITS);
|
||||
v1 = ((t0 - t2) << SHIFT_BITS);
|
||||
v2 = v4 - t3 * CONST (1.847759065);
|
||||
v3 = v4 + t1 * CONST (0.765366865);
|
||||
|
||||
t0 = v0 + v3;
|
||||
t3 = v0 - v3;
|
||||
t1 = v1 + v2;
|
||||
t2 = v1 - v2;
|
||||
|
||||
t4 = pd[JPEG_UNIT_SIZE * 7];
|
||||
t5 = pd[JPEG_UNIT_SIZE * 5];
|
||||
t6 = pd[JPEG_UNIT_SIZE * 3];
|
||||
t7 = pd[JPEG_UNIT_SIZE * 1];
|
||||
|
||||
v0 = t4 + t7;
|
||||
v1 = t5 + t6;
|
||||
v2 = t4 + t6;
|
||||
v3 = t5 + t7;
|
||||
|
||||
v4 = (v2 + v3) * CONST (1.175875602);
|
||||
|
||||
v0 *= CONST (0.899976223);
|
||||
v1 *= CONST (2.562915447);
|
||||
v2 = v2 * CONST (1.961570560) - v4;
|
||||
v3 = v3 * CONST (0.390180644) - v4;
|
||||
|
||||
t4 = t4 * CONST (0.298631336) - v0 - v2;
|
||||
t5 = t5 * CONST (2.053119869) - v1 - v3;
|
||||
t6 = t6 * CONST (3.072711026) - v1 - v2;
|
||||
t7 = t7 * CONST (1.501321110) - v0 - v3;
|
||||
|
||||
pd[JPEG_UNIT_SIZE * 0] = t0 + t7;
|
||||
pd[JPEG_UNIT_SIZE * 7] = t0 - t7;
|
||||
pd[JPEG_UNIT_SIZE * 1] = t1 + t6;
|
||||
pd[JPEG_UNIT_SIZE * 6] = t1 - t6;
|
||||
pd[JPEG_UNIT_SIZE * 2] = t2 + t5;
|
||||
pd[JPEG_UNIT_SIZE * 5] = t2 - t5;
|
||||
pd[JPEG_UNIT_SIZE * 3] = t3 + t4;
|
||||
pd[JPEG_UNIT_SIZE * 4] = t3 - t4;
|
||||
}
|
||||
|
||||
pd = du;
|
||||
for (i = 0; i < JPEG_UNIT_SIZE; i++, pd += JPEG_UNIT_SIZE)
|
||||
{
|
||||
if ((pd[1] | pd[2] | pd[3] | pd[4] | pd[5] | pd[6] | pd[7]) == 0)
|
||||
{
|
||||
pd[0] >>= (SHIFT_BITS + 3);
|
||||
pd[1] = pd[2] = pd[3] = pd[4] = pd[5] = pd[6] = pd[7] = pd[0];
|
||||
continue;
|
||||
}
|
||||
|
||||
v4 = (pd[2] + pd[6]) * CONST (0.541196100);
|
||||
|
||||
v0 = (pd[0] + pd[4]) << SHIFT_BITS;
|
||||
v1 = (pd[0] - pd[4]) << SHIFT_BITS;
|
||||
v2 = v4 - pd[6] * CONST (1.847759065);
|
||||
v3 = v4 + pd[2] * CONST (0.765366865);
|
||||
|
||||
t0 = v0 + v3;
|
||||
t3 = v0 - v3;
|
||||
t1 = v1 + v2;
|
||||
t2 = v1 - v2;
|
||||
|
||||
t4 = pd[7];
|
||||
t5 = pd[5];
|
||||
t6 = pd[3];
|
||||
t7 = pd[1];
|
||||
|
||||
v0 = t4 + t7;
|
||||
v1 = t5 + t6;
|
||||
v2 = t4 + t6;
|
||||
v3 = t5 + t7;
|
||||
|
||||
v4 = (v2 + v3) * CONST (1.175875602);
|
||||
|
||||
v0 *= CONST (0.899976223);
|
||||
v1 *= CONST (2.562915447);
|
||||
v2 = v2 * CONST (1.961570560) - v4;
|
||||
v3 = v3 * CONST (0.390180644) - v4;
|
||||
|
||||
t4 = t4 * CONST (0.298631336) - v0 - v2;
|
||||
t5 = t5 * CONST (2.053119869) - v1 - v3;
|
||||
t6 = t6 * CONST (3.072711026) - v1 - v2;
|
||||
t7 = t7 * CONST (1.501321110) - v0 - v3;
|
||||
|
||||
pd[0] = (t0 + t7) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[7] = (t0 - t7) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[1] = (t1 + t6) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[6] = (t1 - t6) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[2] = (t2 + t5) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[5] = (t2 - t5) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[3] = (t3 + t4) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[4] = (t3 - t4) >> (SHIFT_BITS * 2 + 3);
|
||||
}
|
||||
|
||||
for (i = 0; i < JPEG_UNIT_SIZE * JPEG_UNIT_SIZE; i++)
|
||||
{
|
||||
du[i] += 128;
|
||||
|
||||
if (du[i] < 0)
|
||||
du[i] = 0;
|
||||
if (du[i] > 255)
|
||||
du[i] = 255;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
grub_jpeg_decode_du (struct grub_jpeg_data *data, int id, jpeg_data_unit_t du)
|
||||
{
|
||||
int pos, h1, h2, qt;
|
||||
|
||||
grub_memset (du, 0, sizeof (jpeg_data_unit_t));
|
||||
|
||||
qt = data->comp_index[id][0];
|
||||
h1 = data->comp_index[id][1];
|
||||
h2 = data->comp_index[id][2];
|
||||
|
||||
data->dc_value[id] +=
|
||||
grub_jpeg_get_number (data, grub_jpeg_get_huff_code (data, h1));
|
||||
|
||||
du[0] = data->dc_value[id] * (int) data->quan_table[qt][0];
|
||||
pos = 1;
|
||||
while (pos < 64)
|
||||
{
|
||||
int num, val;
|
||||
|
||||
num = grub_jpeg_get_huff_code (data, h2);
|
||||
if (!num)
|
||||
break;
|
||||
|
||||
val = grub_jpeg_get_number (data, num & 0xF);
|
||||
num >>= 4;
|
||||
pos += num;
|
||||
du[jpeg_zigzag_order[pos]] = val * (int) data->quan_table[qt][pos];
|
||||
pos++;
|
||||
}
|
||||
|
||||
grub_jpeg_idct_transform (du);
|
||||
}
|
||||
|
||||
static void
|
||||
grub_jpeg_ycrcb_to_rgb (int yy, int cr, int cb, grub_uint8_t * rgb)
|
||||
{
|
||||
int dd;
|
||||
|
||||
cr -= 128;
|
||||
cb -= 128;
|
||||
|
||||
/* Red */
|
||||
dd = yy + ((cr * CONST (1.402)) >> SHIFT_BITS);
|
||||
if (dd < 0)
|
||||
dd = 0;
|
||||
if (dd > 255)
|
||||
dd = 255;
|
||||
*(rgb++) = dd;
|
||||
|
||||
/* Green */
|
||||
dd = yy - ((cb * CONST (0.34414) + cr * CONST (0.71414)) >> SHIFT_BITS);
|
||||
if (dd < 0)
|
||||
dd = 0;
|
||||
if (dd > 255)
|
||||
dd = 255;
|
||||
*(rgb++) = dd;
|
||||
|
||||
/* Blue */
|
||||
dd = yy + ((cb * CONST (1.772)) >> SHIFT_BITS);
|
||||
if (dd < 0)
|
||||
dd = 0;
|
||||
if (dd > 255)
|
||||
dd = 255;
|
||||
*(rgb++) = dd;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_jpeg_decode_sos (struct grub_jpeg_data *data)
|
||||
{
|
||||
int i, cc, r1, c1, nr1, nc1, vb, hb;
|
||||
grub_uint8_t *ptr1;
|
||||
grub_uint32_t data_offset;
|
||||
|
||||
data_offset = data->file->offset;
|
||||
data_offset += grub_jpeg_get_word (data);
|
||||
|
||||
cc = grub_jpeg_get_byte (data);
|
||||
|
||||
if (cc != 3)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: component count must be 3");
|
||||
|
||||
for (i = 0; i < cc; i++)
|
||||
{
|
||||
int id, ht;
|
||||
|
||||
id = grub_jpeg_get_byte (data) - 1;
|
||||
if ((id < 0) || (id >= 3))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
|
||||
|
||||
ht = grub_jpeg_get_byte (data);
|
||||
data->comp_index[id][1] = (ht >> 4);
|
||||
data->comp_index[id][2] = (ht & 0xF) + 2;
|
||||
}
|
||||
|
||||
grub_jpeg_get_byte (data); /* Skip 3 unused bytes. */
|
||||
grub_jpeg_get_word (data);
|
||||
|
||||
if (data->file->offset != data_offset)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sos");
|
||||
|
||||
if (grub_video_bitmap_create (data->bitmap, data->image_width,
|
||||
data->image_height,
|
||||
GRUB_VIDEO_BLIT_FORMAT_RGB_888))
|
||||
return grub_errno;
|
||||
|
||||
data->bit_mask = 0x0;
|
||||
|
||||
vb = data->vs * 8;
|
||||
hb = data->hs * 8;
|
||||
nr1 = (data->image_height + vb - 1) / vb;
|
||||
nc1 = (data->image_width + hb - 1) / hb;
|
||||
|
||||
ptr1 = (*data->bitmap)->data;
|
||||
for (r1 = 0; r1 < nr1;
|
||||
r1++, ptr1 += (vb * data->image_width - hb * nc1) * 3)
|
||||
for (c1 = 0; c1 < nc1; c1++, ptr1 += hb * 3)
|
||||
{
|
||||
int r2, c2, nr2, nc2;
|
||||
grub_uint8_t *ptr2;
|
||||
|
||||
for (r2 = 0; r2 < data->vs; r2++)
|
||||
for (c2 = 0; c2 < data->hs; c2++)
|
||||
grub_jpeg_decode_du (data, 0, data->ydu[r2 * 2 + c2]);
|
||||
|
||||
grub_jpeg_decode_du (data, 1, data->cbdu);
|
||||
grub_jpeg_decode_du (data, 2, data->crdu);
|
||||
|
||||
if (grub_errno)
|
||||
return grub_errno;
|
||||
|
||||
nr2 = (r1 == nr1 - 1) ? (data->image_height - r1 * vb) : vb;
|
||||
nc2 = (c1 == nc1 - 1) ? (data->image_width - c1 * hb) : hb;
|
||||
|
||||
ptr2 = ptr1;
|
||||
for (r2 = 0; r2 < nr2; r2++, ptr2 += (data->image_width - nc2) * 3)
|
||||
for (c2 = 0; c2 < nc2; c2++, ptr2 += 3)
|
||||
{
|
||||
int i0, yy, cr, cb;
|
||||
|
||||
i0 = (r2 / data->vs) * 8 + (c2 / data->hs);
|
||||
cr = data->crdu[i0];
|
||||
cb = data->cbdu[i0];
|
||||
yy =
|
||||
data->ydu[(r2 / 8) * 2 + (c2 / 8)][(r2 % 8) * 8 + (c2 % 8)];
|
||||
|
||||
grub_jpeg_ycrcb_to_rgb (yy, cr, cb, ptr2);
|
||||
}
|
||||
}
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_uint8_t
|
||||
grub_jpeg_get_marker (struct grub_jpeg_data *data)
|
||||
{
|
||||
grub_uint8_t r;
|
||||
|
||||
r = grub_jpeg_get_byte (data);
|
||||
|
||||
if (r != JPEG_ESC_CHAR)
|
||||
{
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid maker");
|
||||
return 0;
|
||||
}
|
||||
|
||||
return grub_jpeg_get_byte (data);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_jpeg_decode_jpeg (struct grub_jpeg_data *data)
|
||||
{
|
||||
if (grub_jpeg_get_marker (data) != JPEG_MARKER_SOI) /* Start Of Image. */
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid jpeg file");
|
||||
|
||||
while (grub_errno == 0)
|
||||
{
|
||||
grub_uint8_t marker;
|
||||
|
||||
marker = grub_jpeg_get_marker (data);
|
||||
if (grub_errno)
|
||||
break;
|
||||
|
||||
#ifdef JPEG_DEBUG
|
||||
grub_printf ("jpeg marker: %x\n", marker);
|
||||
#endif
|
||||
|
||||
switch (marker)
|
||||
{
|
||||
case JPEG_MARKER_DHT: /* Define Huffman Table. */
|
||||
grub_jpeg_decode_huff_table (data);
|
||||
break;
|
||||
case JPEG_MARKER_DQT: /* Define Quantization Table. */
|
||||
grub_jpeg_decode_quan_table (data);
|
||||
break;
|
||||
case JPEG_MARKER_SOF0: /* Start Of Frame 0. */
|
||||
grub_jpeg_decode_sof (data);
|
||||
break;
|
||||
case JPEG_MARKER_SOS: /* Start Of Scan. */
|
||||
grub_jpeg_decode_sos (data);
|
||||
break;
|
||||
case JPEG_MARKER_EOI: /* End Of Image. */
|
||||
return grub_errno;
|
||||
default: /* Skip unrecognized marker. */
|
||||
{
|
||||
grub_uint16_t sz;
|
||||
|
||||
sz = grub_jpeg_get_word (data);
|
||||
if (grub_errno)
|
||||
return (grub_errno);
|
||||
grub_file_seek (data->file, data->file->offset + sz - 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_reader_jpeg (struct grub_video_bitmap **bitmap,
|
||||
const char *filename)
|
||||
{
|
||||
grub_file_t file;
|
||||
struct grub_jpeg_data *data;
|
||||
|
||||
file = grub_buffile_open (filename, 0);
|
||||
if (!file)
|
||||
return grub_errno;
|
||||
|
||||
data = grub_zalloc (sizeof (*data));
|
||||
if (data != NULL)
|
||||
{
|
||||
int i;
|
||||
|
||||
data->file = file;
|
||||
data->bitmap = bitmap;
|
||||
grub_jpeg_decode_jpeg (data);
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
if (data->huff_value[i])
|
||||
grub_free (data->huff_value[i]);
|
||||
|
||||
grub_free (data);
|
||||
}
|
||||
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_video_bitmap_destroy (*bitmap);
|
||||
*bitmap = 0;
|
||||
}
|
||||
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
#if defined(JPEG_DEBUG)
|
||||
static grub_err_t
|
||||
grub_cmd_jpegtest (grub_command_t cmd __attribute__ ((unused)),
|
||||
int argc, char **args)
|
||||
{
|
||||
struct grub_video_bitmap *bitmap = 0;
|
||||
|
||||
if (argc != 1)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
|
||||
|
||||
grub_video_reader_jpeg (&bitmap, args[0]);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
grub_video_bitmap_destroy (bitmap);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct grub_video_bitmap_reader jpg_reader = {
|
||||
.extension = ".jpg",
|
||||
.reader = grub_video_reader_jpeg,
|
||||
.next = 0
|
||||
};
|
||||
|
||||
static struct grub_video_bitmap_reader jpeg_reader = {
|
||||
.extension = ".jpeg",
|
||||
.reader = grub_video_reader_jpeg,
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT (jpeg)
|
||||
{
|
||||
grub_video_bitmap_reader_register (&jpg_reader);
|
||||
grub_video_bitmap_reader_register (&jpeg_reader);
|
||||
#if defined(JPEG_DEBUG)
|
||||
cmd = grub_register_command ("jpegtest", grub_cmd_jpegtest,
|
||||
"FILE",
|
||||
"Tests loading of JPEG bitmap.");
|
||||
#endif
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI (jpeg)
|
||||
{
|
||||
#if defined(JPEG_DEBUG)
|
||||
grub_unregister_command (cmd);
|
||||
#endif
|
||||
grub_video_bitmap_reader_unregister (&jpeg_reader);
|
||||
grub_video_bitmap_reader_unregister (&jpg_reader);
|
||||
}
|
913
grub-core/video/readers/png.c
Normal file
913
grub-core/video/readers/png.c
Normal file
|
@ -0,0 +1,913 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 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/bitmap.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/normal.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/bufio.h>
|
||||
|
||||
/* Uncomment following define to enable PNG debug. */
|
||||
//#define PNG_DEBUG
|
||||
|
||||
#define PNG_COLOR_MASK_PALETTE 1
|
||||
#define PNG_COLOR_MASK_COLOR 2
|
||||
#define PNG_COLOR_MASK_ALPHA 4
|
||||
|
||||
#define PNG_COLOR_TYPE_GRAY 0
|
||||
#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
|
||||
#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
|
||||
#define PNG_COLOR_TYPE_RGBA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
|
||||
#define PNG_COLOR_TYPE_GRAYA (PNG_COLOR_MASK_ALPHA)
|
||||
|
||||
#define PNG_COMPRESSION_BASE 0
|
||||
|
||||
#define PNG_INTERLACE_NONE 0
|
||||
#define PNG_INTERLACE_ADAM7 1
|
||||
|
||||
#define PNG_FILTER_TYPE_BASE 0
|
||||
|
||||
#define PNG_FILTER_VALUE_NONE 0
|
||||
#define PNG_FILTER_VALUE_SUB 1
|
||||
#define PNG_FILTER_VALUE_UP 2
|
||||
#define PNG_FILTER_VALUE_AVG 3
|
||||
#define PNG_FILTER_VALUE_PAETH 4
|
||||
#define PNG_FILTER_VALUE_LAST 5
|
||||
|
||||
#define PNG_CHUNK_IHDR 0x49484452
|
||||
#define PNG_CHUNK_IDAT 0x49444154
|
||||
#define PNG_CHUNK_IEND 0x49454e44
|
||||
|
||||
#define Z_DEFLATED 8
|
||||
#define Z_FLAG_DICT 32
|
||||
|
||||
#define INFLATE_STORED 0
|
||||
#define INFLATE_FIXED 1
|
||||
#define INFLATE_DYNAMIC 2
|
||||
|
||||
#define WSIZE 0x8000
|
||||
|
||||
#define DEFLATE_HCLEN_BASE 4
|
||||
#define DEFLATE_HCLEN_MAX 19
|
||||
#define DEFLATE_HLIT_BASE 257
|
||||
#define DEFLATE_HLIT_MAX 288
|
||||
#define DEFLATE_HDIST_BASE 1
|
||||
#define DEFLATE_HDIST_MAX 30
|
||||
|
||||
#define DEFLATE_HUFF_LEN 16
|
||||
|
||||
#ifdef PNG_DEBUG
|
||||
static grub_command_t cmd;
|
||||
#endif
|
||||
|
||||
struct huff_table
|
||||
{
|
||||
int *values, *maxval, *offset;
|
||||
int num_values, max_length;
|
||||
};
|
||||
|
||||
struct grub_png_data
|
||||
{
|
||||
grub_file_t file;
|
||||
struct grub_video_bitmap **bitmap;
|
||||
|
||||
int bit_count, bit_save;
|
||||
|
||||
grub_uint32_t next_offset;
|
||||
|
||||
int image_width, image_height, bpp, is_16bit, raw_bytes;
|
||||
grub_uint8_t *image_data;
|
||||
|
||||
int inside_idat, idat_remain;
|
||||
|
||||
int code_values[DEFLATE_HLIT_MAX];
|
||||
int code_maxval[DEFLATE_HUFF_LEN];
|
||||
int code_offset[DEFLATE_HUFF_LEN];
|
||||
|
||||
int dist_values[DEFLATE_HDIST_MAX];
|
||||
int dist_maxval[DEFLATE_HUFF_LEN];
|
||||
int dist_offset[DEFLATE_HUFF_LEN];
|
||||
|
||||
struct huff_table code_table;
|
||||
struct huff_table dist_table;
|
||||
|
||||
grub_uint8_t slide[WSIZE];
|
||||
int wp;
|
||||
|
||||
grub_uint8_t *cur_rgb;
|
||||
|
||||
int cur_column, cur_filter, first_line;
|
||||
};
|
||||
|
||||
static grub_uint32_t
|
||||
grub_png_get_dword (struct grub_png_data *data)
|
||||
{
|
||||
grub_uint32_t r;
|
||||
|
||||
r = 0;
|
||||
grub_file_read (data->file, &r, sizeof (grub_uint32_t));
|
||||
|
||||
return grub_be_to_cpu32 (r);
|
||||
}
|
||||
|
||||
static grub_uint8_t
|
||||
grub_png_get_byte (struct grub_png_data *data)
|
||||
{
|
||||
grub_uint8_t r;
|
||||
|
||||
if ((data->inside_idat) && (data->idat_remain == 0))
|
||||
{
|
||||
grub_uint32_t len, type;
|
||||
|
||||
do
|
||||
{
|
||||
/* Skip crc checksum. */
|
||||
grub_png_get_dword (data);
|
||||
|
||||
if (data->file->offset != data->next_offset)
|
||||
{
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: chunk size error");
|
||||
return 0;
|
||||
}
|
||||
|
||||
len = grub_png_get_dword (data);
|
||||
type = grub_png_get_dword (data);
|
||||
if (type != PNG_CHUNK_IDAT)
|
||||
{
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: unexpected end of data");
|
||||
return 0;
|
||||
}
|
||||
|
||||
data->next_offset = data->file->offset + len + 4;
|
||||
}
|
||||
while (len == 0);
|
||||
data->idat_remain = len;
|
||||
}
|
||||
|
||||
r = 0;
|
||||
grub_file_read (data->file, &r, 1);
|
||||
|
||||
if (data->inside_idat)
|
||||
data->idat_remain--;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int
|
||||
grub_png_get_bits (struct grub_png_data *data, int num)
|
||||
{
|
||||
int code, shift;
|
||||
|
||||
if (data->bit_count == 0)
|
||||
{
|
||||
data->bit_save = grub_png_get_byte (data);
|
||||
data->bit_count = 8;
|
||||
}
|
||||
|
||||
code = 0;
|
||||
shift = 0;
|
||||
while (grub_errno == 0)
|
||||
{
|
||||
int n;
|
||||
|
||||
n = data->bit_count;
|
||||
if (n > num)
|
||||
n = num;
|
||||
|
||||
code += (int) (data->bit_save & ((1 << n) - 1)) << shift;
|
||||
num -= n;
|
||||
if (!num)
|
||||
{
|
||||
data->bit_count -= n;
|
||||
data->bit_save >>= n;
|
||||
break;
|
||||
}
|
||||
|
||||
shift += n;
|
||||
|
||||
data->bit_save = grub_png_get_byte (data);
|
||||
data->bit_count = 8;
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_decode_image_header (struct grub_png_data *data)
|
||||
{
|
||||
int color_type;
|
||||
int color_bits;
|
||||
|
||||
data->image_width = grub_png_get_dword (data);
|
||||
data->image_height = grub_png_get_dword (data);
|
||||
|
||||
if ((!data->image_height) || (!data->image_width))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid image size");
|
||||
|
||||
color_bits = grub_png_get_byte (data);
|
||||
if ((color_bits != 8) && (color_bits != 16))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: bit depth must be 8 or 16");
|
||||
data->is_16bit = (color_bits == 16);
|
||||
|
||||
color_type = grub_png_get_byte (data);
|
||||
if (color_type == PNG_COLOR_TYPE_RGB)
|
||||
{
|
||||
if (grub_video_bitmap_create (data->bitmap, data->image_width,
|
||||
data->image_height,
|
||||
GRUB_VIDEO_BLIT_FORMAT_RGB_888))
|
||||
return grub_errno;
|
||||
data->bpp = 3;
|
||||
}
|
||||
else if (color_type == PNG_COLOR_TYPE_RGBA)
|
||||
{
|
||||
if (grub_video_bitmap_create (data->bitmap, data->image_width,
|
||||
data->image_height,
|
||||
GRUB_VIDEO_BLIT_FORMAT_RGBA_8888))
|
||||
return grub_errno;
|
||||
data->bpp = 4;
|
||||
}
|
||||
else
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: color type not supported");
|
||||
|
||||
if (data->is_16bit)
|
||||
{
|
||||
data->bpp <<= 1;
|
||||
|
||||
data->image_data = grub_malloc (data->image_height *
|
||||
data->image_width * data->bpp);
|
||||
if (grub_errno)
|
||||
return grub_errno;
|
||||
|
||||
data->cur_rgb = data->image_data;
|
||||
}
|
||||
else
|
||||
{
|
||||
data->image_data = 0;
|
||||
data->cur_rgb = (*data->bitmap)->data;
|
||||
}
|
||||
|
||||
data->raw_bytes = data->image_height * (data->image_width + 1) * data->bpp;
|
||||
|
||||
data->cur_column = 0;
|
||||
data->first_line = 1;
|
||||
|
||||
if (grub_png_get_byte (data) != PNG_COMPRESSION_BASE)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: compression method not supported");
|
||||
|
||||
if (grub_png_get_byte (data) != PNG_FILTER_TYPE_BASE)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: filter method not supported");
|
||||
|
||||
if (grub_png_get_byte (data) != PNG_INTERLACE_NONE)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: interlace method not supported");
|
||||
|
||||
/* Skip crc checksum. */
|
||||
grub_png_get_dword (data);
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
/* Order of the bit length code lengths. */
|
||||
static const grub_uint8_t bitorder[] = {
|
||||
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
|
||||
};
|
||||
|
||||
/* Copy lengths for literal codes 257..285. */
|
||||
static const int cplens[] = {
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
||||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
|
||||
};
|
||||
|
||||
/* Extra bits for literal codes 257..285. */
|
||||
static const grub_uint8_t cplext[] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
|
||||
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
|
||||
}; /* 99==invalid */
|
||||
|
||||
/* Copy offsets for distance codes 0..29. */
|
||||
static const int cpdist[] = {
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
8193, 12289, 16385, 24577
|
||||
};
|
||||
|
||||
/* Extra bits for distance codes. */
|
||||
static const grub_uint8_t cpdext[] = {
|
||||
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
|
||||
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
|
||||
12, 12, 13, 13
|
||||
};
|
||||
|
||||
static void
|
||||
grub_png_init_huff_table (struct huff_table *ht, int cur_maxlen,
|
||||
int *cur_values, int *cur_maxval, int *cur_offset)
|
||||
{
|
||||
ht->values = cur_values;
|
||||
ht->maxval = cur_maxval;
|
||||
ht->offset = cur_offset;
|
||||
ht->num_values = 0;
|
||||
ht->max_length = cur_maxlen;
|
||||
grub_memset (cur_maxval, 0, sizeof (int) * cur_maxlen);
|
||||
}
|
||||
|
||||
static void
|
||||
grub_png_insert_huff_item (struct huff_table *ht, int code, int len)
|
||||
{
|
||||
int i, n;
|
||||
|
||||
if (len == 0)
|
||||
return;
|
||||
|
||||
if (len > ht->max_length)
|
||||
{
|
||||
grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid code length");
|
||||
return;
|
||||
}
|
||||
|
||||
n = 0;
|
||||
for (i = len; i < ht->max_length; i++)
|
||||
n += ht->maxval[i];
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
ht->values[ht->num_values - i] = ht->values[ht->num_values - i - 1];
|
||||
|
||||
ht->values[ht->num_values - n] = code;
|
||||
ht->num_values++;
|
||||
ht->maxval[len - 1]++;
|
||||
}
|
||||
|
||||
static void
|
||||
grub_png_build_huff_table (struct huff_table *ht)
|
||||
{
|
||||
int base, ofs, i;
|
||||
|
||||
base = 0;
|
||||
ofs = 0;
|
||||
for (i = 0; i < ht->max_length; i++)
|
||||
{
|
||||
base += ht->maxval[i];
|
||||
ofs += ht->maxval[i];
|
||||
|
||||
ht->maxval[i] = base;
|
||||
ht->offset[i] = ofs - base;
|
||||
|
||||
base <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
grub_png_get_huff_code (struct grub_png_data *data, struct huff_table *ht)
|
||||
{
|
||||
int code, i;
|
||||
|
||||
code = 0;
|
||||
for (i = 0; i < ht->max_length; i++)
|
||||
{
|
||||
code = (code << 1) + grub_png_get_bits (data, 1);
|
||||
if (code < ht->maxval[i])
|
||||
return ht->values[code + ht->offset[i]];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_init_fixed_block (struct grub_png_data *data)
|
||||
{
|
||||
int i;
|
||||
|
||||
grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
|
||||
data->code_values, data->code_maxval,
|
||||
data->code_offset);
|
||||
|
||||
for (i = 0; i < 144; i++)
|
||||
grub_png_insert_huff_item (&data->code_table, i, 8);
|
||||
|
||||
for (; i < 256; i++)
|
||||
grub_png_insert_huff_item (&data->code_table, i, 9);
|
||||
|
||||
for (; i < 280; i++)
|
||||
grub_png_insert_huff_item (&data->code_table, i, 7);
|
||||
|
||||
for (; i < DEFLATE_HLIT_MAX; i++)
|
||||
grub_png_insert_huff_item (&data->code_table, i, 8);
|
||||
|
||||
grub_png_build_huff_table (&data->code_table);
|
||||
|
||||
grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
|
||||
data->dist_values, data->dist_maxval,
|
||||
data->dist_offset);
|
||||
|
||||
for (i = 0; i < DEFLATE_HDIST_MAX; i++)
|
||||
grub_png_insert_huff_item (&data->dist_table, i, 5);
|
||||
|
||||
grub_png_build_huff_table (&data->dist_table);
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_init_dynamic_block (struct grub_png_data *data)
|
||||
{
|
||||
int nl, nd, nb, i, prev;
|
||||
struct huff_table cl;
|
||||
int cl_values[sizeof (bitorder)];
|
||||
int cl_maxval[8];
|
||||
int cl_offset[8];
|
||||
grub_uint8_t lens[DEFLATE_HCLEN_MAX];
|
||||
|
||||
nl = DEFLATE_HLIT_BASE + grub_png_get_bits (data, 5);
|
||||
nd = DEFLATE_HDIST_BASE + grub_png_get_bits (data, 5);
|
||||
nb = DEFLATE_HCLEN_BASE + grub_png_get_bits (data, 4);
|
||||
|
||||
if ((nl > DEFLATE_HLIT_MAX) || (nd > DEFLATE_HDIST_MAX) ||
|
||||
(nb > DEFLATE_HCLEN_MAX))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: too much data");
|
||||
|
||||
grub_png_init_huff_table (&cl, 8, cl_values, cl_maxval, cl_offset);
|
||||
|
||||
for (i = 0; i < nb; i++)
|
||||
lens[bitorder[i]] = grub_png_get_bits (data, 3);
|
||||
|
||||
for (; i < DEFLATE_HCLEN_MAX; i++)
|
||||
lens[bitorder[i]] = 0;
|
||||
|
||||
for (i = 0; i < DEFLATE_HCLEN_MAX; i++)
|
||||
grub_png_insert_huff_item (&cl, i, lens[i]);
|
||||
|
||||
grub_png_build_huff_table (&cl);
|
||||
|
||||
grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
|
||||
data->code_values, data->code_maxval,
|
||||
data->code_offset);
|
||||
|
||||
grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
|
||||
data->dist_values, data->dist_maxval,
|
||||
data->dist_offset);
|
||||
|
||||
prev = 0;
|
||||
for (i = 0; i < nl + nd; i++)
|
||||
{
|
||||
int n, code;
|
||||
struct huff_table *ht;
|
||||
|
||||
if (grub_errno)
|
||||
return grub_errno;
|
||||
|
||||
if (i < nl)
|
||||
{
|
||||
ht = &data->code_table;
|
||||
code = i;
|
||||
}
|
||||
else
|
||||
{
|
||||
ht = &data->dist_table;
|
||||
code = i - nl;
|
||||
}
|
||||
|
||||
n = grub_png_get_huff_code (data, &cl);
|
||||
if (n < 16)
|
||||
{
|
||||
grub_png_insert_huff_item (ht, code, n);
|
||||
prev = n;
|
||||
}
|
||||
else if (n == 16)
|
||||
{
|
||||
int c;
|
||||
|
||||
c = 3 + grub_png_get_bits (data, 2);
|
||||
while (c > 0)
|
||||
{
|
||||
grub_png_insert_huff_item (ht, code++, prev);
|
||||
i++;
|
||||
c--;
|
||||
}
|
||||
i--;
|
||||
}
|
||||
else if (n == 17)
|
||||
i += 3 + grub_png_get_bits (data, 3) - 1;
|
||||
else
|
||||
i += 11 + grub_png_get_bits (data, 7) - 1;
|
||||
}
|
||||
|
||||
grub_png_build_huff_table (&data->code_table);
|
||||
grub_png_build_huff_table (&data->dist_table);
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_output_byte (struct grub_png_data *data, grub_uint8_t n)
|
||||
{
|
||||
int row_bytes;
|
||||
|
||||
if (--data->raw_bytes < 0)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "image size overflown");
|
||||
|
||||
if (data->cur_column == 0)
|
||||
{
|
||||
if (n >= PNG_FILTER_VALUE_LAST)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid filter value");
|
||||
|
||||
data->cur_filter = n;
|
||||
}
|
||||
else
|
||||
*(data->cur_rgb++) = n;
|
||||
|
||||
data->cur_column++;
|
||||
row_bytes = data->image_width * data->bpp;
|
||||
if (data->cur_column == row_bytes + 1)
|
||||
{
|
||||
grub_uint8_t *blank_line = NULL;
|
||||
grub_uint8_t *cur = data->cur_rgb - row_bytes;
|
||||
grub_uint8_t *left = cur;
|
||||
grub_uint8_t *up;
|
||||
|
||||
if (data->first_line)
|
||||
{
|
||||
blank_line = grub_zalloc (row_bytes);
|
||||
if (blank_line == NULL)
|
||||
return grub_errno;
|
||||
|
||||
up = blank_line;
|
||||
}
|
||||
else
|
||||
up = cur - row_bytes;
|
||||
|
||||
switch (data->cur_filter)
|
||||
{
|
||||
case PNG_FILTER_VALUE_SUB:
|
||||
{
|
||||
int i;
|
||||
|
||||
cur += data->bpp;
|
||||
for (i = data->bpp; i < row_bytes; i++, cur++, left++)
|
||||
*cur += *left;
|
||||
|
||||
break;
|
||||
}
|
||||
case PNG_FILTER_VALUE_UP:
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < row_bytes; i++, cur++, up++)
|
||||
*cur += *up;
|
||||
|
||||
break;
|
||||
}
|
||||
case PNG_FILTER_VALUE_AVG:
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < data->bpp; i++, cur++, up++)
|
||||
*cur += *up >> 1;
|
||||
|
||||
for (; i < row_bytes; i++, cur++, up++, left++)
|
||||
*cur += ((int) *up + (int) *left) >> 1;
|
||||
|
||||
break;
|
||||
}
|
||||
case PNG_FILTER_VALUE_PAETH:
|
||||
{
|
||||
int i;
|
||||
grub_uint8_t *upper_left = up;
|
||||
|
||||
for (i = 0; i < data->bpp; i++, cur++, up++)
|
||||
*cur += *up;
|
||||
|
||||
for (; i < row_bytes; i++, cur++, up++, left++, upper_left++)
|
||||
{
|
||||
int a, b, c, pa, pb, pc;
|
||||
|
||||
a = *left;
|
||||
b = *up;
|
||||
c = *upper_left;
|
||||
|
||||
pa = b - c;
|
||||
pb = a - c;
|
||||
pc = pa + pb;
|
||||
|
||||
if (pa < 0)
|
||||
pa = -pa;
|
||||
|
||||
if (pb < 0)
|
||||
pb = -pb;
|
||||
|
||||
if (pc < 0)
|
||||
pc = -pc;
|
||||
|
||||
*cur += ((pa <= pb) && (pa <= pc)) ? a : (pb <= pc) ? b : c;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (blank_line)
|
||||
grub_free (blank_line);
|
||||
|
||||
data->cur_column = 0;
|
||||
data->first_line = 0;
|
||||
}
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_read_dynamic_block (struct grub_png_data *data)
|
||||
{
|
||||
while (grub_errno == 0)
|
||||
{
|
||||
int n;
|
||||
|
||||
n = grub_png_get_huff_code (data, &data->code_table);
|
||||
if (n < 256)
|
||||
{
|
||||
data->slide[data->wp] = n;
|
||||
grub_png_output_byte (data, n);
|
||||
|
||||
data->wp++;
|
||||
if (data->wp >= WSIZE)
|
||||
data->wp = 0;
|
||||
}
|
||||
else if (n == 256)
|
||||
break;
|
||||
else
|
||||
{
|
||||
int len, dist, pos;
|
||||
|
||||
n -= 257;
|
||||
len = cplens[n];
|
||||
if (cplext[n])
|
||||
len += grub_png_get_bits (data, cplext[n]);
|
||||
|
||||
n = grub_png_get_huff_code (data, &data->dist_table);
|
||||
dist = cpdist[n];
|
||||
if (cpdext[n])
|
||||
dist += grub_png_get_bits (data, cpdext[n]);
|
||||
|
||||
pos = data->wp - dist;
|
||||
if (pos < 0)
|
||||
pos += WSIZE;
|
||||
|
||||
while (len > 0)
|
||||
{
|
||||
data->slide[data->wp] = data->slide[pos];
|
||||
grub_png_output_byte (data, data->slide[data->wp]);
|
||||
|
||||
data->wp++;
|
||||
if (data->wp >= WSIZE)
|
||||
data->wp = 0;
|
||||
|
||||
pos++;
|
||||
if (pos >= WSIZE)
|
||||
pos = 0;
|
||||
|
||||
len--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_decode_image_data (struct grub_png_data *data)
|
||||
{
|
||||
grub_uint8_t cmf, flg;
|
||||
int final;
|
||||
|
||||
cmf = grub_png_get_byte (data);
|
||||
flg = grub_png_get_byte (data);
|
||||
|
||||
if ((cmf & 0xF) != Z_DEFLATED)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: only support deflate compression method");
|
||||
|
||||
if (flg & Z_FLAG_DICT)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: dictionary not supported");
|
||||
|
||||
do
|
||||
{
|
||||
int block_type;
|
||||
|
||||
final = grub_png_get_bits (data, 1);
|
||||
block_type = grub_png_get_bits (data, 2);
|
||||
|
||||
switch (block_type)
|
||||
{
|
||||
case INFLATE_STORED:
|
||||
{
|
||||
grub_uint16_t i, len;
|
||||
|
||||
data->bit_count = 0;
|
||||
len = grub_png_get_byte (data);
|
||||
len += ((grub_uint16_t) grub_png_get_byte (data)) << 8;
|
||||
|
||||
/* Skip NLEN field. */
|
||||
grub_png_get_byte (data);
|
||||
grub_png_get_byte (data);
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
grub_png_output_byte (data, grub_png_get_byte (data));
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case INFLATE_FIXED:
|
||||
grub_png_init_fixed_block (data);
|
||||
grub_png_read_dynamic_block (data);
|
||||
break;
|
||||
|
||||
case INFLATE_DYNAMIC:
|
||||
grub_png_init_dynamic_block (data);
|
||||
grub_png_read_dynamic_block (data);
|
||||
break;
|
||||
|
||||
default:
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: unknown block type");
|
||||
}
|
||||
}
|
||||
while ((!final) && (grub_errno == 0));
|
||||
|
||||
/* Skip adler checksum. */
|
||||
grub_png_get_dword (data);
|
||||
|
||||
/* Skip crc checksum. */
|
||||
grub_png_get_dword (data);
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static const grub_uint8_t png_magic[8] =
|
||||
{ 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0x0a };
|
||||
|
||||
static void
|
||||
grub_png_convert_image (struct grub_png_data *data)
|
||||
{
|
||||
int i;
|
||||
grub_uint8_t *d1, *d2;
|
||||
|
||||
d1 = (*data->bitmap)->data;
|
||||
d2 = data->image_data + 1;
|
||||
|
||||
/* Only copy the upper 8 bit. */
|
||||
for (i = 0; i < (data->image_width * data->image_height * data->bpp >> 1);
|
||||
i++, d1++, d2+=2)
|
||||
*d1 = *d2;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_png_decode_png (struct grub_png_data *data)
|
||||
{
|
||||
grub_uint8_t magic[8];
|
||||
|
||||
if (grub_file_read (data->file, &magic[0], 8) != 8)
|
||||
return grub_errno;
|
||||
|
||||
if (grub_memcmp (magic, png_magic, sizeof (png_magic)))
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: not a png file");
|
||||
|
||||
while (1)
|
||||
{
|
||||
grub_uint32_t len, type;
|
||||
|
||||
len = grub_png_get_dword (data);
|
||||
type = grub_png_get_dword (data);
|
||||
data->next_offset = data->file->offset + len + 4;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case PNG_CHUNK_IHDR:
|
||||
grub_png_decode_image_header (data);
|
||||
break;
|
||||
|
||||
case PNG_CHUNK_IDAT:
|
||||
data->inside_idat = 1;
|
||||
data->idat_remain = len;
|
||||
data->bit_count = 0;
|
||||
|
||||
grub_png_decode_image_data (data);
|
||||
|
||||
data->inside_idat = 0;
|
||||
break;
|
||||
|
||||
case PNG_CHUNK_IEND:
|
||||
if (data->is_16bit)
|
||||
grub_png_convert_image (data);
|
||||
|
||||
return grub_errno;
|
||||
|
||||
default:
|
||||
grub_file_seek (data->file, data->file->offset + len + 4);
|
||||
}
|
||||
|
||||
if (grub_errno)
|
||||
break;
|
||||
|
||||
if (data->file->offset != data->next_offset)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"png: chunk size error");
|
||||
}
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_reader_png (struct grub_video_bitmap **bitmap,
|
||||
const char *filename)
|
||||
{
|
||||
grub_file_t file;
|
||||
struct grub_png_data *data;
|
||||
|
||||
file = grub_buffile_open (filename, 0);
|
||||
if (!file)
|
||||
return grub_errno;
|
||||
|
||||
data = grub_zalloc (sizeof (*data));
|
||||
if (data != NULL)
|
||||
{
|
||||
data->file = file;
|
||||
data->bitmap = bitmap;
|
||||
|
||||
grub_png_decode_png (data);
|
||||
|
||||
grub_free (data->image_data);
|
||||
grub_free (data);
|
||||
}
|
||||
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_video_bitmap_destroy (*bitmap);
|
||||
*bitmap = 0;
|
||||
}
|
||||
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
#if defined(PNG_DEBUG)
|
||||
static grub_err_t
|
||||
grub_cmd_pngtest (grub_command_t cmd __attribute__ ((unused)),
|
||||
int argc, char **args)
|
||||
{
|
||||
struct grub_video_bitmap *bitmap = 0;
|
||||
|
||||
if (argc != 1)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
|
||||
|
||||
grub_video_reader_png (&bitmap, args[0]);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
grub_video_bitmap_destroy (bitmap);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct grub_video_bitmap_reader png_reader = {
|
||||
.extension = ".png",
|
||||
.reader = grub_video_reader_png,
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT (png)
|
||||
{
|
||||
grub_video_bitmap_reader_register (&png_reader);
|
||||
#if defined(PNG_DEBUG)
|
||||
cmd = grub_register_command ("pngtest", grub_cmd_pngtest,
|
||||
"FILE",
|
||||
"Tests loading of PNG bitmap.");
|
||||
#endif
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI (png)
|
||||
{
|
||||
#if defined(PNG_DEBUG)
|
||||
grub_unregister_command (cmd);
|
||||
#endif
|
||||
grub_video_bitmap_reader_unregister (&png_reader);
|
||||
}
|
495
grub-core/video/readers/tga.c
Normal file
495
grub-core/video/readers/tga.c
Normal file
|
@ -0,0 +1,495 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2006,2007 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/bitmap.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/normal.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/bufio.h>
|
||||
|
||||
/* Uncomment following define to enable TGA debug. */
|
||||
//#define TGA_DEBUG
|
||||
|
||||
#if defined(TGA_DEBUG)
|
||||
#define dump_int_field(x) grub_printf( #x " = %d (0x%04x)\n", x, x);
|
||||
static grub_command_t cmd;
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
GRUB_TGA_IMAGE_TYPE_NONE = 0,
|
||||
GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_INDEXCOLOR = 1,
|
||||
GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR = 2,
|
||||
GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_BLACK_AND_WHITE = 3,
|
||||
GRUB_TGA_IMAGE_TYPE_RLE_INDEXCOLOR = 9,
|
||||
GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR = 10,
|
||||
GRUB_TGA_IMAGE_TYPE_RLE_BLACK_AND_WHITE = 11,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
GRUB_TGA_COLOR_MAP_TYPE_NONE = 0,
|
||||
GRUB_TGA_COLOR_MAP_TYPE_INCLUDED = 1
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
GRUB_TGA_IMAGE_ORIGIN_RIGHT = 0x10,
|
||||
GRUB_TGA_IMAGE_ORIGIN_TOP = 0x20
|
||||
};
|
||||
|
||||
struct grub_tga_header
|
||||
{
|
||||
grub_uint8_t id_length;
|
||||
grub_uint8_t color_map_type;
|
||||
grub_uint8_t image_type;
|
||||
|
||||
/* Color Map Specification. */
|
||||
grub_uint16_t color_map_first_index;
|
||||
grub_uint16_t color_map_length;
|
||||
grub_uint8_t color_map_bpp;
|
||||
|
||||
/* Image Specification. */
|
||||
grub_uint16_t image_x_origin;
|
||||
grub_uint16_t image_y_origin;
|
||||
grub_uint16_t image_width;
|
||||
grub_uint16_t image_height;
|
||||
grub_uint8_t image_bpp;
|
||||
grub_uint8_t image_descriptor;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
static grub_err_t
|
||||
tga_load_truecolor_rle_R8G8B8 (struct grub_video_bitmap *bitmap,
|
||||
struct grub_tga_header *header,
|
||||
grub_file_t file)
|
||||
{
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
grub_uint8_t type;
|
||||
grub_uint8_t *ptr;
|
||||
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
|
||||
grub_uint8_t bytes_per_pixel;
|
||||
|
||||
bytes_per_pixel = header->image_bpp / 8;
|
||||
|
||||
for (y = 0; y < header->image_height; y++)
|
||||
{
|
||||
ptr = bitmap->data;
|
||||
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
|
||||
ptr += y * bitmap->mode_info.pitch;
|
||||
else
|
||||
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
|
||||
|
||||
for (x = 0; x < header->image_width;)
|
||||
{
|
||||
if (grub_file_read (file, &type, sizeof (type)) != sizeof(type))
|
||||
return grub_errno;
|
||||
|
||||
if (type & 0x80)
|
||||
{
|
||||
/* RLE-encoded packet. */
|
||||
type &= 0x7f;
|
||||
type++;
|
||||
|
||||
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
|
||||
!= bytes_per_pixel)
|
||||
return grub_errno;
|
||||
|
||||
while (type)
|
||||
{
|
||||
if (x < header->image_width)
|
||||
{
|
||||
ptr[0] = tmp[2];
|
||||
ptr[1] = tmp[1];
|
||||
ptr[2] = tmp[0];
|
||||
ptr += 3;
|
||||
}
|
||||
|
||||
type--;
|
||||
x++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* RAW-encoded packet. */
|
||||
type++;
|
||||
|
||||
while (type)
|
||||
{
|
||||
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
|
||||
!= bytes_per_pixel)
|
||||
return grub_errno;
|
||||
|
||||
if (x < header->image_width)
|
||||
{
|
||||
ptr[0] = tmp[2];
|
||||
ptr[1] = tmp[1];
|
||||
ptr[2] = tmp[0];
|
||||
ptr += 3;
|
||||
}
|
||||
|
||||
type--;
|
||||
x++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
tga_load_truecolor_rle_R8G8B8A8 (struct grub_video_bitmap *bitmap,
|
||||
struct grub_tga_header *header,
|
||||
grub_file_t file)
|
||||
{
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
grub_uint8_t type;
|
||||
grub_uint8_t *ptr;
|
||||
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
|
||||
grub_uint8_t bytes_per_pixel;
|
||||
|
||||
bytes_per_pixel = header->image_bpp / 8;
|
||||
|
||||
for (y = 0; y < header->image_height; y++)
|
||||
{
|
||||
ptr = bitmap->data;
|
||||
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
|
||||
ptr += y * bitmap->mode_info.pitch;
|
||||
else
|
||||
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
|
||||
|
||||
for (x = 0; x < header->image_width;)
|
||||
{
|
||||
if (grub_file_read (file, &type, sizeof (type)) != sizeof(type))
|
||||
return grub_errno;
|
||||
|
||||
if (type & 0x80)
|
||||
{
|
||||
/* RLE-encoded packet. */
|
||||
type &= 0x7f;
|
||||
type++;
|
||||
|
||||
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
|
||||
!= bytes_per_pixel)
|
||||
return grub_errno;
|
||||
|
||||
while (type)
|
||||
{
|
||||
if (x < header->image_width)
|
||||
{
|
||||
ptr[0] = tmp[2];
|
||||
ptr[1] = tmp[1];
|
||||
ptr[2] = tmp[0];
|
||||
ptr[3] = tmp[3];
|
||||
ptr += 4;
|
||||
}
|
||||
|
||||
type--;
|
||||
x++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* RAW-encoded packet. */
|
||||
type++;
|
||||
|
||||
while (type)
|
||||
{
|
||||
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
|
||||
!= bytes_per_pixel)
|
||||
return grub_errno;
|
||||
|
||||
if (x < header->image_width)
|
||||
{
|
||||
ptr[0] = tmp[2];
|
||||
ptr[1] = tmp[1];
|
||||
ptr[2] = tmp[0];
|
||||
ptr[3] = tmp[3];
|
||||
ptr += 4;
|
||||
}
|
||||
|
||||
type--;
|
||||
x++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
tga_load_truecolor_R8G8B8 (struct grub_video_bitmap *bitmap,
|
||||
struct grub_tga_header *header,
|
||||
grub_file_t file)
|
||||
{
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
grub_uint8_t *ptr;
|
||||
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
|
||||
grub_uint8_t bytes_per_pixel;
|
||||
|
||||
bytes_per_pixel = header->image_bpp / 8;
|
||||
|
||||
for (y = 0; y < header->image_height; y++)
|
||||
{
|
||||
ptr = bitmap->data;
|
||||
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
|
||||
ptr += y * bitmap->mode_info.pitch;
|
||||
else
|
||||
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
|
||||
|
||||
for (x = 0; x < header->image_width; x++)
|
||||
{
|
||||
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
|
||||
!= bytes_per_pixel)
|
||||
return grub_errno;
|
||||
|
||||
ptr[0] = tmp[2];
|
||||
ptr[1] = tmp[1];
|
||||
ptr[2] = tmp[0];
|
||||
|
||||
ptr += 3;
|
||||
}
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
tga_load_truecolor_R8G8B8A8 (struct grub_video_bitmap *bitmap,
|
||||
struct grub_tga_header *header,
|
||||
grub_file_t file)
|
||||
{
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
grub_uint8_t *ptr;
|
||||
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
|
||||
grub_uint8_t bytes_per_pixel;
|
||||
|
||||
bytes_per_pixel = header->image_bpp / 8;
|
||||
|
||||
for (y = 0; y < header->image_height; y++)
|
||||
{
|
||||
ptr = bitmap->data;
|
||||
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
|
||||
ptr += y * bitmap->mode_info.pitch;
|
||||
else
|
||||
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
|
||||
|
||||
for (x = 0; x < header->image_width; x++)
|
||||
{
|
||||
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
|
||||
!= bytes_per_pixel)
|
||||
return grub_errno;
|
||||
|
||||
ptr[0] = tmp[2];
|
||||
ptr[1] = tmp[1];
|
||||
ptr[2] = tmp[0];
|
||||
ptr[3] = tmp[3];
|
||||
|
||||
ptr += 4;
|
||||
}
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_reader_tga (struct grub_video_bitmap **bitmap,
|
||||
const char *filename)
|
||||
{
|
||||
grub_file_t file;
|
||||
grub_ssize_t pos;
|
||||
struct grub_tga_header header;
|
||||
int has_alpha;
|
||||
|
||||
file = grub_buffile_open (filename, 0);
|
||||
if (! file)
|
||||
return grub_errno;
|
||||
|
||||
/* TGA Specification states that we SHOULD start by reading
|
||||
ID from end of file, but we really don't care about that as we are
|
||||
not going to support developer area & extensions at this point. */
|
||||
|
||||
/* Read TGA header from beginning of file. */
|
||||
if (grub_file_read (file, &header, sizeof (header))
|
||||
!= sizeof (header))
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
/* Skip ID field. */
|
||||
pos = grub_file_tell (file);
|
||||
pos += header.id_length;
|
||||
grub_file_seek (file, pos);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
#if defined(TGA_DEBUG)
|
||||
grub_printf("tga: header\n");
|
||||
dump_int_field(header.id_length);
|
||||
dump_int_field(header.color_map_type);
|
||||
dump_int_field(header.image_type);
|
||||
dump_int_field(header.color_map_first_index);
|
||||
dump_int_field(header.color_map_length);
|
||||
dump_int_field(header.color_map_bpp);
|
||||
dump_int_field(header.image_x_origin);
|
||||
dump_int_field(header.image_y_origin);
|
||||
dump_int_field(header.image_width);
|
||||
dump_int_field(header.image_height);
|
||||
dump_int_field(header.image_bpp);
|
||||
dump_int_field(header.image_descriptor);
|
||||
#endif
|
||||
|
||||
/* Check that bitmap encoding is supported. */
|
||||
switch (header.image_type)
|
||||
{
|
||||
case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
|
||||
case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
|
||||
break;
|
||||
|
||||
default:
|
||||
grub_file_close (file);
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"unsupported bitmap format (unknown encoding)");
|
||||
}
|
||||
|
||||
/* Check that bitmap depth is supported. */
|
||||
switch (header.image_bpp)
|
||||
{
|
||||
case 24:
|
||||
has_alpha = 0;
|
||||
break;
|
||||
|
||||
case 32:
|
||||
has_alpha = 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
grub_file_close (file);
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"unsupported bitmap format (bpp=%d)",
|
||||
header.image_bpp);
|
||||
}
|
||||
|
||||
/* Allocate bitmap. If there is alpha information store it too. */
|
||||
if (has_alpha)
|
||||
{
|
||||
grub_video_bitmap_create (bitmap, header.image_width,
|
||||
header.image_height,
|
||||
GRUB_VIDEO_BLIT_FORMAT_RGBA_8888);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
/* Load bitmap data. */
|
||||
switch (header.image_type)
|
||||
{
|
||||
case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
|
||||
tga_load_truecolor_R8G8B8A8 (*bitmap, &header, file);
|
||||
break;
|
||||
|
||||
case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
|
||||
tga_load_truecolor_rle_R8G8B8A8 (*bitmap, &header, file);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
grub_video_bitmap_create (bitmap, header.image_width,
|
||||
header.image_height,
|
||||
GRUB_VIDEO_BLIT_FORMAT_RGB_888);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
/* Load bitmap data. */
|
||||
switch (header.image_type)
|
||||
{
|
||||
case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
|
||||
tga_load_truecolor_R8G8B8 (*bitmap, &header, file);
|
||||
break;
|
||||
|
||||
case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
|
||||
tga_load_truecolor_rle_R8G8B8 (*bitmap, &header, file);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* If there was a loading problem, destroy bitmap. */
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_video_bitmap_destroy (*bitmap);
|
||||
*bitmap = 0;
|
||||
}
|
||||
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
#if defined(TGA_DEBUG)
|
||||
static grub_err_t
|
||||
grub_cmd_tgatest (grub_command_t cmd __attribute__ ((unused)),
|
||||
int argc, char **args)
|
||||
{
|
||||
struct grub_video_bitmap *bitmap = 0;
|
||||
|
||||
if (argc != 1)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
|
||||
|
||||
grub_video_reader_tga (&bitmap, args[0]);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
grub_video_bitmap_destroy (bitmap);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct grub_video_bitmap_reader tga_reader = {
|
||||
.extension = ".tga",
|
||||
.reader = grub_video_reader_tga,
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(tga)
|
||||
{
|
||||
grub_video_bitmap_reader_register (&tga_reader);
|
||||
#if defined(TGA_DEBUG)
|
||||
cmd = grub_register_command ("tgatest", grub_cmd_tgatest,
|
||||
"FILE", "Tests loading of TGA bitmap.");
|
||||
#endif
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(tga)
|
||||
{
|
||||
#if defined(TGA_DEBUG)
|
||||
grub_unregister_command (cmd);
|
||||
#endif
|
||||
grub_video_bitmap_reader_unregister (&tga_reader);
|
||||
}
|
230
grub-core/video/sm712.c
Normal file
230
grub-core/video/sm712.c
Normal file
|
@ -0,0 +1,230 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2005,2006,2007,2008,2009,2010 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/>.
|
||||
*/
|
||||
|
||||
#define grub_video_render_target grub_video_fbrender_target
|
||||
|
||||
#include <grub/err.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/video.h>
|
||||
#include <grub/video_fb.h>
|
||||
#include <grub/pci.h>
|
||||
|
||||
static struct
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
struct grub_video_render_target *render_target;
|
||||
|
||||
unsigned int bytes_per_scan_line;
|
||||
unsigned int bytes_per_pixel;
|
||||
grub_uint8_t *ptr;
|
||||
int index_color_mode;
|
||||
int mapped;
|
||||
grub_uint32_t base;
|
||||
grub_pci_device_t dev;
|
||||
} framebuffer;
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_video_init (void)
|
||||
{
|
||||
/* Reset frame buffer. */
|
||||
grub_memset (&framebuffer, 0, sizeof(framebuffer));
|
||||
|
||||
return grub_video_fb_init ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_video_fini (void)
|
||||
{
|
||||
if (framebuffer.mapped)
|
||||
grub_pci_device_unmap_range (framebuffer.dev, framebuffer.ptr,
|
||||
1024 * 600 * 2);
|
||||
|
||||
return grub_video_fb_fini ();
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_setup (unsigned int width, unsigned int height,
|
||||
unsigned int mode_type, unsigned int mode_mask __attribute__ ((unused)))
|
||||
{
|
||||
int depth;
|
||||
grub_err_t err;
|
||||
int found = 0;
|
||||
|
||||
auto int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid __attribute__ ((unused)));
|
||||
int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid __attribute__ ((unused)))
|
||||
{
|
||||
grub_pci_address_t addr;
|
||||
grub_uint32_t class;
|
||||
|
||||
addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
|
||||
class = grub_pci_read (addr);
|
||||
|
||||
if (((class >> 16) & 0xffff) != 0x0300 || pciid != 0x0712126f)
|
||||
return 0;
|
||||
|
||||
found = 1;
|
||||
|
||||
addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
|
||||
framebuffer.base = grub_pci_read (addr);
|
||||
framebuffer.dev = dev;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Decode depth from mode_type. If it is zero, then autodetect. */
|
||||
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
|
||||
|
||||
if ((width != 1024 && width != 0) || (height != 600 && height != 0)
|
||||
|| (depth != 16 && depth != 0))
|
||||
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
|
||||
"Only 1024x600x16 is supported");
|
||||
|
||||
grub_pci_iterate (find_card);
|
||||
if (!found)
|
||||
return grub_error (GRUB_ERR_IO, "Couldn't find graphics card");
|
||||
|
||||
if (found && framebuffer.base == 0)
|
||||
{
|
||||
/* FIXME: change framebuffer base */
|
||||
}
|
||||
|
||||
/* Fill mode info details. */
|
||||
framebuffer.mode_info.width = 1024;
|
||||
framebuffer.mode_info.height = 600;
|
||||
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
|
||||
framebuffer.mode_info.bpp = 16;
|
||||
framebuffer.mode_info.bytes_per_pixel = 2;
|
||||
framebuffer.mode_info.pitch = 1024 * 2;
|
||||
framebuffer.mode_info.number_of_colors = 256;
|
||||
framebuffer.mode_info.red_mask_size = 5;
|
||||
framebuffer.mode_info.red_field_pos = 11;
|
||||
framebuffer.mode_info.green_mask_size = 6;
|
||||
framebuffer.mode_info.green_field_pos = 5;
|
||||
framebuffer.mode_info.blue_mask_size = 5;
|
||||
framebuffer.mode_info.blue_field_pos = 0;
|
||||
framebuffer.mode_info.reserved_mask_size = 0;
|
||||
framebuffer.mode_info.reserved_field_pos = 0;
|
||||
framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
|
||||
/* We can safely discard volatile attribute. */
|
||||
framebuffer.ptr = (void *) grub_pci_device_map_range (framebuffer.dev,
|
||||
framebuffer.base,
|
||||
1024 * 600 * 2);
|
||||
framebuffer.mapped = 1;
|
||||
|
||||
err = grub_video_fb_create_render_target_from_pointer (&framebuffer.render_target, &framebuffer.mode_info, framebuffer.ptr);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Copy default palette to initialize emulated palette. */
|
||||
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
|
||||
grub_video_fbstd_colors);
|
||||
return err;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data)
|
||||
{
|
||||
if (framebuffer.index_color_mode)
|
||||
{
|
||||
/* TODO: Implement setting indexed color mode palette to hardware. */
|
||||
}
|
||||
|
||||
/* Then set color to emulated palette. */
|
||||
return grub_video_fb_set_palette (start, count, palette_data);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_swap_buffers (void)
|
||||
{
|
||||
/* TODO: Implement buffer swapping. */
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
|
||||
target = framebuffer.render_target;
|
||||
|
||||
return grub_video_fb_set_active_render_target (target);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_video_sm712_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;
|
||||
|
||||
grub_video_fb_fini ();
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
|
||||
static struct grub_video_adapter grub_video_sm712_adapter =
|
||||
{
|
||||
.name = "SM712 Video Driver",
|
||||
.id = GRUB_VIDEO_DRIVER_SM712,
|
||||
|
||||
.init = grub_video_sm712_video_init,
|
||||
.fini = grub_video_sm712_video_fini,
|
||||
.setup = grub_video_sm712_setup,
|
||||
.get_info = grub_video_fb_get_info,
|
||||
.get_info_and_fini = grub_video_sm712_get_info_and_fini,
|
||||
.set_palette = grub_video_sm712_set_palette,
|
||||
.get_palette = grub_video_fb_get_palette,
|
||||
.set_viewport = grub_video_fb_set_viewport,
|
||||
.get_viewport = grub_video_fb_get_viewport,
|
||||
.map_color = grub_video_fb_map_color,
|
||||
.map_rgb = grub_video_fb_map_rgb,
|
||||
.map_rgba = grub_video_fb_map_rgba,
|
||||
.unmap_color = grub_video_fb_unmap_color,
|
||||
.fill_rect = grub_video_fb_fill_rect,
|
||||
.blit_bitmap = grub_video_fb_blit_bitmap,
|
||||
.blit_render_target = grub_video_fb_blit_render_target,
|
||||
.scroll = grub_video_fb_scroll,
|
||||
.swap_buffers = grub_video_sm712_swap_buffers,
|
||||
.create_render_target = grub_video_fb_create_render_target,
|
||||
.delete_render_target = grub_video_fb_delete_render_target,
|
||||
.set_active_render_target = grub_video_sm712_set_active_render_target,
|
||||
.get_active_render_target = grub_video_fb_get_active_render_target,
|
||||
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(video_sm712)
|
||||
{
|
||||
grub_video_register (&grub_video_sm712_adapter);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(video_sm712)
|
||||
{
|
||||
grub_video_unregister (&grub_video_sm712_adapter);
|
||||
}
|
706
grub-core/video/video.c
Normal file
706
grub-core/video/video.c
Normal file
|
@ -0,0 +1,706 @@
|
|||
/*
|
||||
* 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/video.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
|
||||
/* The list of video adapters registered to system. */
|
||||
static grub_video_adapter_t grub_video_adapter_list;
|
||||
|
||||
/* Active video adapter. */
|
||||
static grub_video_adapter_t grub_video_adapter_active;
|
||||
|
||||
/* Register video driver. */
|
||||
void
|
||||
grub_video_register (grub_video_adapter_t adapter)
|
||||
{
|
||||
adapter->next = grub_video_adapter_list;
|
||||
grub_video_adapter_list = adapter;
|
||||
}
|
||||
|
||||
/* Unregister video driver. */
|
||||
void
|
||||
grub_video_unregister (grub_video_adapter_t adapter)
|
||||
{
|
||||
grub_video_adapter_t *p, q;
|
||||
|
||||
for (p = &grub_video_adapter_list, q = *p; q; p = &(q->next), q = q->next)
|
||||
if (q == adapter)
|
||||
{
|
||||
*p = q->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Iterate thru all registered video drivers. */
|
||||
void
|
||||
grub_video_iterate (int (*hook) (grub_video_adapter_t adapter))
|
||||
{
|
||||
grub_video_adapter_t p;
|
||||
|
||||
for (p = grub_video_adapter_list; p; p = p->next)
|
||||
if (hook (p))
|
||||
break;
|
||||
}
|
||||
|
||||
/* Restore back to initial mode (where applicable). */
|
||||
grub_err_t
|
||||
grub_video_restore (void)
|
||||
{
|
||||
if (grub_video_adapter_active)
|
||||
{
|
||||
grub_video_adapter_active->fini ();
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_errno;
|
||||
|
||||
grub_video_adapter_active = 0;
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Get information about active video mode. */
|
||||
grub_err_t
|
||||
grub_video_get_info (struct grub_video_mode_info *mode_info)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
/* If mode_info is NULL just report that video adapter is active. */
|
||||
if (! mode_info)
|
||||
{
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
return grub_video_adapter_active->get_info (mode_info);
|
||||
}
|
||||
|
||||
grub_video_driver_id_t
|
||||
grub_video_get_driver_id (void)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return GRUB_VIDEO_DRIVER_NONE;
|
||||
return grub_video_adapter_active->id;
|
||||
}
|
||||
|
||||
/* Get information about active video mode. */
|
||||
grub_err_t
|
||||
grub_video_get_info_and_fini (struct grub_video_mode_info *mode_info,
|
||||
void **framebuffer)
|
||||
{
|
||||
grub_err_t err;
|
||||
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
err = grub_video_adapter_active->get_info_and_fini (mode_info, framebuffer);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
grub_video_adapter_active = 0;
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Determine optimized blitting formation for specified video mode info. */
|
||||
enum grub_video_blit_format
|
||||
grub_video_get_blit_format (struct grub_video_mode_info *mode_info)
|
||||
{
|
||||
/* Check if we have any known 32 bit modes. */
|
||||
if (mode_info->bpp == 32)
|
||||
{
|
||||
if ((mode_info->red_mask_size == 8)
|
||||
&& (mode_info->red_field_pos == 16)
|
||||
&& (mode_info->green_mask_size == 8)
|
||||
&& (mode_info->green_field_pos == 8)
|
||||
&& (mode_info->blue_mask_size == 8)
|
||||
&& (mode_info->blue_field_pos == 0))
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_BGRA_8888;
|
||||
}
|
||||
else if ((mode_info->red_mask_size == 8)
|
||||
&& (mode_info->red_field_pos == 0)
|
||||
&& (mode_info->green_mask_size == 8)
|
||||
&& (mode_info->green_field_pos == 8)
|
||||
&& (mode_info->blue_mask_size == 8)
|
||||
&& (mode_info->blue_field_pos == 16))
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_RGBA_8888;
|
||||
}
|
||||
}
|
||||
/* Check if we have any known 24 bit modes. */
|
||||
else if (mode_info->bpp == 24)
|
||||
{
|
||||
if ((mode_info->red_mask_size == 8)
|
||||
&& (mode_info->red_field_pos == 16)
|
||||
&& (mode_info->green_mask_size == 8)
|
||||
&& (mode_info->green_field_pos == 8)
|
||||
&& (mode_info->blue_mask_size == 8)
|
||||
&& (mode_info->blue_field_pos == 0))
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_BGR_888;
|
||||
}
|
||||
else if ((mode_info->red_mask_size == 8)
|
||||
&& (mode_info->red_field_pos == 0)
|
||||
&& (mode_info->green_mask_size == 8)
|
||||
&& (mode_info->green_field_pos == 8)
|
||||
&& (mode_info->blue_mask_size == 8)
|
||||
&& (mode_info->blue_field_pos == 16))
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_RGB_888;
|
||||
}
|
||||
}
|
||||
/* Check if we have any known 16 bit modes. */
|
||||
else if (mode_info->bpp == 16)
|
||||
{
|
||||
if ((mode_info->red_mask_size == 5)
|
||||
&& (mode_info->red_field_pos == 11)
|
||||
&& (mode_info->green_mask_size == 6)
|
||||
&& (mode_info->green_field_pos == 5)
|
||||
&& (mode_info->blue_mask_size == 5)
|
||||
&& (mode_info->blue_field_pos == 0))
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_BGR_565;
|
||||
}
|
||||
else if ((mode_info->red_mask_size == 5)
|
||||
&& (mode_info->red_field_pos == 0)
|
||||
&& (mode_info->green_mask_size == 6)
|
||||
&& (mode_info->green_field_pos == 5)
|
||||
&& (mode_info->blue_mask_size == 5)
|
||||
&& (mode_info->blue_field_pos == 11))
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_RGB_565;
|
||||
}
|
||||
}
|
||||
else if (mode_info->bpp == 1)
|
||||
return GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED;
|
||||
|
||||
/* Backup route. Unknown format. */
|
||||
|
||||
/* If there are more than 8 bits per color, assume RGB(A) mode. */
|
||||
if (mode_info->bpp > 8)
|
||||
{
|
||||
if (mode_info->reserved_mask_size > 0)
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_RGBA;
|
||||
}
|
||||
else
|
||||
{
|
||||
return GRUB_VIDEO_BLIT_FORMAT_RGB;
|
||||
}
|
||||
}
|
||||
|
||||
/* Assume as indexcolor mode. */
|
||||
return GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR;
|
||||
}
|
||||
|
||||
/* Set new indexed color palette entries. */
|
||||
grub_err_t
|
||||
grub_video_set_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->set_palette (start, count, palette_data);
|
||||
}
|
||||
|
||||
/* Get indexed color palette entries. */
|
||||
grub_err_t
|
||||
grub_video_get_palette (unsigned int start, unsigned int count,
|
||||
struct grub_video_palette_data *palette_data)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->get_palette (start, count, palette_data);
|
||||
}
|
||||
|
||||
/* Set viewport dimensions. */
|
||||
grub_err_t
|
||||
grub_video_set_viewport (unsigned int x, unsigned int y,
|
||||
unsigned int width, unsigned int height)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->set_viewport (x, y, width, height);
|
||||
}
|
||||
|
||||
/* Get viewport dimensions. */
|
||||
grub_err_t
|
||||
grub_video_get_viewport (unsigned int *x, unsigned int *y,
|
||||
unsigned int *width, unsigned int *height)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->get_viewport (x, y, width, height);
|
||||
}
|
||||
|
||||
/* Map color name to adapter specific color. */
|
||||
grub_video_color_t
|
||||
grub_video_map_color (grub_uint32_t color_name)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return 0;
|
||||
|
||||
return grub_video_adapter_active->map_color (color_name);
|
||||
}
|
||||
|
||||
/* Map RGB value to adapter specific color. */
|
||||
grub_video_color_t
|
||||
grub_video_map_rgb (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return 0;
|
||||
|
||||
return grub_video_adapter_active->map_rgb (red, green, blue);
|
||||
}
|
||||
|
||||
/* Map RGBA value to adapter specific color. */
|
||||
grub_video_color_t
|
||||
grub_video_map_rgba (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue,
|
||||
grub_uint8_t alpha)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return 0;
|
||||
|
||||
return grub_video_adapter_active->map_rgba (red, green, blue, alpha);
|
||||
}
|
||||
|
||||
/* Unmap video color back to RGBA components. */
|
||||
grub_err_t
|
||||
grub_video_unmap_color (grub_video_color_t color, grub_uint8_t *red,
|
||||
grub_uint8_t *green, grub_uint8_t *blue,
|
||||
grub_uint8_t *alpha)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->unmap_color (color,
|
||||
red,
|
||||
green,
|
||||
blue,
|
||||
alpha);
|
||||
}
|
||||
|
||||
/* Fill rectangle using specified color. */
|
||||
grub_err_t
|
||||
grub_video_fill_rect (grub_video_color_t color, int x, int y,
|
||||
unsigned int width, unsigned int height)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->fill_rect (color, x, y, width, height);
|
||||
}
|
||||
|
||||
/* Blit bitmap to screen. */
|
||||
grub_err_t
|
||||
grub_video_blit_bitmap (struct grub_video_bitmap *bitmap,
|
||||
enum grub_video_blit_operators oper,
|
||||
int x, int y, int offset_x, int offset_y,
|
||||
unsigned int width, unsigned int height)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->blit_bitmap (bitmap, oper, x, y,
|
||||
offset_x, offset_y,
|
||||
width, height);
|
||||
}
|
||||
|
||||
/* Blit render target to active render target. */
|
||||
grub_err_t
|
||||
grub_video_blit_render_target (struct grub_video_render_target *target,
|
||||
enum grub_video_blit_operators oper,
|
||||
int x, int y, int offset_x, int offset_y,
|
||||
unsigned int width, unsigned int height)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->blit_render_target (target, oper, x, y,
|
||||
offset_x, offset_y,
|
||||
width, height);
|
||||
}
|
||||
|
||||
/* Scroll viewport and fill new areas with specified color. */
|
||||
grub_err_t
|
||||
grub_video_scroll (grub_video_color_t color, int dx, int dy)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->scroll (color, dx, dy);
|
||||
}
|
||||
|
||||
/* Swap buffers (swap active render target). */
|
||||
grub_err_t
|
||||
grub_video_swap_buffers (void)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->swap_buffers ();
|
||||
}
|
||||
|
||||
/* Create new render target. */
|
||||
grub_err_t
|
||||
grub_video_create_render_target (struct grub_video_render_target **result,
|
||||
unsigned int width, unsigned int height,
|
||||
unsigned int mode_type)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->create_render_target (result,
|
||||
width, height,
|
||||
mode_type);
|
||||
}
|
||||
|
||||
/* Delete render target. */
|
||||
grub_err_t
|
||||
grub_video_delete_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->delete_render_target (target);
|
||||
}
|
||||
|
||||
/* Set active render target. */
|
||||
grub_err_t
|
||||
grub_video_set_active_render_target (struct grub_video_render_target *target)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->set_active_render_target (target);
|
||||
}
|
||||
|
||||
/* Get active render target. */
|
||||
grub_err_t
|
||||
grub_video_get_active_render_target (struct grub_video_render_target **target)
|
||||
{
|
||||
if (! grub_video_adapter_active)
|
||||
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
|
||||
|
||||
return grub_video_adapter_active->get_active_render_target (target);
|
||||
}
|
||||
|
||||
/* Parse <width>x<height>[x<depth>]*/
|
||||
static grub_err_t
|
||||
parse_modespec (const char *current_mode, int *width, int *height, int *depth)
|
||||
{
|
||||
const char *value;
|
||||
const char *param = current_mode;
|
||||
|
||||
*width = *height = *depth = -1;
|
||||
|
||||
if (grub_strcmp (param, "auto") == 0)
|
||||
{
|
||||
*width = *height = 0;
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Find width value. */
|
||||
value = param;
|
||||
param = grub_strchr(param, 'x');
|
||||
if (param == NULL)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"Invalid mode: %s\n",
|
||||
current_mode);
|
||||
|
||||
param++;
|
||||
|
||||
*width = grub_strtoul (value, 0, 0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"Invalid mode: %s\n",
|
||||
current_mode);
|
||||
|
||||
/* Find height value. */
|
||||
value = param;
|
||||
param = grub_strchr(param, 'x');
|
||||
if (param == NULL)
|
||||
{
|
||||
*height = grub_strtoul (value, 0, 0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"Invalid mode: %s\n",
|
||||
current_mode);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We have optional color depth value. */
|
||||
param++;
|
||||
|
||||
*height = grub_strtoul (value, 0, 0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"Invalid mode: %s\n",
|
||||
current_mode);
|
||||
|
||||
/* Convert color depth value. */
|
||||
value = param;
|
||||
*depth = grub_strtoul (value, 0, 0);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"Invalid mode: %s\n",
|
||||
current_mode);
|
||||
}
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_video_set_mode (const char *modestring,
|
||||
unsigned int modemask,
|
||||
unsigned int modevalue)
|
||||
{
|
||||
char *tmp;
|
||||
char *next_mode;
|
||||
char *current_mode;
|
||||
char *modevar;
|
||||
|
||||
modevalue &= modemask;
|
||||
|
||||
/* Take copy of env.var. as we don't want to modify that. */
|
||||
modevar = grub_strdup (modestring);
|
||||
|
||||
/* Initialize next mode. */
|
||||
next_mode = modevar;
|
||||
|
||||
if (! modevar)
|
||||
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
|
||||
"couldn't allocate space for local modevar copy");
|
||||
|
||||
if (grub_memcmp (next_mode, "keep", sizeof ("keep")) == 0
|
||||
|| grub_memcmp (next_mode, "keep,", sizeof ("keep,") - 1) == 0
|
||||
|| grub_memcmp (next_mode, "keep;", sizeof ("keep;") - 1) == 0)
|
||||
{
|
||||
int suitable = 1;
|
||||
grub_err_t err;
|
||||
|
||||
if (grub_video_adapter_active)
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
grub_memset (&mode_info, 0, sizeof (mode_info));
|
||||
err = grub_video_get_info (&mode_info);
|
||||
if (err)
|
||||
{
|
||||
suitable = 0;
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
}
|
||||
if ((mode_info.mode_type & modemask) != modevalue)
|
||||
suitable = 0;
|
||||
}
|
||||
else if (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) != 0)
|
||||
&& ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) == 0))
|
||||
suitable = 0;
|
||||
|
||||
if (suitable)
|
||||
{
|
||||
grub_free (modevar);
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
next_mode += sizeof ("keep") - 1;
|
||||
if (! *next_mode)
|
||||
{
|
||||
grub_free (modevar);
|
||||
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"no suitable mode found");
|
||||
}
|
||||
|
||||
/* Skip separator. */
|
||||
next_mode++;
|
||||
}
|
||||
|
||||
/* De-activate last set video adapter. */
|
||||
if (grub_video_adapter_active)
|
||||
{
|
||||
/* Finalize adapter. */
|
||||
grub_video_adapter_active->fini ();
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
|
||||
/* Mark active adapter as not set. */
|
||||
grub_video_adapter_active = 0;
|
||||
}
|
||||
|
||||
/* Loop until all modes has been tested out. */
|
||||
while (next_mode != NULL)
|
||||
{
|
||||
int width = -1;
|
||||
int height = -1;
|
||||
int depth = -1;
|
||||
grub_err_t err;
|
||||
unsigned int flags = modevalue;
|
||||
unsigned int flagmask = modemask;
|
||||
|
||||
/* Use last next_mode as current mode. */
|
||||
tmp = next_mode;
|
||||
|
||||
/* Save position of next mode and separate modes. */
|
||||
for (; *next_mode; next_mode++)
|
||||
if (*next_mode == ',' || *next_mode == ';')
|
||||
break;
|
||||
if (*next_mode)
|
||||
{
|
||||
*next_mode = 0;
|
||||
next_mode++;
|
||||
}
|
||||
else
|
||||
next_mode = 0;
|
||||
|
||||
/* Skip whitespace. */
|
||||
while (grub_isspace (*tmp))
|
||||
tmp++;
|
||||
|
||||
/* Initialize token holders. */
|
||||
current_mode = tmp;
|
||||
|
||||
/* XXX: we assume that we're in pure text mode if
|
||||
no video mode is initialized. Is it always true? */
|
||||
if (grub_strcmp (current_mode, "text") == 0)
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
|
||||
grub_memset (&mode_info, 0, sizeof (mode_info));
|
||||
if (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) == 0)
|
||||
|| ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) != 0))
|
||||
{
|
||||
/* Valid mode found from adapter, and it has been activated.
|
||||
Specify it as active adapter. */
|
||||
grub_video_adapter_active = NULL;
|
||||
|
||||
/* Free memory. */
|
||||
grub_free (modevar);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
err = parse_modespec (current_mode, &width, &height, &depth);
|
||||
if (err)
|
||||
{
|
||||
/* Free memory before returning. */
|
||||
grub_free (modevar);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Try out video mode. */
|
||||
|
||||
/* If user requested specific depth check if this depth is supported. */
|
||||
if (depth != -1 && (flagmask & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
&&
|
||||
(((flags & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
|
||||
!= ((depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
|
||||
& GRUB_VIDEO_MODE_TYPE_DEPTH_MASK))))
|
||||
continue;
|
||||
|
||||
if (depth != -1)
|
||||
{
|
||||
flags |= (depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
|
||||
& GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
|
||||
flagmask |= GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
|
||||
}
|
||||
|
||||
/* Try to initialize requested mode. Ignore any errors. */
|
||||
grub_video_adapter_t p;
|
||||
|
||||
/* Loop thru all possible video adapter trying to find requested mode. */
|
||||
for (p = grub_video_adapter_list; p; p = p->next)
|
||||
{
|
||||
struct grub_video_mode_info mode_info;
|
||||
|
||||
grub_memset (&mode_info, 0, sizeof (mode_info));
|
||||
|
||||
/* Try to initialize adapter, if it fails, skip to next adapter. */
|
||||
err = p->init ();
|
||||
if (err != GRUB_ERR_NONE)
|
||||
{
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Try to initialize video mode. */
|
||||
err = p->setup (width, height, flags, flagmask);
|
||||
if (err != GRUB_ERR_NONE)
|
||||
{
|
||||
p->fini ();
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
err = p->get_info (&mode_info);
|
||||
if (err != GRUB_ERR_NONE)
|
||||
{
|
||||
p->fini ();
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
flags = mode_info.mode_type & ~GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
|
||||
flags |= (mode_info.bpp << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
|
||||
& GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
|
||||
|
||||
/* Check that mode is suitable for upper layer. */
|
||||
if ((flags & GRUB_VIDEO_MODE_TYPE_PURE_TEXT)
|
||||
? (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) != 0)
|
||||
&& ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) == 0))
|
||||
: ((flags & modemask) != modevalue))
|
||||
{
|
||||
p->fini ();
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Valid mode found from adapter, and it has been activated.
|
||||
Specify it as active adapter. */
|
||||
grub_video_adapter_active = p;
|
||||
|
||||
/* Free memory. */
|
||||
grub_free (modevar);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* Free memory. */
|
||||
grub_free (modevar);
|
||||
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
||||
"no suitable mode found");
|
||||
}
|
||||
|
||||
/* Initialize Video API module. */
|
||||
GRUB_MOD_INIT(video)
|
||||
{
|
||||
}
|
||||
|
||||
/* Finalize Video API module. */
|
||||
GRUB_MOD_FINI(video)
|
||||
{
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue