From 4b187937acb52b5ee5da7c687ded09e7b2c1825a Mon Sep 17 00:00:00 2001
From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>
Date: Thu, 2 May 2013 14:39:03 +0200
Subject: [PATCH 401/482] First automated video test (running videotest
and comparing results)
---
ChangeLog | 4 +
Makefile.util.def | 7 +
grub-core/Makefile.core.def | 8 +
grub-core/tests/checksums.c | 27 +++
grub-core/tests/fake_input.c | 67 ++++++
grub-core/tests/lib/functional_test.c | 29 ++-
grub-core/tests/video_checksum.c | 435 ++++++++++++++++++++++++++++++++++
grub-core/tests/videotest_checksum.c | 286 ++++++++++++++++++++++
grub-core/video/capture.c | 128 ++++++++++
grub-core/video/video.c | 13 +-
include/grub/emu/export.h | 3 +-
include/grub/test.h | 9 +
include/grub/video.h | 120 +++++++++-
tests/grub_func_test.in | 12 +
tests/util/grub-shell.in | 2 +
util/grub-render-label.c | 97 ++------
16 files changed, 1150 insertions(+), 97 deletions(-)
create mode 100644 grub-core/tests/checksums.c
create mode 100644 grub-core/tests/fake_input.c
create mode 100644 grub-core/tests/video_checksum.c
create mode 100644 grub-core/tests/videotest_checksum.c
create mode 100644 grub-core/video/capture.c
create mode 100644 tests/grub_func_test.in
diff --git a/ChangeLog b/ChangeLog
index b202abe..37595a9 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,9 @@
2013-05-02 Vladimir Serbinenko <phcoder@gmail.com>
+ First automated video test (running videotest and comparing results)
+
+2013-05-02 Vladimir Serbinenko <phcoder@gmail.com>
+
* grub-core/commands/videotest.c: Reduce flickering and draw 6 squares
instead of 2 to have full RGB/CMY test pattern.
diff --git a/Makefile.util.def b/Makefile.util.def
index fbd37eb..a357341 100644
--- a/Makefile.util.def
+++ b/Makefile.util.def
@@ -67,6 +67,7 @@ library = {
common = grub-core/video/fb/fbfill.c;
common = grub-core/video/fb/video_fb.c;
common = grub-core/video/video.c;
+ common = grub-core/video/capture.c;
common = grub-core/video/colors.c;
common = grub-core/unidata.c;
common = grub-core/io/bufio.c;
@@ -814,6 +815,12 @@ script = {
common = tests/grub_script_strcmp.in;
};
+script = {
+ testcase;
+ name = grub_func_test;
+ common = tests/grub_func_test.in;
+};
+
program = {
testcase;
name = example_unit_test;
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 7e19acb..2fa0ea7 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -1731,6 +1731,9 @@ module = {
name = functional_test;
common = tests/lib/functional_test.c;
common = tests/lib/test.c;
+ common = tests/video_checksum.c;
+ common = tests/fake_input.c;
+ common = video/capture.c;
};
module = {
@@ -1739,6 +1742,11 @@ module = {
};
module = {
+ name = videotest_checksum;
+ common = tests/videotest_checksum.c;
+};
+
+module = {
name = bitmap;
common = video/bitmap.c;
enable = videomodules;
diff --git a/grub-core/tests/checksums.c b/grub-core/tests/checksums.c
new file mode 100644
index 0000000..93d100f
--- /dev/null
+++ b/grub-core/tests/checksums.c
@@ -0,0 +1,27 @@
+ { "videotest", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x7f1853ba, 0x7f1853ba, 0x7f1853ba, 0x7f1853ba, 0x7f1853ba, }, 5 },
+ { "videotest", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xff1957f0, 0xff1957f0, 0xff1957f0, 0xff1957f0, 0xff1957f0, }, 5 },
+ { "videotest", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xcb45d8c5, 0xcb45d8c5, 0xcb45d8c5, 0xcb45d8c5, 0xcb45d8c5, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 640x480xrgb555 */, (grub_uint32_t []) { 0x2c97569c, 0x2c97569c, 0x2c97569c, 0x2c97569c, 0x2c97569c, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 800x600xrgb555 */, (grub_uint32_t []) { 0x9bd7a3ac, 0x9bd7a3ac, 0x9bd7a3ac, 0x9bd7a3ac, 0x9bd7a3ac, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 1024x768xrgb555 */, (grub_uint32_t []) { 0xedbceb9c, 0xedbceb9c, 0xedbceb9c, 0xedbceb9c, 0xedbceb9c, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 640x480xrgb565 */, (grub_uint32_t []) { 0x3c2a42f1, 0x3c2a42f1, 0x3c2a42f1, 0x3c2a42f1, 0x3c2a42f1, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 800x600xrgb565 */, (grub_uint32_t []) { 0xb25ce62a, 0xb25ce62a, 0xb25ce62a, 0xb25ce62a, 0xb25ce62a, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 1024x768xrgb565 */, (grub_uint32_t []) { 0x66cee14c, 0x66cee14c, 0x66cee14c, 0x66cee14c, 0x66cee14c, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 640x480xrgb888 */, (grub_uint32_t []) { 0x61db45b7, 0x1d867efe, 0x99613325, 0xe53c086c, 0x9543de62, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 800x600xrgb888 */, (grub_uint32_t []) { 0xa46eb37f, 0xd2a59656, 0x49f8f92d, 0x3f33dc04, 0x7aae512a, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 1024x768xrgb888 */, (grub_uint32_t []) { 0xb864a496, 0x6c22313b, 0x1505f93d, 0xc1436c90, 0xe74a6931, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgb888 */, (grub_uint32_t []) { 0x2b154617, 0x692e98df, 0xaf62fb87, 0xed59254f, 0x26164bc6, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgb888 */, (grub_uint32_t []) { 0x3b0fbc56, 0xd9d57c0e, 0xfb564a17, 0x198c8a4f, 0xbe502625, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgb888 */, (grub_uint32_t []) { 0x6e6c9b36, 0x4ae9f137, 0x27664f34, 0x3e32535, 0xfc793332, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 640x480xbgr555 */, (grub_uint32_t []) { 0x9056f776, 0x9056f776, 0x9056f776, 0x9056f776, 0x9056f776, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 800x600xbgr555 */, (grub_uint32_t []) { 0x2bde3c67, 0x2bde3c67, 0x2bde3c67, 0x2bde3c67, 0x2bde3c67, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 1024x768xbgr555 */, (grub_uint32_t []) { 0xb04615f3, 0xb04615f3, 0xb04615f3, 0xb04615f3, 0xb04615f3, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 640x480xbgr565 */, (grub_uint32_t []) { 0xba8df8dd, 0xba8df8dd, 0xba8df8dd, 0xba8df8dd, 0xba8df8dd, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 800x600xbgr565 */, (grub_uint32_t []) { 0x84ac1329, 0x84ac1329, 0x84ac1329, 0x84ac1329, 0x84ac1329, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 1024x768xbgr565 */, (grub_uint32_t []) { 0x145ad698, 0x145ad698, 0x145ad698, 0x145ad698, 0x145ad698, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 640x480xbgr888 */, (grub_uint32_t []) { 0x4af6b480, 0x923db79c, 0xfe8cc449, 0x2647c755, 0x27ee23e3, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 800x600xbgr888 */, (grub_uint32_t []) { 0x121d5e29, 0xf66c0aed, 0xdf138150, 0x3b62d594, 0x8dec962a, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 1024x768xbgr888 */, (grub_uint32_t []) { 0xae86a12c, 0x4dabbe89, 0x6d30e897, 0x8e1df732, 0x2c0644ab, }, 5 },
+ { "videotest", 640, 480, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 640x480xbgr888 */, (grub_uint32_t []) { 0x2605d280, 0xc06e3172, 0xef3e6395, 0x9558067, 0xb19ec65b, }, 5 },
+ { "videotest", 800, 600, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 800x600xbgr888 */, (grub_uint32_t []) { 0x9404ef3b, 0xa4fdf18, 0xad7ef98c, 0x3335c9af, 0xe6f0c255, }, 5 },
+ { "videotest", 1024, 768, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 1024x768xbgr888 */, (grub_uint32_t []) { 0xa008b770, 0xb98eb0d8, 0x9304b820, 0x8a82bf88, 0xc610a9d0, }, 5 },
diff --git a/grub-core/tests/fake_input.c b/grub-core/tests/fake_input.c
new file mode 100644
index 0000000..b514c2a
--- /dev/null
+++ b/grub-core/tests/fake_input.c
@@ -0,0 +1,67 @@
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2013 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/term.h>
+#include <grub/mm.h>
+#include <grub/dl.h>
+#include <grub/test.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static int *seq;
+static int seqptr, nseq;
+static struct grub_term_input *saved;
+
+static int
+fake_getkey (struct grub_term_input *term __attribute__ ((unused)))
+{
+ if (seq && seqptr < nseq)
+ return seq[seqptr++];
+ return -1;
+}
+
+static struct grub_term_input fake_input_term =
+ {
+ .name = "fake",
+ .getkey = fake_getkey
+ };
+
+void
+grub_terminal_input_fake_sequence (int *seq_in, int nseq_in)
+{
+ if (!saved)
+ saved = grub_term_inputs;
+ if (seq)
+ grub_free (seq);
+ seq = grub_malloc (nseq_in * sizeof (seq[0]));
+ if (seq)
+ {
+ grub_term_inputs = &fake_input_term;
+ grub_memcpy (seq, seq_in, nseq_in * sizeof (seq[0]));
+ }
+ nseq = nseq_in;
+}
+
+void
+grub_terminal_input_fake_sequence_end (void)
+{
+ grub_term_inputs = saved;
+ grub_free (seq);
+ seq = 0;
+ nseq = 0;
+}
diff --git a/grub-core/tests/lib/functional_test.c b/grub-core/tests/lib/functional_test.c
index fd199bd..da4d5f8 100644
--- a/grub-core/tests/lib/functional_test.c
+++ b/grub-core/tests/lib/functional_test.c
@@ -30,9 +30,34 @@ grub_functional_test (grub_extcmd_context_t ctxt __attribute__ ((unused)),
char **args __attribute__ ((unused)))
{
grub_test_t test;
+ int ok = 1;
FOR_LIST_ELEMENTS (test, grub_test_list)
- grub_test_run (test);
+ ok = ok && !grub_test_run (test);
+ if (ok)
+ grub_printf ("ALL TESTS PASSED\n");
+ else
+ grub_printf ("TEST FAILURE\n");
+ return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_functional_all_tests (grub_extcmd_context_t ctxt __attribute__ ((unused)),
+ int argc __attribute__ ((unused)),
+ char **args __attribute__ ((unused)))
+{
+ grub_test_t test;
+ int ok = 1;
+
+ grub_dl_load ("exfctest");
+ grub_dl_load ("videotest_checksum");
+
+ FOR_LIST_ELEMENTS (test, grub_test_list)
+ ok = ok && !grub_test_run (test);
+ if (ok)
+ grub_printf ("ALL TESTS PASSED\n");
+ else
+ grub_printf ("TEST FAILURE\n");
return GRUB_ERR_NONE;
}
@@ -41,6 +66,8 @@ static grub_extcmd_t cmd;
GRUB_MOD_INIT (functional_test)
{
cmd = grub_register_extcmd ("functional_test", grub_functional_test, 0, 0,
+ "Run all loaded functional tests.", 0);
+ cmd = grub_register_extcmd ("all_functional_test", grub_functional_all_tests, 0, 0,
"Run all functional tests.", 0);
}
diff --git a/grub-core/tests/video_checksum.c b/grub-core/tests/video_checksum.c
new file mode 100644
index 0000000..b2aab79
--- /dev/null
+++ b/grub-core/tests/video_checksum.c
@@ -0,0 +1,435 @@
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2013 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/>.
+ */
+
+/* All tests need to include test.h for GRUB testing framework. */
+#include <grub/test.h>
+#include <grub/dl.h>
+#include <grub/video.h>
+#include <grub/lib/crc.h>
+#include <grub/mm.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static int ctr;
+static int nchk;
+static char *basename;
+static const grub_uint32_t *checksums;
+static struct grub_video_mode_info capt_mode_info;
+
+#ifdef GRUB_MACHINE_EMU
+#include <grub/emu/misc.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+struct bmp_header
+{
+ grub_uint8_t magic[2];
+ grub_uint32_t filesize;
+ grub_uint32_t reserved;
+ grub_uint32_t bmp_off;
+ grub_uint32_t head_size;
+ grub_uint16_t width;
+ grub_uint16_t height;
+ grub_uint16_t planes;
+ grub_uint16_t bpp;
+} __attribute__ ((packed));
+
+static void
+grub_video_capture_write_bmp (const char *fname,
+ void *ptr,
+ const struct grub_video_mode_info *mode_info)
+{
+ int fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+ struct bmp_header head;
+
+ if (fd < 0)
+ {
+ grub_printf (_("cannot open `%s': %s"),
+ fname, strerror (errno));
+ }
+
+ grub_memset (&head, 0, sizeof (head));
+
+ head.magic[0] = 'B';
+ head.magic[1] = 'M';
+
+ if (mode_info->mode_type & GRUB_VIDEO_MODE_TYPE_RGB)
+ {
+ head.filesize = grub_cpu_to_le32 (sizeof (head) + mode_info->width * mode_info->height * 3);
+ head.bmp_off = grub_cpu_to_le32 (sizeof (head));
+ head.bpp = grub_cpu_to_le16_compile_time (24);
+ }
+ else
+ {
+ head.filesize = grub_cpu_to_le32 (sizeof (head) + 3 * 256 + mode_info->width * mode_info->height);
+ head.bmp_off = grub_cpu_to_le32 (sizeof (head) + 3 * 256);
+ head.bpp = grub_cpu_to_le16_compile_time (8);
+ }
+ head.head_size = grub_cpu_to_le32 (sizeof (head) - 14);
+ head.width = grub_cpu_to_le16 (mode_info->width);
+ head.height = grub_cpu_to_le16 (mode_info->height);
+ head.planes = grub_cpu_to_le16_compile_time (1);
+
+ head.width = grub_cpu_to_le16 (mode_info->width);
+ head.height = grub_cpu_to_le16 (mode_info->height);
+
+ write (fd, &head, sizeof (head));
+
+ if (!(mode_info->mode_type & GRUB_VIDEO_MODE_TYPE_RGB))
+ {
+ struct grub_video_palette_data palette_data[256];
+ int i;
+ int palette_len = mode_info->number_of_colors;
+ grub_memset (palette_data, 0, sizeof (palette_data));
+ if (palette_len > 256)
+ palette_len = 256;
+ grub_video_get_palette (0, palette_len, palette_data);
+ for (i = 0; i < 256; i++)
+ {
+ grub_uint8_t r, g, b;
+ r = palette_data[i].r;
+ g = palette_data[i].g;
+ b = palette_data[i].b;
+
+ write (fd, &b, 1);
+ write (fd, &g, 1);
+ write (fd, &r, 1);
+ }
+ }
+
+ /* This does essentialy the same as some fbblit functions yet using
+ them would mean testing them against themselves so keep this
+ implemetation separate. */
+ switch (mode_info->bytes_per_pixel)
+ {
+ case 4:
+ {
+ grub_uint8_t *buffer = xmalloc (mode_info->width * 3);
+ grub_uint32_t rmask = ((1 << mode_info->red_mask_size) - 1);
+ grub_uint32_t gmask = ((1 << mode_info->green_mask_size) - 1);
+ grub_uint32_t bmask = ((1 << mode_info->blue_mask_size) - 1);
+ int rshift = mode_info->red_field_pos;
+ int gshift = mode_info->green_field_pos;
+ int bshift = mode_info->blue_field_pos;
+ int mulrshift = (8 - mode_info->red_mask_size);
+ int mulgshift = (8 - mode_info->green_mask_size);
+ int mulbshift = (8 - mode_info->blue_mask_size);
+ int y;
+
+ for (y = mode_info->height - 1; y >= 0; y--)
+ {
+ grub_uint32_t *iptr = (grub_uint32_t *) ((grub_uint8_t *) ptr + mode_info->pitch * y);
+ int x;
+ grub_uint8_t *optr = buffer;
+ for (x = 0; x < (int) mode_info->width; x++)
+ {
+ grub_uint32_t val = *iptr++;
+ *optr++ = ((val >> bshift) & bmask) << mulbshift;
+ *optr++ = ((val >> gshift) & gmask) << mulgshift;
+ *optr++ = ((val >> rshift) & rmask) << mulrshift;
+ }
+ write (fd, buffer, mode_info->width * 3);
+ }
+ grub_free (buffer);
+ break;
+ }
+ case 3:
+ {
+ grub_uint8_t *buffer = xmalloc (mode_info->width * 3);
+ grub_uint32_t rmask = ((1 << mode_info->red_mask_size) - 1);
+ grub_uint32_t gmask = ((1 << mode_info->green_mask_size) - 1);
+ grub_uint32_t bmask = ((1 << mode_info->blue_mask_size) - 1);
+ int rshift = mode_info->red_field_pos;
+ int gshift = mode_info->green_field_pos;
+ int bshift = mode_info->blue_field_pos;
+ int mulrshift = (8 - mode_info->red_mask_size);
+ int mulgshift = (8 - mode_info->green_mask_size);
+ int mulbshift = (8 - mode_info->blue_mask_size);
+ int y;
+
+ for (y = mode_info->height - 1; y >= 0; y--)
+ {
+ grub_uint8_t *iptr = ((grub_uint8_t *) ptr + mode_info->pitch * y);
+ int x;
+ grub_uint8_t *optr = buffer;
+ for (x = 0; x < (int) mode_info->width; x++)
+ {
+ grub_uint32_t val = 0;
+#ifdef GRUB_CPU_WORDS_BIGENDIAN
+ val |= *iptr++ << 16;
+ val |= *iptr++ << 8;
+ val |= *iptr++;
+#else
+ val |= *iptr++;
+ val |= *iptr++ << 8;
+ val |= *iptr++ << 16;
+#endif
+ *optr++ = ((val >> bshift) & bmask) << mulbshift;
+ *optr++ = ((val >> gshift) & gmask) << mulgshift;
+ *optr++ = ((val >> rshift) & rmask) << mulrshift;
+ }
+ write (fd, buffer, mode_info->width * 3);
+ }
+ grub_free (buffer);
+ break;
+ }
+ case 2:
+ {
+ grub_uint8_t *buffer = xmalloc (mode_info->width * 3);
+ grub_uint16_t rmask = ((1 << mode_info->red_mask_size) - 1);
+ grub_uint16_t gmask = ((1 << mode_info->green_mask_size) - 1);
+ grub_uint16_t bmask = ((1 << mode_info->blue_mask_size) - 1);
+ int rshift = mode_info->red_field_pos;
+ int gshift = mode_info->green_field_pos;
+ int bshift = mode_info->blue_field_pos;
+ int mulrshift = (8 - mode_info->red_mask_size);
+ int mulgshift = (8 - mode_info->green_mask_size);
+ int mulbshift = (8 - mode_info->blue_mask_size);
+ int y;
+
+ for (y = mode_info->height - 1; y >= 0; y--)
+ {
+ grub_uint16_t *iptr = (grub_uint16_t *) ((grub_uint8_t *) ptr + mode_info->pitch * y);
+ int x;
+ grub_uint8_t *optr = buffer;
+ for (x = 0; x < (int) mode_info->width; x++)
+ {
+ grub_uint16_t val = *iptr++;
+ *optr++ = ((val >> bshift) & bmask) << mulbshift;
+ *optr++ = ((val >> gshift) & gmask) << mulgshift;
+ *optr++ = ((val >> rshift) & rmask) << mulrshift;
+ }
+ write (fd, buffer, mode_info->width * 3);
+ }
+ grub_free (buffer);
+ break;
+ }
+ case 1:
+ {
+ int y;
+
+ for (y = mode_info->height - 1; y >= 0; y--)
+ write (fd, ((grub_uint8_t *) ptr + mode_info->pitch * y), mode_info->width);
+ break;
+ }
+ }
+ close (fd);
+}
+
+#endif
+
+static const char *
+get_modename (void)
+{
+ static char buf[40];
+ if (capt_mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)
+ {
+ grub_snprintf (buf, sizeof (buf), "i%d", capt_mode_info.number_of_colors);
+ return buf;
+ }
+ if (capt_mode_info.red_field_pos == 0)
+ {
+ grub_snprintf (buf, sizeof (buf), "bgr%d%d%d", capt_mode_info.blue_mask_size,
+ capt_mode_info.green_mask_size,
+ capt_mode_info.red_mask_size);
+ return buf;
+ }
+ grub_snprintf (buf, sizeof (buf), "rgb%d%d%d", capt_mode_info.red_mask_size,
+ capt_mode_info.green_mask_size,
+ capt_mode_info.blue_mask_size);
+ return buf;
+}
+
+//#define GENERATE_MODE 1
+
+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)
+int genfd = -1;
+#endif
+
+static void
+checksum (void)
+{
+ void *ptr;
+ grub_uint32_t crc;
+
+ ptr = grub_video_capture_get_framebuffer ();
+
+ crc = grub_getcrc32c (0, ptr, capt_mode_info.pitch * capt_mode_info.height);
+ if (!checksums || ctr >= nchk)
+ {
+ grub_test_assert (0, "Unexpected checksum %s_%dx%dx%s:%d: 0x%x",
+ basename,
+ capt_mode_info.width,
+ capt_mode_info.height, get_modename (), ctr, crc);
+ }
+ else if (crc != checksums[ctr])
+ {
+ grub_test_assert (0, "Checksum %s_%dx%dx%s:%d failed: 0x%x vs 0x%x",
+ basename,
+ capt_mode_info.width,
+ capt_mode_info.height, get_modename (),
+ ctr, crc, checksums[ctr]);
+ }
+ else
+ {
+#if !(defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU))
+ ctr++;
+ return;
+#endif
+ }
+#ifdef GRUB_MACHINE_EMU
+ char *name = grub_xasprintf ("%s_%dx%dx%s_%d.bmp", basename,
+ capt_mode_info.width,
+ capt_mode_info.height, get_modename (),
+ ctr);
+ grub_video_capture_write_bmp (name, ptr, &capt_mode_info);
+#endif
+
+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)
+ if (genfd >= 0)
+ {
+ char buf[20];
+ grub_snprintf (buf, sizeof (buf), "0x%x, ", crc);
+ write (genfd, buf, grub_strlen (buf));
+ }
+#endif
+
+ ctr++;
+}
+
+struct checksum_desc
+{
+ const char *name;
+ unsigned width;
+ unsigned height;
+ unsigned mode_type;
+ unsigned number_of_colors;
+ unsigned bpp;
+ unsigned bytes_per_pixel;
+ unsigned red_field_pos;
+ unsigned red_mask_size;
+ unsigned green_field_pos;
+ unsigned green_mask_size;
+ unsigned blue_field_pos;
+ unsigned blue_mask_size;
+ unsigned reserved_field_pos;
+ unsigned reserved_mask_size;
+ const grub_uint32_t *checksums;
+ int nchk;
+};
+
+const struct checksum_desc checksum_table[] = {
+#include "checksums.c"
+};
+
+void
+grub_video_checksum (const char *basename_in)
+{
+ unsigned i;
+
+ grub_video_get_info (&capt_mode_info);
+
+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)
+ if (genfd < 0)
+ genfd = open ("checksums.c", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+ if (genfd >= 0)
+ {
+ char buf[400];
+
+ grub_snprintf (buf, sizeof (buf), "\", %d, %d, 0x%x, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d /* %dx%dx%s */, (grub_uint32_t []) { ",
+ capt_mode_info.width,
+ capt_mode_info.height,
+ capt_mode_info.mode_type,
+ capt_mode_info.number_of_colors,
+ capt_mode_info.bpp,
+ capt_mode_info.bytes_per_pixel,
+ capt_mode_info.red_field_pos,
+ capt_mode_info.red_mask_size,
+ capt_mode_info.green_field_pos,
+ capt_mode_info.green_mask_size,
+ capt_mode_info.blue_field_pos,
+ capt_mode_info.blue_mask_size,
+ capt_mode_info.reserved_field_pos,
+ capt_mode_info.reserved_mask_size,
+ capt_mode_info.width,
+ capt_mode_info.height, get_modename ());
+
+ write (genfd, " { \"", 5);
+ write (genfd, basename_in, grub_strlen (basename_in));
+ write (genfd, buf, grub_strlen (buf));
+ }
+#endif
+
+ basename = grub_strdup (basename_in);
+ nchk = 0;
+ checksums = 0;
+ /* FIXME: optimize this. */
+ for (i = 0; i < ARRAY_SIZE (checksum_table); i++)
+ if (grub_strcmp (checksum_table[i].name, basename_in) == 0
+ && capt_mode_info.width == checksum_table[i].width
+ && capt_mode_info.height == checksum_table[i].height
+ && capt_mode_info.mode_type == checksum_table[i].mode_type
+ && capt_mode_info.number_of_colors == checksum_table[i].number_of_colors
+ && capt_mode_info.bpp == checksum_table[i].bpp
+ && capt_mode_info.bytes_per_pixel == checksum_table[i].bytes_per_pixel
+ && capt_mode_info.red_field_pos == checksum_table[i].red_field_pos
+ && capt_mode_info.red_mask_size == checksum_table[i].red_mask_size
+ && capt_mode_info.green_field_pos == checksum_table[i].green_field_pos
+ && capt_mode_info.green_mask_size == checksum_table[i].green_mask_size
+ && capt_mode_info.blue_field_pos == checksum_table[i].blue_field_pos
+ && capt_mode_info.blue_mask_size == checksum_table[i].blue_mask_size
+ && capt_mode_info.reserved_field_pos == checksum_table[i].reserved_field_pos
+ && capt_mode_info.reserved_mask_size == checksum_table[i].reserved_mask_size)
+ {
+ nchk = checksum_table[i].nchk;
+ checksums = checksum_table[i].checksums;
+ break;
+ }
+
+ ctr = 0;
+ grub_video_capture_refresh_cb = checksum;
+}
+
+void
+grub_video_checksum_end (void)
+{
+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)
+ if (genfd >= 0)
+ {
+ char buf[40];
+ grub_snprintf (buf, sizeof (buf), "}, %x },\n", ctr);
+ write (genfd, buf, grub_strlen (buf));
+ }
+#endif
+ grub_test_assert (ctr == nchk, "Not enough checksums %s_%dx%dx%s: %d vs %d",
+ basename,
+ capt_mode_info.width,
+ capt_mode_info.height, get_modename (),
+ ctr, nchk);
+ grub_free (basename);
+ basename = 0;
+ nchk = 0;
+ checksums = 0;
+ ctr = 0;
+ grub_video_capture_refresh_cb = 0;
+}
diff --git a/grub-core/tests/videotest_checksum.c b/grub-core/tests/videotest_checksum.c
new file mode 100644
index 0000000..e57dae7
--- /dev/null
+++ b/grub-core/tests/videotest_checksum.c
@@ -0,0 +1,286 @@
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2013 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/>.
+ */
+
+/* All tests need to include test.h for GRUB testing framework. */
+#include <grub/test.h>
+#include <grub/dl.h>
+#include <grub/video.h>
+#include <grub/video_fb.h>
+#include <grub/command.h>
+#include <grub/font.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+struct
+{
+ struct grub_video_mode_info mode_info;
+} tests[] = {
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 640,
+ .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+ .bpp = 8,
+ .bytes_per_pixel = 1,
+ .number_of_colors = GRUB_VIDEO_FBSTD_NUMCOLORS
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 800,
+ .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+ .bpp = 8,
+ .bytes_per_pixel = 1,
+ .number_of_colors = GRUB_VIDEO_FBSTD_NUMCOLORS
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 1024,
+ .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+ .bpp = 8,
+ .bytes_per_pixel = 1,
+ .number_of_colors = GRUB_VIDEO_FBSTD_NUMCOLORS
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 1280,
+ GRUB_VIDEO_MI_RGB555 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 1600,
+ GRUB_VIDEO_MI_RGB555 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 2048,
+ GRUB_VIDEO_MI_RGB555 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 1280,
+ GRUB_VIDEO_MI_RGB565 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 1600,
+ GRUB_VIDEO_MI_RGB565 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 2048,
+ GRUB_VIDEO_MI_RGB565 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 640 * 3,
+ GRUB_VIDEO_MI_RGB888 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 800 * 3,
+ GRUB_VIDEO_MI_RGB888 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 1024 * 3,
+ GRUB_VIDEO_MI_RGB888 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 640 * 4,
+ GRUB_VIDEO_MI_RGBA8888()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 800 * 4,
+ GRUB_VIDEO_MI_RGBA8888()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 1024 * 4,
+ GRUB_VIDEO_MI_RGBA8888()
+ },
+ },
+
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 1280,
+ GRUB_VIDEO_MI_BGR555 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 1600,
+ GRUB_VIDEO_MI_BGR555 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 2048,
+ GRUB_VIDEO_MI_BGR555 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 1280,
+ GRUB_VIDEO_MI_BGR565 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 1600,
+ GRUB_VIDEO_MI_BGR565 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 2048,
+ GRUB_VIDEO_MI_BGR565 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 640 * 3,
+ GRUB_VIDEO_MI_BGR888 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 800 * 3,
+ GRUB_VIDEO_MI_BGR888 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 1024 * 3,
+ GRUB_VIDEO_MI_BGR888 ()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 640,
+ .height = 480,
+ .pitch = 640 * 4,
+ GRUB_VIDEO_MI_BGRA8888()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 800,
+ .height = 600,
+ .pitch = 800 * 4,
+ GRUB_VIDEO_MI_BGRA8888()
+ },
+ },
+ {
+ .mode_info = {
+ .width = 1024,
+ .height = 768,
+ .pitch = 1024 * 4,
+ GRUB_VIDEO_MI_BGRA8888()
+ },
+ },
+
+ };
+
+
+/* Functional test main method. */
+static void
+videotest_checksum (void)
+{
+ unsigned i;
+ grub_font_load ("unicode");
+ for (i = 0; i < ARRAY_SIZE (tests); i++)
+ {
+ grub_video_capture_start (&tests[i].mode_info,
+ grub_video_fbstd_colors,
+ GRUB_VIDEO_FBSTD_NUMCOLORS);
+ grub_terminal_input_fake_sequence ((int []) { '\n' }, 1);
+
+ grub_video_checksum ("videotest");
+
+ char *args[] = { 0 };
+ grub_command_execute ("videotest", 0, args);
+ grub_video_checksum_end ();
+ grub_video_capture_end ();
+ }
+}
+
+/* Register example_test method as a functional test. */
+GRUB_FUNCTIONAL_TEST (videotest_checksum, videotest_checksum);
diff --git a/grub-core/video/capture.c b/grub-core/video/capture.c
new file mode 100644
index 0000000..be7fb61
--- /dev/null
+++ b/grub-core/video/capture.c
@@ -0,0 +1,128 @@
+
+#define grub_video_render_target grub_video_fbrender_target
+
+#include <grub/video.h>
+#include <grub/video_fb.h>
+#include <grub/mm.h>
+
+static struct
+{
+ struct grub_video_mode_info mode_info;
+ struct grub_video_render_target *render_target;
+ grub_uint8_t *ptr;
+} framebuffer;
+
+void (*grub_video_capture_refresh_cb) (void);
+
+static grub_err_t
+grub_video_capture_swap_buffers (void)
+{
+ if (grub_video_capture_refresh_cb)
+ grub_video_capture_refresh_cb ();
+ return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_video_capture_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 struct grub_video_adapter grub_video_capture_adapter =
+ {
+ .name = "Render capture",
+
+ .prio = 0,
+ .id = GRUB_VIDEO_ADAPTER_CAPTURE,
+
+ .fini = grub_video_fb_fini,
+ .get_info = grub_video_fb_get_info,
+ .get_info_and_fini = 0,
+ .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_capture_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_capture_set_active_render_target,
+ .get_active_render_target = grub_video_fb_get_active_render_target,
+
+ .next = 0
+ };
+
+static struct grub_video_adapter *saved;
+static struct grub_video_mode_info saved_mode_info;
+
+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)
+{
+ grub_err_t err;
+ grub_memset (&framebuffer, 0, sizeof (framebuffer));
+
+ grub_video_fb_init ();
+
+ framebuffer.mode_info = *mode_info;
+ framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
+
+ framebuffer.ptr = grub_malloc (framebuffer.mode_info.height * framebuffer.mode_info.pitch);
+ if (!framebuffer.ptr)
+ return grub_errno;
+
+ 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, palette_size, palette);
+ if (err)
+ return err;
+
+ saved = grub_video_adapter_active;
+ if (saved)
+ {
+ grub_video_get_info (&saved_mode_info);
+ if (saved->fini)
+ saved->fini ();
+ }
+ grub_video_adapter_active = &grub_video_capture_adapter;
+
+ return GRUB_ERR_NONE;
+}
+
+void *
+grub_video_capture_get_framebuffer (void)
+{
+ return framebuffer.ptr;
+}
+
+void
+grub_video_capture_end (void)
+{
+ grub_free (framebuffer.ptr);
+ grub_video_fb_fini ();
+ grub_video_adapter_active = saved;
+ if (saved)
+ {
+ if (saved->init)
+ saved->init ();
+ if (saved->setup)
+ saved->setup (saved_mode_info.width, saved_mode_info.height, 0, 0);
+ }
+}
diff --git a/grub-core/video/video.c b/grub-core/video/video.c
index 844f36c..90b5253 100644
--- a/grub-core/video/video.c
+++ b/grub-core/video/video.c
@@ -29,7 +29,7 @@ GRUB_MOD_LICENSE ("GPLv3+");
grub_video_adapter_t grub_video_adapter_list = NULL;
/* Active video adapter. */
-static grub_video_adapter_t grub_video_adapter_active;
+grub_video_adapter_t grub_video_adapter_active;
/* Restore back to initial mode (where applicable). */
grub_err_t
@@ -510,6 +510,9 @@ grub_video_set_mode (const char *modestring,
if (! modevar)
return grub_errno;
+ if (grub_video_adapter_active && grub_video_adapter_active->id == GRUB_VIDEO_ADAPTER_CAPTURE)
+ return GRUB_ERR_NONE;
+
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)
@@ -714,11 +717,3 @@ grub_video_set_mode (const char *modestring,
return grub_error (GRUB_ERR_BAD_ARGUMENT,
N_("no suitable video mode found"));
}
-
-#ifdef GRUB_UTIL
-void
-grub_video_set_adapter (grub_video_adapter_t adapter)
-{
- grub_video_adapter_active = adapter;
-}
-#endif
diff --git a/include/grub/emu/export.h b/include/grub/emu/export.h
index 1e2f043..7f9e4e1 100644
--- a/include/grub/emu/export.h
+++ b/include/grub/emu/export.h
@@ -3,4 +3,5 @@ void EXPORT_FUNC (close) (void);
void EXPORT_FUNC (read) (void);
void EXPORT_FUNC (write) (void);
void EXPORT_FUNC (ioctl) (void);
-
+void EXPORT_FUNC (__errno_location) (void);
+void EXPORT_FUNC (strerror) (void);
diff --git a/include/grub/test.h b/include/grub/test.h
index d876f57..6aa4069 100644
--- a/include/grub/test.h
+++ b/include/grub/test.h
@@ -90,4 +90,13 @@ void grub_unit_test_fini (void);
grub_test_unregister (#name); \
}
+void
+grub_video_checksum (const char *basename_in);
+void
+grub_video_checksum_end (void);
+void
+grub_terminal_input_fake_sequence (int *seq_in, int nseq_in);
+void
+grub_terminal_input_fake_sequence_end (void);
+
#endif /* ! GRUB_TEST_HEADER */
diff --git a/include/grub/video.h b/include/grub/video.h
index bd5852e..6308177 100644
--- a/include/grub/video.h
+++ b/include/grub/video.h
@@ -284,7 +284,8 @@ typedef enum grub_video_driver_id
GRUB_VIDEO_DRIVER_SIS315PRO,
GRUB_VIDEO_DRIVER_RADEON_FULOONG2E,
GRUB_VIDEO_DRIVER_COREBOOT,
- GRUB_VIDEO_DRIVER_IEEE1275
+ GRUB_VIDEO_DRIVER_IEEE1275,
+ GRUB_VIDEO_ADAPTER_CAPTURE
} grub_video_driver_id_t;
typedef enum grub_video_adapter_prio
@@ -544,9 +545,122 @@ extern void grub_video_sis315pro_fini (void);
extern void grub_video_radeon_fuloong2e_fini (void);
#endif
-#ifdef GRUB_UTIL
void
grub_video_set_adapter (grub_video_adapter_t adapter);
-#endif
+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 */
diff --git a/tests/grub_func_test.in b/tests/grub_func_test.in
new file mode 100644
index 0000000..a149cf9
--- /dev/null
+++ b/tests/grub_func_test.in
@@ -0,0 +1,12 @@
+#! /bin/bash
+set -e
+
+. "@builddir@/grub-core/modinfo.sh"
+
+out=`echo all_functional_test | @builddir@/grub-shell`
+
+if [ "$(echo "$out" | tail -n 1)" != "ALL TESTS PASSED" ]; then
+ echo "Functional test failure: $out"
+ exit 1
+fi
+
diff --git a/tests/util/grub-shell.in b/tests/util/grub-shell.in
index 1d7dfb8..dfde836 100644
--- a/tests/util/grub-shell.in
+++ b/tests/util/grub-shell.in
@@ -408,6 +408,8 @@ if [ x$boot = xnet ]; then
timeout -s KILL $timeout "${qemu}" ${qemuopts} -nographic ${serial_null} -serial file:/dev/stdout -monitor file:/dev/null -boot n -net "user,tftp=$netdir,bootfile=/boot/grub/${grub_modinfo_target_cpu}-${grub_modinfo_platform}/core.$netbootext" -net nic | cat | tr -d "\r" | do_trim
elif [ x$boot = xemu ]; then
grubdir="$(mktemp -d "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX")"
+ mkdir -p "$grubdir/fonts"
+ cp "@builddir@/"unicode.pf2 "$grubdir/fonts/unicode.pf2"
cp "${cfgfile}" "$grubdir/grub.cfg"
cp "${source}" "$grubdir/testcase.cfg"
@builddir@/grub-core/grub-emu -m "$device_map" -d "$grubdir" | tr -d "\r" | do_trim
diff --git a/util/grub-render-label.c b/util/grub-render-label.c
index 7237759..32d3774 100644
--- a/util/grub-render-label.c
+++ b/util/grub-render-label.c
@@ -1,6 +1,6 @@
/*
* GRUB -- GRand Unified Bootloader
- * Copyright (C) 2010,2012 Free Software Foundation, Inc.
+ * Copyright (C) 2010,2012,2013 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
@@ -17,8 +17,6 @@
*/
-#define grub_video_render_target grub_video_fbrender_target
-
#include <config.h>
#include <grub/util/misc.h>
@@ -74,58 +72,6 @@ static struct argp_option options[] = {
#include <grub/video.h>
#include <grub/video_fb.h>
-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_text_render_swap_buffers (void)
-{
- return GRUB_ERR_NONE;
-}
-
-static grub_err_t
-grub_video_text_render_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 struct grub_video_adapter grub_video_text_render_adapter =
- {
- .name = "Text rendering",
-
- .prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE,
-
- .fini = grub_video_fb_fini,
- .get_info = grub_video_fb_get_info,
- .get_info_and_fini = 0,
- .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_text_render_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_text_render_set_active_render_target,
- .get_active_render_target = grub_video_fb_get_active_render_target,
-
- .next = 0
- };
-
static error_t
argp_parser (int key, char *arg, struct argp_state *state)
{
@@ -208,6 +154,7 @@ main (int argc, char *argv[])
0x77, 0x66, 0x3f, 0x27 };
int i, j, k, cptr = 0;
grub_uint8_t bg, fg;
+ struct grub_video_mode_info mode_info;
for (i = 0; i < 256; i++)
ieee1275_palette[i].a = 0xff;
@@ -340,32 +287,17 @@ main (int argc, char *argv[])
width = grub_font_get_string_width (font, text) + 10;
height = grub_font_get_height (font);
- grub_memset (&framebuffer, 0, sizeof (framebuffer));
-
- grub_video_fb_init ();
+ mode_info.width = width;
+ mode_info.height = height;
+ mode_info.pitch = width;
- framebuffer.mode_info.width = width;
- framebuffer.mode_info.height = height;
- framebuffer.mode_info.pitch = width;
+ 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;
- framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
- framebuffer.mode_info.bpp = 8;
- framebuffer.mode_info.bytes_per_pixel = 1;
- framebuffer.mode_info.number_of_colors = 256;
-
- framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
-
- /* For some reason sparc64 uses 32-bit pointer too. */
- framebuffer.ptr = xmalloc (height * width);
-
- grub_video_fb_create_render_target_from_pointer (&framebuffer.render_target,
- &framebuffer.mode_info,
- framebuffer.ptr);
- grub_video_fb_set_active_render_target (framebuffer.render_target);
- grub_video_fb_set_palette (0, ARRAY_SIZE (ieee1275_palette),
- ieee1275_palette);
-
- grub_video_set_adapter (&grub_video_text_render_adapter);
+ grub_video_capture_start (&mode_info, ieee1275_palette,
+ ARRAY_SIZE (ieee1275_palette));
fg = grub_video_map_rgb (arguments.fgcolor.red,
arguments.fgcolor.green,
@@ -374,18 +306,17 @@ main (int argc, char *argv[])
arguments.bgcolor.green,
arguments.bgcolor.blue);
- grub_memset (framebuffer.ptr, bg, height * width);
+ grub_memset (grub_video_capture_get_framebuffer (), bg, height * width);
grub_font_draw_string (text, font, fg,
5, grub_font_get_ascent (font));
- grub_video_set_adapter (0);
-
head.magic = 1;
head.width = grub_cpu_to_be16 (width);
head.height = grub_cpu_to_be16 (height);
fwrite (&head, 1, sizeof (head), out);
- fwrite (framebuffer.ptr, 1, width * height, out);
+ fwrite (grub_video_capture_get_framebuffer (), 1, width * height, out);
+ grub_video_capture_end ();
if (out != stdout)
fclose (out);
--
1.8.2.1