diff options
Diffstat (limited to 'include/grub/video.h')
| -rw-r--r-- | include/grub/video.h | 704 |
1 files changed, 704 insertions, 0 deletions
diff --git a/include/grub/video.h b/include/grub/video.h new file mode 100644 index 0000000..52c3fd7 --- /dev/null +++ b/include/grub/video.h @@ -0,0 +1,704 @@ +/* + * 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/>. + */ + +#ifndef GRUB_VIDEO_HEADER +#define GRUB_VIDEO_HEADER 1 + +#include <grub/err.h> +#include <grub/types.h> +#include <grub/list.h> + +/* Video color in hardware dependent format. Users should not assume any + specific coding format. */ +typedef grub_uint32_t grub_video_color_t; + +/* Video color in hardware independent format. */ +typedef struct grub_video_rgba_color +{ + grub_uint8_t red; + grub_uint8_t green; + grub_uint8_t blue; + grub_uint8_t alpha; +} grub_video_rgba_color_t; + +/* This structure is driver specific and should not be accessed directly by + outside code. */ +struct grub_video_render_target; + +/* Forward declarations for used data structures. */ +struct grub_video_bitmap; + +/* Defines used to describe video mode or rendering target. */ +/* If following is set render target contains currenly displayed image + after swapping buffers (otherwise it contains previously displayed image). + */ +typedef enum grub_video_mode_type + { + GRUB_VIDEO_MODE_TYPE_RGB = 0x00000001, + GRUB_VIDEO_MODE_TYPE_INDEX_COLOR = 0x00000002, + GRUB_VIDEO_MODE_TYPE_1BIT_BITMAP = 0x00000004, + GRUB_VIDEO_MODE_TYPE_YUV = 0x00000008, + + /* Defines used to mask flags. */ + GRUB_VIDEO_MODE_TYPE_COLOR_MASK = 0x0000000F, + + GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED = 0x00000010, + GRUB_VIDEO_MODE_TYPE_ALPHA = 0x00000020, + GRUB_VIDEO_MODE_TYPE_PURE_TEXT = 0x00000040, + GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP = 0x00000080, + GRUB_VIDEO_MODE_TYPE_OPERATIONAL_MASK = 0x000000F0, + + /* Defines used to specify requested bit depth. */ + GRUB_VIDEO_MODE_TYPE_DEPTH_MASK = 0x0000FF00, +#define GRUB_VIDEO_MODE_TYPE_DEPTH_POS 8 + + GRUB_VIDEO_MODE_TYPE_UNKNOWN = 0x00010000, + GRUB_VIDEO_MODE_TYPE_HERCULES = 0x00020000, + GRUB_VIDEO_MODE_TYPE_PLANAR = 0x00040000, + GRUB_VIDEO_MODE_TYPE_NONCHAIN4 = 0x00080000, + GRUB_VIDEO_MODE_TYPE_CGA = 0x00100000, + GRUB_VIDEO_MODE_TYPE_INFO_MASK = 0x00FF0000, + } grub_video_mode_type_t; + +/* The basic render target representing the whole display. This always + renders to the back buffer when double-buffering is in use. */ +#define GRUB_VIDEO_RENDER_TARGET_DISPLAY \ + ((struct grub_video_render_target *) 0) + +/* Defined blitting formats. */ +enum grub_video_blit_format + { + /* Generic RGBA, use fields & masks. */ + GRUB_VIDEO_BLIT_FORMAT_RGBA, + + /* Optimized RGBA's. */ + GRUB_VIDEO_BLIT_FORMAT_RGBA_8888, + GRUB_VIDEO_BLIT_FORMAT_BGRA_8888, + + /* Generic RGB, use fields & masks. */ + GRUB_VIDEO_BLIT_FORMAT_RGB, + + /* Optimized RGB's. */ + GRUB_VIDEO_BLIT_FORMAT_RGB_888, + GRUB_VIDEO_BLIT_FORMAT_BGR_888, + GRUB_VIDEO_BLIT_FORMAT_RGB_565, + GRUB_VIDEO_BLIT_FORMAT_BGR_565, + + /* When needed, decode color or just use value as is. */ + GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR, + /* Like index but only 16-colors and F0 is a special value for transparency. + Could be extended to 4 bits of alpha and 4 bits of color if necessary. + Used internally for text rendering. + */ + GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR_ALPHA, + + /* Two color bitmap; bits packed: rows are not padded to byte boundary. */ + GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED + }; + +/* Define blitting operators. */ +enum grub_video_blit_operators + { + /* Replace target bitmap data with source. */ + GRUB_VIDEO_BLIT_REPLACE, + /* Blend target and source based on source's alpha value. */ + GRUB_VIDEO_BLIT_BLEND + }; + +struct grub_video_mode_info +{ + /* Width of the screen. */ + unsigned int width; + + /* Height of the screen. */ + unsigned int height; + + /* Mode type bitmask. Contains information like is it Index color or + RGB mode. */ + grub_video_mode_type_t mode_type; + + /* Bits per pixel. */ + unsigned int bpp; + + /* Bytes per pixel. */ + unsigned int bytes_per_pixel; + + /* Pitch of one scanline. How many bytes there are for scanline. */ + unsigned int pitch; + + /* In index color mode, number of colors. In RGB mode this is 256. */ + unsigned int number_of_colors; + + unsigned int mode_number; +#define GRUB_VIDEO_MODE_NUMBER_INVALID 0xffffffff + + /* Optimization hint how binary data is coded. */ + enum grub_video_blit_format blit_format; + + /* How many bits are reserved for red color. */ + unsigned int red_mask_size; + + /* What is location of red color bits. In Index Color mode, this is 0. */ + unsigned int red_field_pos; + + /* How many bits are reserved for green color. */ + unsigned int green_mask_size; + + /* What is location of green color bits. In Index Color mode, this is 0. */ + unsigned int green_field_pos; + + /* How many bits are reserved for blue color. */ + unsigned int blue_mask_size; + + /* What is location of blue color bits. In Index Color mode, this is 0. */ + unsigned int blue_field_pos; + + /* How many bits are reserved in color. */ + unsigned int reserved_mask_size; + + /* What is location of reserved color bits. In Index Color mode, + this is 0. */ + unsigned int reserved_field_pos; + + /* For 1-bit bitmaps, the background color. Used for bits = 0. */ + grub_uint8_t bg_red; + grub_uint8_t bg_green; + grub_uint8_t bg_blue; + grub_uint8_t bg_alpha; + + /* For 1-bit bitmaps, the foreground color. Used for bits = 1. */ + grub_uint8_t fg_red; + grub_uint8_t fg_green; + grub_uint8_t fg_blue; + grub_uint8_t fg_alpha; +}; + +/* A 2D rectangle type. */ +struct grub_video_rect +{ + unsigned x; + unsigned y; + unsigned width; + unsigned height; +}; +typedef struct grub_video_rect grub_video_rect_t; + +struct grub_video_signed_rect +{ + signed x; + signed y; + unsigned width; + unsigned height; +}; +typedef struct grub_video_signed_rect grub_video_signed_rect_t; + +struct grub_video_palette_data +{ + grub_uint8_t r; /* Red color value (0-255). */ + grub_uint8_t g; /* Green color value (0-255). */ + grub_uint8_t b; /* Blue color value (0-255). */ + grub_uint8_t a; /* Reserved bits value (0-255). */ +}; + +struct grub_video_edid_info +{ + grub_uint8_t header[8]; + grub_uint16_t manufacturer_id; + grub_uint16_t product_id; + grub_uint32_t serial_number; + grub_uint8_t week_of_manufacture; + grub_uint8_t year_of_manufacture; + grub_uint8_t version; + grub_uint8_t revision; + + grub_uint8_t video_input_definition; + grub_uint8_t max_horizontal_image_size; + grub_uint8_t max_vertical_image_size; + grub_uint8_t display_gamma; + grub_uint8_t feature_support; +#define GRUB_VIDEO_EDID_FEATURE_PREFERRED_TIMING_MODE (1 << 1) + + grub_uint8_t red_green_lo; + grub_uint8_t blue_white_lo; + grub_uint8_t red_x_hi; + grub_uint8_t red_y_hi; + grub_uint8_t green_x_hi; + grub_uint8_t green_y_hi; + grub_uint8_t blue_x_hi; + grub_uint8_t blue_y_hi; + grub_uint8_t white_x_hi; + grub_uint8_t white_y_hi; + + grub_uint8_t established_timings_1; + grub_uint8_t established_timings_2; + grub_uint8_t manufacturer_reserved_timings; + + grub_uint16_t standard_timings[8]; + + struct { + grub_uint16_t pixel_clock; + /* Only valid if the pixel clock is non-null. */ + grub_uint8_t horizontal_active_lo; + grub_uint8_t horizontal_blanking_lo; + grub_uint8_t horizontal_hi; + grub_uint8_t vertical_active_lo; + grub_uint8_t vertical_blanking_lo; + grub_uint8_t vertical_hi; + grub_uint8_t horizontal_sync_offset_lo; + grub_uint8_t horizontal_sync_pulse_width_lo; + grub_uint8_t vertical_sync_lo; + grub_uint8_t sync_hi; + grub_uint8_t horizontal_image_size_lo; + grub_uint8_t vertical_image_size_lo; + grub_uint8_t image_size_hi; + grub_uint8_t horizontal_border; + grub_uint8_t vertical_border; + grub_uint8_t flags; + } detailed_timings[4]; + + grub_uint8_t extension_flag; + grub_uint8_t checksum; +} GRUB_PACKED; + +typedef enum grub_video_driver_id + { + GRUB_VIDEO_DRIVER_NONE, + GRUB_VIDEO_DRIVER_VBE, + GRUB_VIDEO_DRIVER_EFI_UGA, + GRUB_VIDEO_DRIVER_EFI_GOP, + GRUB_VIDEO_DRIVER_SM712, + GRUB_VIDEO_DRIVER_VGA, + GRUB_VIDEO_DRIVER_CIRRUS, + GRUB_VIDEO_DRIVER_BOCHS, + GRUB_VIDEO_DRIVER_SDL, + GRUB_VIDEO_DRIVER_SIS315PRO, + GRUB_VIDEO_DRIVER_RADEON_FULOONG2E, + GRUB_VIDEO_DRIVER_COREBOOT, + GRUB_VIDEO_DRIVER_IEEE1275, + GRUB_VIDEO_ADAPTER_CAPTURE, + GRUB_VIDEO_DRIVER_XEN, + GRUB_VIDEO_DRIVER_RADEON_YEELOONG3A + } grub_video_driver_id_t; + +typedef enum grub_video_adapter_prio + { + GRUB_VIDEO_ADAPTER_PRIO_FALLBACK = 60, + GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE_DIRTY = 70, + GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE = 80, + GRUB_VIDEO_ADAPTER_PRIO_NATIVE = 100 + } grub_video_adapter_prio_t; + +typedef enum grub_video_area_status + { + GRUB_VIDEO_AREA_DISABLED, + GRUB_VIDEO_AREA_ENABLED + } grub_video_area_status_t; + +struct grub_video_adapter +{ + /* The next video adapter. */ + struct grub_video_adapter *next; + struct grub_video_adapter **prev; + + /* The video adapter name. */ + const char *name; + grub_video_driver_id_t id; + + grub_video_adapter_prio_t prio; + + /* Initialize the video adapter. */ + grub_err_t (*init) (void); + + /* Clean up the video adapter. */ + grub_err_t (*fini) (void); + + grub_err_t (*setup) (unsigned int width, unsigned int height, + grub_video_mode_type_t mode_type, + grub_video_mode_type_t mode_mask); + + grub_err_t (*get_info) (struct grub_video_mode_info *mode_info); + + grub_err_t (*get_info_and_fini) (struct grub_video_mode_info *mode_info, + void **framebuffer); + + grub_err_t (*set_palette) (unsigned int start, unsigned int count, + struct grub_video_palette_data *palette_data); + + grub_err_t (*get_palette) (unsigned int start, unsigned int count, + struct grub_video_palette_data *palette_data); + + grub_err_t (*set_viewport) (unsigned int x, unsigned int y, + unsigned int width, unsigned int height); + + grub_err_t (*get_viewport) (unsigned int *x, unsigned int *y, + unsigned int *width, unsigned int *height); + + grub_err_t (*set_region) (unsigned int x, unsigned int y, + unsigned int width, unsigned int height); + + grub_err_t (*get_region) (unsigned int *x, unsigned int *y, + unsigned int *width, unsigned int *height); + + grub_err_t (*set_area_status) (grub_video_area_status_t area_status); + + grub_err_t (*get_area_status) (grub_video_area_status_t *area_status); + + grub_video_color_t (*map_color) (grub_uint32_t color_name); + + grub_video_color_t (*map_rgb) (grub_uint8_t red, grub_uint8_t green, + grub_uint8_t blue); + + grub_video_color_t (*map_rgba) (grub_uint8_t red, grub_uint8_t green, + grub_uint8_t blue, grub_uint8_t alpha); + + grub_err_t (*unmap_color) (grub_video_color_t color, + grub_uint8_t *red, grub_uint8_t *green, + grub_uint8_t *blue, grub_uint8_t *alpha); + + grub_err_t (*fill_rect) (grub_video_color_t color, int x, int y, + unsigned int width, unsigned int height); + + grub_err_t (*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); + + grub_err_t (*blit_render_target) (struct grub_video_render_target *source, + enum grub_video_blit_operators oper, + int x, int y, int offset_x, int offset_y, + unsigned int width, unsigned int height); + + grub_err_t (*scroll) (grub_video_color_t color, int dx, int dy); + + grub_err_t (*swap_buffers) (void); + + grub_err_t (*create_render_target) (struct grub_video_render_target **result, + unsigned int width, unsigned int height, + unsigned int mode_type); + + grub_err_t (*delete_render_target) (struct grub_video_render_target *target); + + grub_err_t (*set_active_render_target) (struct grub_video_render_target *target); + + grub_err_t (*get_active_render_target) (struct grub_video_render_target **target); + + int (*iterate) (int (*hook) (const struct grub_video_mode_info *info, void *hook_arg), void *hook_arg); + + grub_err_t (*get_edid) (struct grub_video_edid_info *edid_info); + + void (*print_adapter_specific_info) (void); +}; +typedef struct grub_video_adapter *grub_video_adapter_t; + +extern grub_video_adapter_t EXPORT_VAR(grub_video_adapter_list); + +#ifndef GRUB_LST_GENERATOR +/* Register video driver. */ +static inline void +grub_video_register (grub_video_adapter_t adapter) +{ + grub_video_adapter_t *p; + for (p = &grub_video_adapter_list; *p && (*p)->prio > adapter->prio; + p = &((*p)->next)); + adapter->next = *p; + *p = adapter; + + adapter->prev = p; + if (adapter->next) + adapter->next->prev = &adapter->next; +} +#endif + +/* Unregister video driver. */ +static inline void +grub_video_unregister (grub_video_adapter_t adapter) +{ + grub_list_remove (GRUB_AS_LIST (adapter)); +} + +#define FOR_VIDEO_ADAPTERS(var) FOR_LIST_ELEMENTS((var), (grub_video_adapter_list)) + +grub_err_t EXPORT_FUNC (grub_video_restore) (void); + +grub_err_t EXPORT_FUNC (grub_video_get_info) (struct grub_video_mode_info *mode_info); + +/* Framebuffer address may change as a part of normal operation + (e.g. double buffering). That's why you need to stop video subsystem to be + sure that framebuffer address doesn't change. To ensure this abstraction + grub_video_get_info_and_fini is the only function supplying framebuffer + address. */ +grub_err_t EXPORT_FUNC (grub_video_get_info_and_fini) (struct grub_video_mode_info *mode_info, + void **framebuffer); + +enum grub_video_blit_format EXPORT_FUNC(grub_video_get_blit_format) (struct grub_video_mode_info *mode_info); + +grub_err_t grub_video_set_palette (unsigned int start, unsigned int count, + struct grub_video_palette_data *palette_data); + +grub_err_t EXPORT_FUNC (grub_video_get_palette) (unsigned int start, + unsigned int count, + struct grub_video_palette_data *palette_data); + +grub_err_t EXPORT_FUNC (grub_video_set_viewport) (unsigned int x, + unsigned int y, + unsigned int width, + unsigned int height); + +grub_err_t EXPORT_FUNC (grub_video_get_viewport) (unsigned int *x, + unsigned int *y, + unsigned int *width, + unsigned int *height); + +grub_err_t EXPORT_FUNC (grub_video_set_region) (unsigned int x, + unsigned int y, + unsigned int width, + unsigned int height); + +grub_err_t EXPORT_FUNC (grub_video_get_region) (unsigned int *x, + unsigned int *y, + unsigned int *width, + unsigned int *height); + +grub_err_t EXPORT_FUNC (grub_video_set_area_status) + (grub_video_area_status_t area_status); + +grub_err_t EXPORT_FUNC (grub_video_get_area_status) + (grub_video_area_status_t *area_status); + +grub_video_color_t EXPORT_FUNC (grub_video_map_color) (grub_uint32_t color_name); + +grub_video_color_t EXPORT_FUNC (grub_video_map_rgb) (grub_uint8_t red, + grub_uint8_t green, + grub_uint8_t blue); + +grub_video_color_t EXPORT_FUNC (grub_video_map_rgba) (grub_uint8_t red, + grub_uint8_t green, + grub_uint8_t blue, + grub_uint8_t alpha); + +grub_err_t EXPORT_FUNC (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); + +grub_err_t EXPORT_FUNC (grub_video_fill_rect) (grub_video_color_t color, + int x, int y, + unsigned int width, + unsigned int height); + +grub_err_t EXPORT_FUNC (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); + +grub_err_t EXPORT_FUNC (grub_video_blit_render_target) (struct grub_video_render_target *source, + enum grub_video_blit_operators oper, + int x, int y, + int offset_x, + int offset_y, + unsigned int width, + unsigned int height); + +grub_err_t grub_video_scroll (grub_video_color_t color, int dx, int dy); + +grub_err_t EXPORT_FUNC (grub_video_swap_buffers) (void); + +grub_err_t EXPORT_FUNC (grub_video_create_render_target) (struct grub_video_render_target **result, + unsigned int width, + unsigned int height, + unsigned int mode_type); + +grub_err_t EXPORT_FUNC (grub_video_delete_render_target) (struct grub_video_render_target *target); + +grub_err_t EXPORT_FUNC (grub_video_set_active_render_target) (struct grub_video_render_target *target); + +grub_err_t grub_video_get_active_render_target (struct grub_video_render_target **target); + +grub_err_t EXPORT_FUNC (grub_video_edid_checksum) (struct grub_video_edid_info *edid_info); +grub_err_t EXPORT_FUNC (grub_video_edid_preferred_mode) (struct grub_video_edid_info *edid_info, + unsigned int *width, + unsigned int *height); + +grub_err_t EXPORT_FUNC (grub_video_set_mode) (const char *modestring, + unsigned int modemask, + unsigned int modevalue); + +static inline int +grub_video_check_mode_flag (grub_video_mode_type_t flags, + grub_video_mode_type_t mask, + grub_video_mode_type_t flag, int def) +{ + return (flag & mask) ? !! (flags & flag) : def; +} + +grub_video_driver_id_t EXPORT_FUNC (grub_video_get_driver_id) (void); + +static __inline grub_video_rgba_color_t +grub_video_rgba_color_rgb (grub_uint8_t r, grub_uint8_t g, grub_uint8_t b) +{ + grub_video_rgba_color_t c; + c.red = r; + c.green = g; + c.blue = b; + c.alpha = 255; + return c; +} + +static __inline grub_video_color_t +grub_video_map_rgba_color (grub_video_rgba_color_t c) +{ + return grub_video_map_rgba (c.red, c.green, c.blue, c.alpha); +} + +#ifndef GRUB_MACHINE_EMU +extern void grub_font_init (void); +extern void grub_font_fini (void); +extern void grub_gfxterm_init (void); +extern void grub_gfxterm_fini (void); +extern void grub_video_sm712_init (void); +extern void grub_video_sm712_fini (void); +extern void grub_video_sis315pro_init (void); +extern void grub_video_radeon_fuloong2e_init (void); +extern void grub_video_sis315pro_fini (void); +extern void grub_video_radeon_fuloong2e_fini (void); +extern void grub_video_radeon_yeeloong3a_init (void); +extern void grub_video_radeon_yeeloong3a_fini (void); +#endif + +void +grub_video_set_adapter (grub_video_adapter_t adapter); +grub_video_adapter_t +grub_video_get_adapter (void); +grub_err_t +grub_video_capture_start (const struct grub_video_mode_info *mode_info, + struct grub_video_palette_data *palette, + unsigned int palette_size); +void +grub_video_capture_end (void); + +void * +grub_video_capture_get_framebuffer (void); + +extern grub_video_adapter_t EXPORT_VAR (grub_video_adapter_active); +extern void (*grub_video_capture_refresh_cb) (void); + +#define GRUB_VIDEO_MI_RGB555(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 15, \ + x.bytes_per_pixel = 2, \ + x.number_of_colors = 256, \ + x.red_mask_size = 5, \ + x.red_field_pos = 10, \ + x.green_mask_size = 5, \ + x.green_field_pos = 5, \ + x.blue_mask_size = 5, \ + x.blue_field_pos = 0 + +#define GRUB_VIDEO_MI_RGB565(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 16, \ + x.bytes_per_pixel = 2, \ + x.number_of_colors = 256, \ + x.red_mask_size = 5, \ + x.red_field_pos = 11, \ + x.green_mask_size = 6, \ + x.green_field_pos = 5, \ + x.blue_mask_size = 5, \ + x.blue_field_pos = 0 + +#define GRUB_VIDEO_MI_RGB888(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 24, \ + x.bytes_per_pixel = 3, \ + x.number_of_colors = 256, \ + x.red_mask_size = 8, \ + x.red_field_pos = 16, \ + x.green_mask_size = 8, \ + x.green_field_pos = 8, \ + x.blue_mask_size = 8, \ + x.blue_field_pos = 0 + +#define GRUB_VIDEO_MI_RGBA8888(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 32, \ + x.bytes_per_pixel = 4, \ + x.number_of_colors = 256, \ + x.reserved_mask_size = 8, \ + x.reserved_field_pos = 24, \ + x.red_mask_size = 8, \ + x.red_field_pos = 16, \ + x.green_mask_size = 8, \ + x.green_field_pos = 8, \ + x.blue_mask_size = 8, \ + x.blue_field_pos = 0 + + +#define GRUB_VIDEO_MI_BGR555(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 15, \ + x.bytes_per_pixel = 2, \ + x.number_of_colors = 256, \ + x.red_mask_size = 5, \ + x.red_field_pos = 0, \ + x.green_mask_size = 5, \ + x.green_field_pos = 5, \ + x.blue_mask_size = 5, \ + x.blue_field_pos = 10 + +#define GRUB_VIDEO_MI_BGR565(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 16, \ + x.bytes_per_pixel = 2, \ + x.number_of_colors = 256, \ + x.red_mask_size = 5, \ + x.red_field_pos = 0, \ + x.green_mask_size = 6, \ + x.green_field_pos = 5, \ + x.blue_mask_size = 5, \ + x.blue_field_pos = 11 + +#define GRUB_VIDEO_MI_BGR888(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 24, \ + x.bytes_per_pixel = 3, \ + x.number_of_colors = 256, \ + x.red_mask_size = 8, \ + x.red_field_pos = 0, \ + x.green_mask_size = 8, \ + x.green_field_pos = 8, \ + x.blue_mask_size = 8, \ + x.blue_field_pos = 16 + +#define GRUB_VIDEO_MI_BGRA8888(x) \ + x.mode_type = GRUB_VIDEO_MODE_TYPE_RGB, \ + x.bpp = 32, \ + x.bytes_per_pixel = 4, \ + x.number_of_colors = 256, \ + x.reserved_mask_size = 8, \ + x.reserved_field_pos = 24, \ + x.red_mask_size = 8, \ + x.red_field_pos = 0, \ + x.green_mask_size = 8, \ + x.green_field_pos = 8, \ + x.blue_mask_size = 8, \ + x.blue_field_pos = 16 + +#endif /* ! GRUB_VIDEO_HEADER */ |