1508 lines
46 KiB
Diff
1508 lines
46 KiB
Diff
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
|
|
|