16 Jun
2007
16 Jun
'07
2:07 a.m.
The problem: the new bootvid needs vga, which the olpc doesn`t have...
For the other problem (freeloader import problem): He can't press enter on
this machine because of the bios.
Perhaps that could be better solved by a new option in freeldr, which make
disappear all messages in say 3-5 seconds.
I'm afraid that fireballs sollution is merged into trunk in some time,
which would hide this problem indead.
Do not add any new hack to reactos, that will create a
new hell we already
manger getting out from ntoskrnl.
it took alex 1-2 year fix.
and we all have been agree not adding any new hacks to
reactos, do a proper fix, try figout what it really cause of the problem.
some times I stting weeks debug win32k
to solv a serten bug. or I can choice write a hack solv
it within 5mins. please do proper fix not hacks, even a proper fix leads
to
allot more problem at moment I can not boot reactos now after all new
hacks.
thanks allot
----- Original Message -----
From: "Alex Ionescu" <ionucu(a)videotron.ca To: <ros-dev(a)reactos.org
Sent: Friday, June 15, 2007 8:51 PM
Subject: Re: [ros-dev] [ros-diffs] [fireball] 27186: - Resurrect
"old"bootvid. The plan is to * make it working in trunk * addframebuffer
support for olpc and xbox kind of devices.
============================================================================
==
> Modified:
branches/olpc/drivers/base/bootvid/bootvid.c
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
============================================================================
==
> +
> +//#define USE_PROGRESS_BAR
> +
> +/* GLOBALS
*******************************************************************/
> Propchange:
branches/olpc/drivers/base/bootvid/bootvid.c
> --------------------------------------------------------------------------
----
> --- svn:needs-lock (original)
> +++ svn:needs-lock (removed)
> @@ -1,1 +1,0 @@
> -*
> Modified:
branches/olpc/drivers/base/bootvid/bootvid.def
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
============================================================================
==
> EXPORTS
> -VidBitBlt@12
> -VidBufferToScreenBlt@24
> -VidCleanUp@0
> -VidDisplayString@4
> -VidDisplayStringXY
> -VidInitialize@4
> -VidResetDisplay@4
> -VidScreenToBufferBlt@24
> -VidSetScrollRegion@16
> -VidSetTextColor@4
> -VidSolidColorFill@20
> -
> +VidInitialize
> +VidCleanUp
> +VidResetDisplay
> +VidBufferToScreenBlt
> +VidScreenToBufferBlt
> +VidBitBlt
> +VidSolidColorFill
> +VidDisplayString
> +BootVidDisplayBootLogo
> +BootVidUpdateProgress
> +BootVidFinalizeBootLogo
> Propchange:
branches/olpc/drivers/base/bootvid/bootvid.def
> --------------------------------------------------------------------------
----
> --- svn:needs-lock (original)
> +++ svn:needs-lock (removed)
> @@ -1,1 +1,0 @@
> -*
> Modified:
branches/olpc/drivers/base/bootvid/bootvid.rbuild
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
============================================================================
==
> <bootstrap
base="$(CDOUTPUT)" nameoncd="bootvid.dll" / > <include base="bootvid">.</include > - <define name="__USE_W32API"
/ > + <define
name="__USE_W32API" / >
<library>ntoskrnl</library >
<library>hal</library >
<file>bootvid.c</file > -
<file>bootdata.c</file > -
<file>vga.c</file > +
<file>vid.c</file > +
<file>vid_vga.c</file > +
<file>vid_vgatext.c</file > +
<file>vid_xbox.c</file >
<file>bootvid.rc</file >
-</module > +</module
> Propchange: branches/olpc/drivers/base/bootvid/bootvid.rbuild
> --------------------------------------------------------------------------
----
> --- svn:needs-lock (original)
> +++ svn:needs-lock (removed)
> @@ -1,1 +1,0 @@
> -*
> Modified:
branches/olpc/drivers/base/bootvid/bootvid.rc
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
============================================================================
==
> --- branches/olpc/drivers/base/bootvid/bootvid.rc (original)
> +++ branches/olpc/drivers/base/bootvid/bootvid.rc Fri Jun 15 14:58:37
> 2007
> @@ -3,8 +3,12 @@
> #include "resource.h"
> #define REACTOS_VERSION_DLL
> -#define REACTOS_STR_FILE_DESCRIPTION "VGA Boot Driver\0"
> -#define REACTOS_STR_INTERNAL_NAME "bootvid.dll\0"
> -#define REACTOS_STR_ORIGINAL_FILENAME "bootvid.dll\0"
> +#define REACTOS_STR_FILE_DESCRIPTION "ReactOS Boot Video\0"
> +#define REACTOS_STR_INTERNAL_NAME "bootvid\0"
> +#define REACTOS_STR_ORIGINAL_FILENAME "bootvid.sys\0"
> +#include <reactos/version.rc > -#include <reactos/version.rc > +IDB_BOOTIMAGE BITMAP DISCARDABLE
"bootimage.bmp"
> +IDB_BAR BITMAP DISCARDABLE "bar.bmp"
> +
> +
> Propchange:
branches/olpc/drivers/base/bootvid/bootvid.rc
> --------------------------------------------------------------------------
----
> --- svn:needs-lock (original)
> +++ svn:needs-lock (removed)
> @@ -1,1 +1,0 @@
> -*
> Removed:
branches/olpc/drivers/base/bootvid/precomp.h
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/preco…
============================================================================
==
> --- branches/olpc/drivers/base/bootvid/precomp.h (original)
> +++ branches/olpc/drivers/base/bootvid/precomp.h (removed)
> @@ -1,46 +1,0 @@
> -#include "ntddk.h"
> -#include "arc/arc.h"
> -#include "halfuncs.h"
> -#include "drivers/bootvid/bootvid.h"
> -
> -//
> -// Command Stream Definitions
> -//
> -#define CMD_STREAM_WRITE 0x0
> -#define CMD_STREAM_WRITE_ARRAY 0x2
> -#define CMD_STREAM_USHORT 0x4
> -#define CMD_STREAM_READ 0x8
> -
> -//
> -// Bitmap Header
> -//
> -typedef struct tagBITMAPINFOHEADER
> -{
> - ULONG biSize;
> - LONG biWidth;
> - LONG biHeight;
> - USHORT biPlanes;
> - USHORT biBitCount;
> - ULONG biCompression;
> - ULONG biSizeImage;
> - LONG biXPelsPerMeter;
> - LONG biYPelsPerMeter;
> - ULONG biClrUsed;
> - ULONG biClrImportant;
> -} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
> -
> -VOID
> -NTAPI
> -InitializePalette(
> - VOID
> -);
> -
> -//
> -// Globals
> -//
> -extern USHORT AT_Initialization[];
> -extern ULONG curr_x;
> -extern ULONG curr_y;
> -extern ULONG_PTR VgaRegisterBase;
> -extern ULONG_PTR VgaBase;
> -extern UCHAR FontData[256 * 13];
> Removed:
branches/olpc/drivers/base/bootvid/vga.c
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/vga.c…
============================================================================
==
3);
>
_______________________________________________
> Ros-dev mailing list
> Ros-dev(a)reactos.org
> http://www.reactos.org/mailman/listinfo/ros-dev
_______________________________________________
Ros-dev mailing list
Ros-dev(a)reactos.org
http://www.reactos.org/mailman/listinfo/ros-dev
Screwing up compatibility continues! Here's
an idea, let's rename all
the
kernel exports!
-----Original Message-----
From: ros-diffs-bounces(a)reactos.org
[mailto:ros-diffs-bounces@reactos.org]
On Behalf Of fireball(a)svn.reactos.org
Sent: Friday, June 15, 2007 3:59 AM
To: ros-diffs(a)reactos.org
Subject: [ros-diffs] [fireball] 27186: - Resurrect "old" bootvid. The
plan
is to * make it working in trunk * add framebuffer support for olpc and
xbox
kind of devices.
Author: fireball
Date: Fri Jun 15 14:58:37 2007
New Revision: 27186
URL: http://svn.reactos.org/svn/reactos?rev=27186&view=rev
Log:
- Resurrect "old" bootvid. The plan is to
* make it working in trunk
* add framebuffer support for olpc and xbox kind of devices.
Added:
branches/olpc/drivers/base/bootvid/bar.bmp
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/bar.bmp
branches/olpc/drivers/base/bootvid/bootimage.bmp
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/bootimage.bmp
branches/olpc/drivers/base/bootvid/bootvid.h
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/bootvid.h
branches/olpc/drivers/base/bootvid/resource.h
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/resource.h
branches/olpc/drivers/base/bootvid/vid.c
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/vid.c
branches/olpc/drivers/base/bootvid/vid_vga.c
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/vid_vga.c
branches/olpc/drivers/base/bootvid/vid_vgatext.c
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/vid_vgatext.c
branches/olpc/drivers/base/bootvid/vid_xbox.c
- copied unchanged from r25677,
trunk/reactos/drivers/base/bootvid/vid_xbox.c
Removed:
branches/olpc/drivers/base/bootvid/bootdata.c
branches/olpc/drivers/base/bootvid/precomp.h
branches/olpc/drivers/base/bootvid/vga.c
Modified:
branches/olpc/drivers/base/bootvid/bootvid.c (contents, props
changed)
branches/olpc/drivers/base/bootvid/bootvid.def (contents, props
changed)
branches/olpc/drivers/base/bootvid/bootvid.rbuild (contents, props
changed)
branches/olpc/drivers/base/bootvid/bootvid.rc
(contents, props
changed)
Removed: branches/olpc/drivers/base/bootvid/bootdata.c
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootd…
--- branches/olpc/drivers/base/bootvid/bootdata.c
(original)
+++ branches/olpc/drivers/base/bootvid/bootdata.c (removed)
@@ -1,309 +1,0 @@
-#include "precomp.h"
-
-USHORT AT_Initialization[] =
-{
- 0x10 | CMD_STREAM_READ, // Major Command = 0x10. Minor Command
=
0x08.
- 0x3DA, // Index Status
1 Register Port Address
-
- //
- // This Stream performs a USHORT Array Indexed Write at port 0x3C0
- //
- 0x20 | 0x01, // Major Command = 0x20. Minor Command
=
0x01.
- 0x3C0, // Attribute
Controller Data Register
- 0x10, // Loop Count = 16 (Number of Pallette
Entries)
- 0x0, // Index to
select (Index = 0,
palettes)
- 0x00, // Palette 0
- 0x01, // Palette 1
- 0x02, // Palette 2
- 0x03, // Palette 3
- 0x04, // Palette 4
- 0x05, // Palette 5
- 0x06, // Palette 6
- 0x07, // Palette 7
- 0x08, // Palette 8
- 0x09, // Palette 9
- 0x0A, // Palette 10
- 0x0B, // Palette 11
- 0x0C, // Palette 12
- 0x0D, // Palette 13
- 0x0E, // Palette 14
- 0x0F, // Palette 15
-
- //
- // This Stream performs a UCHAR READ of port 0x3DA
- //
- 0x10 | CMD_STREAM_READ, // Major Command = 0x10. Minor Command
=
0x08.
- 0x3DA, // Index Status
1 Register Port Address
-
- //
- // This Stream performs a UCHAR WRITE of value 0x20 at port 0x3C0
- //
- 0x10 | CMD_STREAM_WRITE, // Major Command = 0x10. Minor Command
=
0x00.
- 0x3C0, // Attribute
Controller Data Register
- 0x20, // Set Palette Address Source
-
- //
- // End of Stream Marker
- //
- 0x0 // End of command stream
-};
-
-UCHAR FontData[256 * 13] =
-{
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00,
0x00, 0x00,
// 0
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 13
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 26
- 0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 39
- 0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 52
- 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 65
- 0x24, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 78
- 0x10, 0x28, 0x10, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 91
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x10,
0x10, 0x10, // 104
- 0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 117
- 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 130
- 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 143
- 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 156
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x10, 0x10, // 169
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 182
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 195
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 208
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 221
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 234
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 247
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 260
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 273
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 286
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 299
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 312
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 325
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 338
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 351
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 364
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 377
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 390
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 403
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 416
- 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x00, 0x00, 0x10, 0x00,
0x00, 0x00, // 429
- 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 442
- 0x00, 0x14, 0x14, 0x14, 0x7F, 0x28, 0xFE,
0x50, 0x50, 0x50, 0x00,
0x00, 0x00, // 455
- 0x10, 0x3C, 0x50, 0x50, 0x70, 0x38, 0x1C,
0x14, 0x14, 0x78, 0x10,
0x00, 0x00, // 468
- 0x00, 0x61, 0x92, 0x94, 0x68, 0x18, 0x16,
0x29, 0x49, 0x86, 0x00,
0x00, 0x00, // 481
- 0x00, 0x18, 0x24, 0x24, 0x38, 0x71, 0x89,
0x8E, 0xC6, 0x7E, 0x00,
0x00, 0x00, // 494
- 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 507
- 0x06, 0x08, 0x10, 0x30, 0x20, 0x20, 0x20,
0x20, 0x30, 0x10, 0x08,
0x06, 0x00, // 520
- 0x60, 0x10, 0x08, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x08, 0x10,
0x60, 0x00, // 533
- 0x00, 0x10, 0x52, 0x24, 0x3C, 0x24, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 546
- 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE,
0x10, 0x10, 0x10, 0x00,
0x00, 0x00, // 559
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x30, 0x30, 0x10,
0x20, 0x00, // 572
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 585
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x30, 0x30, 0x00,
0x00, 0x00, // 598
- 0x01, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10,
0x10, 0x20, 0x40, 0x40,
0x80, 0x00, // 611
- 0x00, 0x18, 0x24, 0x42, 0x42, 0x42, 0x42,
0x42, 0x24, 0x3C, 0x00,
0x00, 0x00, // 624
- 0x00, 0x30, 0xD0, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0xFE, 0x00,
0x00, 0x00, // 637
- 0x00, 0x78, 0x04, 0x04, 0x04, 0x08, 0x10,
0x20, 0x40, 0x7C, 0x00,
0x00, 0x00, // 650
- 0x00, 0x78, 0x04, 0x04, 0x08, 0x30, 0x0C,
0x04, 0x04, 0x78, 0x00,
0x00, 0x00, // 663
- 0x00, 0x08, 0x18, 0x28, 0x28, 0x48, 0x88,
0xFC, 0x08, 0x08, 0x00,
0x00, 0x00, // 676
- 0x00, 0x3C, 0x20, 0x20, 0x38, 0x04, 0x04,
0x04, 0x04, 0x38, 0x00,
0x00, 0x00, // 689
- 0x00, 0x1C, 0x20, 0x40, 0x5C, 0x62, 0x42,
0x42, 0x22, 0x1C, 0x00,
0x00, 0x00, // 702
- 0x00, 0x7E, 0x02, 0x04, 0x08, 0x08, 0x10,
0x10, 0x20, 0x20, 0x00,
0x00, 0x00, // 715
- 0x00, 0x3C, 0x42, 0x42, 0x24, 0x3C, 0x46,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 728
- 0x00, 0x38, 0x44, 0x42, 0x42, 0x46, 0x3A,
0x02, 0x04, 0x38, 0x00,
0x00, 0x00, // 741
- 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
0x00, 0x18, 0x18, 0x00,
0x00, 0x00, // 754
- 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00,
0x00, 0x30, 0x30, 0x10,
0x20, 0x00, // 767
- 0x00, 0x00, 0x00, 0x02, 0x0C, 0x10, 0x60,
0x10, 0x0C, 0x02, 0x00,
0x00, 0x00, // 780
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00,
0x7E, 0x00, 0x00, 0x00,
0x00, 0x00, // 793
- 0x00, 0x00, 0x00, 0x40, 0x30, 0x08, 0x06,
0x08, 0x30, 0x40, 0x00,
0x00, 0x00, // 806
- 0x00, 0x7C, 0x42, 0x02, 0x04, 0x08, 0x10,
0x00, 0x00, 0x10, 0x00,
0x00, 0x00, // 819
- 0x00, 0x3C, 0x62, 0xDE, 0xB2, 0xA2, 0xA6,
0x9B, 0x44, 0x3C, 0x00,
0x00, 0x00, // 832
- 0x00, 0x00, 0x18, 0x18, 0x24, 0x24, 0x24,
0x7E, 0x42, 0x81, 0x00,
0x00, 0x00, // 845
- 0x00, 0x00, 0x7C, 0x42, 0x42, 0x7C, 0x42,
0x42, 0x42, 0x7C, 0x00,
0x00, 0x00, // 858
- 0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x80,
0x80, 0x40, 0x3E, 0x00,
0x00, 0x00, // 871
- 0x00, 0x00, 0x78, 0x44, 0x42, 0x42, 0x42,
0x42, 0x44, 0x78, 0x00,
0x00, 0x00, // 884
- 0x00, 0x00, 0x7E, 0x40, 0x40, 0x40, 0x7C,
0x40, 0x40, 0x7E, 0x00,
0x00, 0x00, // 897
- 0x00, 0x00, 0x7E, 0x40, 0x40, 0x40, 0x7C,
0x40, 0x40, 0x40, 0x00,
0x00, 0x00, // 910
- 0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x8E,
0x82, 0x42, 0x3E, 0x00,
0x00, 0x00, // 923
- 0x00, 0x00, 0x42, 0x42, 0x42, 0x7E, 0x42,
0x42, 0x42, 0x42, 0x00,
0x00, 0x00, // 936
- 0x00, 0x00, 0x7C, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x7C, 0x00,
0x00, 0x00, // 949
- 0x00, 0x00, 0x3C, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x78, 0x00,
0x00, 0x00, // 962
- 0x00, 0x00, 0x42, 0x44, 0x48, 0x70, 0x50,
0x48, 0x44, 0x42, 0x00,
0x00, 0x00, // 975
- 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40,
0x40, 0x40, 0x7E, 0x00,
0x00, 0x00, // 988
- 0x00, 0x00, 0xC6, 0xC6, 0xAA, 0xAA, 0xAA,
0x92, 0x82, 0x82, 0x00,
0x00, 0x00, // 1001
- 0x00, 0x00, 0x42, 0x62, 0x52, 0x52, 0x4A,
0x4A, 0x46, 0x42, 0x00,
0x00, 0x00, // 1014
- 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82,
0x82, 0x44, 0x38, 0x00,
0x00, 0x00, // 1027
- 0x00, 0x00, 0x7C, 0x42, 0x42, 0x42, 0x7C,
0x40, 0x40, 0x40, 0x00,
0x00, 0x00, // 1040
- 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82,
0x82, 0x44, 0x38, 0x06,
0x03, 0x00, // 1053
- 0x00, 0x00, 0x78, 0x44, 0x44, 0x44, 0x78,
0x48, 0x44, 0x42, 0x00,
0x00, 0x00, // 1066
- 0x00, 0x00, 0x3E, 0x40, 0x40, 0x38, 0x04,
0x02, 0x02, 0x7C, 0x00,
0x00, 0x00, // 1079
- 0x00, 0x00, 0xFE, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x00,
0x00, 0x00, // 1092
- 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 1105
- 0x00, 0x00, 0x81, 0x42, 0x42, 0x44, 0x24,
0x28, 0x38, 0x10, 0x00,
0x00, 0x00, // 1118
- 0x00, 0x00, 0x81, 0x81, 0x92, 0x5A, 0x5A,
0x6A, 0x66, 0x24, 0x00,
0x00, 0x00, // 1131
- 0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x18,
0x24, 0x42, 0x81, 0x00,
0x00, 0x00, // 1144
- 0x00, 0x00, 0x82, 0x44, 0x28, 0x28, 0x10,
0x10, 0x10, 0x10, 0x00,
0x00, 0x00, // 1157
- 0x00, 0x00, 0xFE, 0x02, 0x04, 0x08, 0x10,
0x20, 0x40, 0xFE, 0x00,
0x00, 0x00, // 1170
- 0x1E, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10,
0x1E, 0x00, // 1183
- 0x80, 0x40, 0x40, 0x20, 0x10, 0x10, 0x08,
0x08, 0x04, 0x02, 0x02,
0x01, 0x00, // 1196
- 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08,
0x78, 0x00, // 1209
- 0x00, 0x08, 0x08, 0x18, 0x14, 0x24, 0x24,
0x42, 0x00, 0x00, 0x00,
0x00, 0x00, // 1222
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xFF,
0x00, 0x00, // 1235
- 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 1248
- 0x00, 0x00, 0x00, 0x38, 0x04, 0x04, 0x3C,
0x44, 0x44, 0x3E, 0x00,
0x00, 0x00, // 1261
- 0x40, 0x40, 0x40, 0x5C, 0x62, 0x42, 0x42,
0x42, 0x62, 0x5C, 0x00,
0x00, 0x00, // 1274
- 0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x40,
0x40, 0x20, 0x1E, 0x00,
0x00, 0x00, // 1287
- 0x02, 0x02, 0x02, 0x3A, 0x46, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x00,
0x00, 0x00, // 1300
- 0x00, 0x00, 0x00, 0x3C, 0x22, 0x42, 0x7E,
0x40, 0x40, 0x3E, 0x00,
0x00, 0x00, // 1313
- 0x1E, 0x20, 0x20, 0xFE, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x00,
0x00, 0x00, // 1326
- 0x00, 0x00, 0x00, 0x3A, 0x46, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x02,
0x02, 0x3C, // 1339
- 0x40, 0x40, 0x40, 0x5C, 0x62, 0x42, 0x42,
0x42, 0x42, 0x42, 0x00,
0x00, 0x00, // 1352
- 0x18, 0x18, 0x00, 0x78, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00,
0x00, 0x00, // 1365
- 0x18, 0x18, 0x00, 0x78, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08,
0x08, 0x70, // 1378
- 0x40, 0x40, 0x40, 0x44, 0x48, 0x50, 0x60,
0x50, 0x48, 0x44, 0x00,
0x00, 0x00, // 1391
- 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00,
0x00, 0x00, // 1404
- 0x00, 0x00, 0x00, 0xB6, 0xDA, 0x92, 0x92,
0x92, 0x92, 0x92, 0x00,
0x00, 0x00, // 1417
- 0x00, 0x00, 0x00, 0x5C, 0x62, 0x42, 0x42,
0x42, 0x42, 0x42, 0x00,
0x00, 0x00, // 1430
- 0x00, 0x00, 0x00, 0x3C, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 1443
- 0x00, 0x00, 0x00, 0x5C, 0x62, 0x42, 0x42,
0x42, 0x62, 0x5C, 0x40,
0x40, 0x40, // 1456
- 0x00, 0x00, 0x00, 0x3A, 0x46, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x02,
0x02, 0x02, // 1469
- 0x00, 0x00, 0x00, 0x5C, 0x64, 0x40, 0x40,
0x40, 0x40, 0x40, 0x00,
0x00, 0x00, // 1482
- 0x00, 0x00, 0x00, 0x3C, 0x40, 0x60, 0x18,
0x04, 0x04, 0x78, 0x00,
0x00, 0x00, // 1495
- 0x00, 0x00, 0x20, 0xFC, 0x20, 0x20, 0x20,
0x20, 0x20, 0x1C, 0x00,
0x00, 0x00, // 1508
- 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x00,
0x00, 0x00, // 1521
- 0x00, 0x00, 0x00, 0x82, 0x44, 0x44, 0x44,
0x28, 0x28, 0x10, 0x00,
0x00, 0x00, // 1534
- 0x00, 0x00, 0x00, 0x81, 0x91, 0x5A, 0x5A,
0x6A, 0x24, 0x24, 0x00,
0x00, 0x00, // 1547
- 0x00, 0x00, 0x00, 0x42, 0x24, 0x18, 0x18,
0x18, 0x24, 0x42, 0x00,
0x00, 0x00, // 1560
- 0x00, 0x00, 0x00, 0x81, 0x42, 0x42, 0x24,
0x24, 0x18, 0x18, 0x10,
0x30, 0xE0, // 1573
- 0x00, 0x00, 0x00, 0x7E, 0x02, 0x04, 0x08,
0x10, 0x20, 0x7E, 0x00,
0x00, 0x00, // 1586
- 0x1C, 0x10, 0x10, 0x10, 0x10, 0x60, 0x10,
0x10, 0x10, 0x10, 0x10,
0x0C, 0x00, // 1599
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10,
0x10, 0x00, // 1612
- 0x30, 0x08, 0x08, 0x08, 0x08, 0x06, 0x08,
0x08, 0x08, 0x08, 0x08,
0x30, 0x00, // 1625
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71,
0x8E, 0x00, 0x00, 0x00,
0x00, 0x00, // 1638
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24,
0x24, 0x24, 0x3C, 0x00,
0x00, 0x00, // 1651
- 0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x80,
0x80, 0x40, 0x3E, 0x04,
0x02, 0x06, // 1664
- 0x00, 0x24, 0x00, 0x42, 0x42, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x00,
0x00, 0x00, // 1677
- 0x08, 0x10, 0x00, 0x3C, 0x22, 0x42, 0x7E,
0x40, 0x40, 0x3E, 0x00,
0x00, 0x00, // 1690
- 0x18, 0x24, 0x00, 0x38, 0x04, 0x04, 0x3C,
0x44, 0x44, 0x3E, 0x00,
0x00, 0x00, // 1703
- 0x00, 0x24, 0x00, 0x38, 0x04, 0x04, 0x3C,
0x44, 0x44, 0x3E, 0x00,
0x00, 0x00, // 1716
- 0x10, 0x08, 0x00, 0x38, 0x04, 0x04, 0x3C,
0x44, 0x44, 0x3E, 0x00,
0x00, 0x00, // 1729
- 0x10, 0x28, 0x10, 0x38, 0x04, 0x04, 0x3C,
0x44, 0x44, 0x3E, 0x00,
0x00, 0x00, // 1742
- 0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x40,
0x40, 0x20, 0x1E, 0x08,
0x04, 0x0C, // 1755
- 0x18, 0x24, 0x00, 0x3C, 0x22, 0x42, 0x7E,
0x40, 0x40, 0x3E, 0x00,
0x00, 0x00, // 1768
- 0x00, 0x12, 0x00, 0x3C, 0x22, 0x42, 0x7E,
0x40, 0x40, 0x3E, 0x00,
0x00, 0x00, // 1781
- 0x10, 0x08, 0x00, 0x3C, 0x22, 0x42, 0x7E,
0x40, 0x40, 0x3E, 0x00,
0x00, 0x00, // 1794
- 0x00, 0x24, 0x00, 0x78, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00,
0x00, 0x00, // 1807
- 0x18, 0x24, 0x00, 0x78, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00,
0x00, 0x00, // 1820
- 0x10, 0x08, 0x00, 0x78, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00,
0x00, 0x00, // 1833
- 0x24, 0x00, 0x18, 0x18, 0x24, 0x24, 0x24,
0x7E, 0x42, 0x81, 0x00,
0x00, 0x00, // 1846
- 0x10, 0x28, 0x10, 0x28, 0x28, 0x24, 0x44,
0x7E, 0x42, 0x81, 0x00,
0x00, 0x00, // 1859
- 0x08, 0x10, 0x7E, 0x40, 0x40, 0x40, 0x7C,
0x40, 0x40, 0x7E, 0x00,
0x00, 0x00, // 1872
- 0x00, 0x00, 0x00, 0xFC, 0x12, 0x12, 0x7E,
0x90, 0x90, 0x6E, 0x00,
0x00, 0x00, // 1885
- 0x00, 0x00, 0x0F, 0x18, 0x18, 0x28, 0x2E,
0x78, 0x48, 0x8F, 0x00,
0x00, 0x00, // 1898
- 0x18, 0x24, 0x00, 0x3C, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 1911
- 0x00, 0x24, 0x00, 0x3C, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 1924
- 0x20, 0x10, 0x00, 0x3C, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 1937
- 0x18, 0x24, 0x00, 0x42, 0x42, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x00,
0x00, 0x00, // 1950
- 0x20, 0x10, 0x00, 0x42, 0x42, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x00,
0x00, 0x00, // 1963
- 0x00, 0x24, 0x00, 0x81, 0x42, 0x42, 0x24,
0x24, 0x18, 0x18, 0x10,
0x30, 0xE0, // 1976
- 0x24, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82,
0x82, 0x44, 0x38, 0x00,
0x00, 0x00, // 1989
- 0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 2002
- 0x00, 0x08, 0x1C, 0x28, 0x48, 0x48, 0x48,
0x68, 0x1C, 0x08, 0x00,
0x00, 0x00, // 2015
- 0x00, 0x0E, 0x10, 0x10, 0x10, 0x38, 0x10,
0x10, 0x20, 0x3E, 0x00,
0x00, 0x00, // 2028
- 0x00, 0x81, 0x42, 0x24, 0x18, 0x7C, 0x10,
0x7C, 0x10, 0x10, 0x00,
0x00, 0x00, // 2041
- 0x00, 0xE0, 0x90, 0x90, 0xE0, 0x96, 0xBC,
0x94, 0x92, 0x9E, 0x00,
0x00, 0x00, // 2054
- 0x0E, 0x10, 0x10, 0x3C, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10,
0x10, 0xE0, // 2067
- 0x08, 0x10, 0x00, 0x38, 0x04, 0x04, 0x3C,
0x44, 0x44, 0x3E, 0x00,
0x00, 0x00, // 2080
- 0x08, 0x10, 0x00, 0x78, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00,
0x00, 0x00, // 2093
- 0x08, 0x10, 0x00, 0x3C, 0x42, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 2106
- 0x08, 0x10, 0x00, 0x42, 0x42, 0x42, 0x42,
0x42, 0x46, 0x3A, 0x00,
0x00, 0x00, // 2119
- 0x14, 0x28, 0x00, 0x5C, 0x62, 0x42, 0x42,
0x42, 0x42, 0x42, 0x00,
0x00, 0x00, // 2132
- 0x14, 0x28, 0x42, 0x62, 0x52, 0x52, 0x4A,
0x4A, 0x46, 0x42, 0x00,
0x00, 0x00, // 2145
- 0x00, 0x78, 0x08, 0x38, 0x48, 0x7C, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2158
- 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2171
- 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08,
0x10, 0x20, 0x40, 0x42,
0x3E, 0x00, // 2184
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x40,
0x40, 0x00, 0x00, 0x00,
0x00, 0x00, // 2197
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x02,
0x02, 0x00, 0x00, 0x00,
0x00, 0x00, // 2210
- 0x00, 0xC4, 0x48, 0x48, 0x50, 0x37, 0x21,
0x43, 0x44, 0x87, 0x00,
0x00, 0x00, // 2223
- 0x00, 0xC4, 0x48, 0x48, 0x50, 0x22, 0x26,
0x4A, 0x4F, 0x82, 0x00,
0x00, 0x00, // 2236
- 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10,
0x10, 0x10, 0x10, 0x10,
0x10, 0x00, // 2249
- 0x00, 0x00, 0x00, 0x00, 0x12, 0x24, 0x48,
0x24, 0x12, 0x00, 0x00,
0x00, 0x00, // 2262
- 0x00, 0x00, 0x00, 0x00, 0x48, 0x24, 0x12,
0x24, 0x48, 0x00, 0x00,
0x00, 0x00, // 2275
- 0x94, 0x00, 0x00, 0x94, 0x00, 0x94, 0x00,
0x00, 0x94, 0x00, 0x94,
0x00, 0x00, // 2288
- 0x49, 0x94, 0x00, 0x49, 0x94, 0x49, 0x00,
0x94, 0x49, 0x94, 0x49,
0x00, 0x94, // 2301
- 0xFF, 0x94, 0x94, 0xFF, 0x94, 0xFF, 0x94,
0x94, 0xFF, 0x94, 0xFF,
0x94, 0x94, // 2314
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2327
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2340
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10,
0xF0, 0x10, 0x10, 0x10,
0x10, 0x10, // 2353
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2366
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2379
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10,
0xF0, 0x10, 0x10, 0x10,
0x10, 0x10, // 2392
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x04,
0xF4, 0x14, 0x14, 0x14,
0x14, 0x14, // 2405
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2418
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x04,
0xF4, 0x14, 0x14, 0x14,
0x14, 0x14, // 2431
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x04,
0xFC, 0x00, 0x00, 0x00,
0x00, 0x00, // 2444
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFC,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2457
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10,
0xF0, 0x00, 0x00, 0x00,
0x00, 0x00, // 2470
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2483
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2496
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2509
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2522
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2535
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2548
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2561
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10,
0x1F, 0x10, 0x10, 0x10,
0x10, 0x10, // 2574
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x17,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2587
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x10,
0x1F, 0x00, 0x00, 0x00,
0x00, 0x00, // 2600
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10,
0x17, 0x14, 0x14, 0x14,
0x14, 0x14, // 2613
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00,
0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, // 2626
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
0xF7, 0x14, 0x14, 0x14,
0x14, 0x14, // 2639
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x10,
0x17, 0x14, 0x14, 0x14,
0x14, 0x14, // 2652
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, // 2665
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00,
0xF7, 0x14, 0x14, 0x14,
0x14, 0x14, // 2678
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00,
0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, // 2691
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFF,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2704
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
0xFF, 0x10, 0x10, 0x10,
0x10, 0x10, // 2717
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2730
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x1F,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2743
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10,
0x1F, 0x00, 0x00, 0x00,
0x00, 0x00, // 2756
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10,
0x1F, 0x10, 0x10, 0x10,
0x10, 0x10, // 2769
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2782
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFF,
0x14, 0x14, 0x14, 0x14,
0x14, 0x14, // 2795
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10,
0xFF, 0x10, 0x10, 0x10,
0x10, 0x10, // 2808
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2821
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 2834
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, // 2847
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, // 2860
- 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
0xF0, 0xF0, 0xF0, 0xF0,
0xF0, 0xF0, // 2873
- 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
0x0F, 0x0F, 0x0F, 0x0F,
0x0F, 0x0F, // 2886
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 2899
- 0x00, 0x00, 0x00, 0x31, 0x49, 0x86, 0x84,
0x84, 0x8A, 0x71, 0x00,
0x00, 0x00, // 2912
- 0x38, 0x48, 0x48, 0x50, 0x50, 0x58, 0x44,
0x42, 0x42, 0x5C, 0x00,
0x00, 0x00, // 2925
- 0x00, 0x00, 0x3F, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x00,
0x00, 0x00, // 2938
- 0x00, 0x00, 0x00, 0x7F, 0x24, 0x24, 0x24,
0x24, 0x24, 0x24, 0x00,
0x00, 0x00, // 2951
- 0x00, 0x00, 0xFF, 0x40, 0x20, 0x10, 0x10,
0x20, 0x40, 0xFF, 0x00,
0x00, 0x00, // 2964
- 0x00, 0x00, 0x00, 0x7F, 0x84, 0x84, 0x84,
0x84, 0x84, 0x78, 0x00,
0x00, 0x00, // 2977
- 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42,
0x42, 0x66, 0x5A, 0x40,
0x40, 0x40, // 2990
- 0x00, 0x00, 0x00, 0xFE, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x00,
0x00, 0x00, // 3003
- 0x00, 0x00, 0x10, 0x7C, 0x92, 0x92, 0x92,
0x92, 0x7C, 0x10, 0x00,
0x00, 0x00, // 3016
- 0x00, 0x00, 0x38, 0x44, 0x82, 0xBA, 0x82,
0x82, 0x44, 0x38, 0x00,
0x00, 0x00, // 3029
- 0x00, 0x00, 0x7C, 0xC6, 0x82, 0x82, 0x82,
0x84, 0x44, 0xEE, 0x00,
0x00, 0x00, // 3042
- 0x38, 0x40, 0x60, 0x18, 0x24, 0x42, 0x42,
0x42, 0x42, 0x3C, 0x00,
0x00, 0x00, // 3055
- 0x00, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99,
0x99, 0x66, 0x00, 0x00,
0x00, 0x00, // 3068
- 0x10, 0x10, 0x10, 0x7C, 0x92, 0x91, 0x91,
0x91, 0x92, 0x7C, 0x10,
0x10, 0x10, // 3081
- 0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x7C,
0x40, 0x60, 0x1E, 0x00,
0x00, 0x00, // 3094
- 0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82,
0x82, 0x82, 0x82, 0x00,
0x00, 0x00, // 3107
- 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x7E,
0x00, 0x7E, 0x00, 0x00,
0x00, 0x00, // 3120
- 0x00, 0x00, 0x00, 0x10, 0x10, 0xFE, 0x10,
0x10, 0x00, 0xFE, 0x00,
0x00, 0x00, // 3133
- 0x00, 0x00, 0x40, 0x30, 0x08, 0x06, 0x08,
0x30, 0x40, 0x00, 0x7E,
0x00, 0x00, // 3146
- 0x00, 0x00, 0x02, 0x0C, 0x10, 0x60, 0x10,
0x0C, 0x02, 0x00, 0x7E,
0x00, 0x00, // 3159
- 0x0C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10,
0x10, 0x10, // 3172
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10,
0x10, 0x60, // 3185
- 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xFE,
0x00, 0x00, 0x10, 0x00,
0x00, 0x00, // 3198
- 0x00, 0x00, 0x00, 0x00, 0x72, 0x4E, 0x00,
0x72, 0x4E, 0x00, 0x00,
0x00, 0x00, // 3211
- 0x00, 0x10, 0x28, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 3224
- 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C,
0x18, 0x00, 0x00, 0x00,
0x00, 0x00, // 3237
- 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C,
0x18, 0x00, 0x00, 0x00,
0x00, 0x00, // 3250
- 0x01, 0x01, 0x02, 0x02, 0x02, 0x04, 0x04,
0xC4, 0x28, 0x28, 0x18,
0x10, 0x00, // 3263
- 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 3276
- 0x00, 0x3C, 0x04, 0x18, 0x3C, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, // 3289
- 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00,
0x00, 0x00, // 3302
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00 // 3315
> -};
--- branches/olpc/drivers/base/bootvid/bootvid.c
(original)
+++ branches/olpc/drivers/base/bootvid/bootvid.c Fri Jun 15 14:58:37
2007
@@ -1,475 +1,290 @@
-#include "precomp.h"
-
-/* PRIVATE FUNCTIONS
*********************************************************/
-
-BOOLEAN
-NTAPI
-VgaInterpretCmdStream(IN PUSHORT CmdStream)
-{
- PUCHAR Base = (PUCHAR)VgaRegisterBase;
- USHORT Cmd;
- UCHAR Major, Minor;
- USHORT Count;
- UCHAR Index;
- PUSHORT Buffer;
- PUSHORT ShortPort;
- PUCHAR Port;
- UCHAR Value;
- USHORT ShortValue;
-
- /* First make sure that we have a Command Stream */
- if (!CmdStream) return TRUE;
-
- /* Loop as long as we have commands */
- while (*CmdStream)
- {
- /* Get the Major and Minor Function */
- Cmd = *CmdStream;
- Major = Cmd & 0xF0;
- Minor = Cmd & 0x0F;
-
- /* Move to the next command */
- CmdStream++;
-
- /* Check which major function this was */
- if (Major == 0x10)
- {
- /* Now let's see the minor function */
- if (Minor & CMD_STREAM_READ)
- {
- /* Now check the sub-type */
- if (Minor & CMD_STREAM_USHORT)
- {
- /* The port is what is in the stream right now */
- ShortPort = UlongToPtr((ULONG)*CmdStream);
-
- /* Move to the next command */
- CmdStream++;
-
- /* Read USHORT from the port */
- READ_PORT_USHORT(PtrToUlong(Base) + ShortPort);
- }
- else
- {
- /* The port is what is in the stream right now */
- Port = UlongToPtr((ULONG)*CmdStream);
-
- /* Move to the next command */
- CmdStream++;
-
- /* Read UCHAR from the port */
- READ_PORT_UCHAR(PtrToUlong(Base) + Port);
- }
- }
- else if (Minor & CMD_STREAM_WRITE_ARRAY)
- {
- /* Now check the sub-type */
- if (Minor & CMD_STREAM_USHORT)
- {
- /* The port is what is in the stream right now */
- ShortPort = UlongToPtr(Cmd);
-
- /* Move to the next command and get the count */
- Count = *(CmdStream++);
-
- /* The buffer is what's next in the command stream
*/
- Buffer = CmdStream++;
-
- /* Write USHORT to the port */
- WRITE_PORT_BUFFER_USHORT(PtrToUshort(Base) +
ShortPort,
Buffer, Count);
-
- /* Move past the buffer in the command stream */
- CmdStream += Count;
- }
- else
- {
- /* The port is what is in the stream right now */
- Port = UlongToPtr(Cmd);
-
- /* Move to the next command and get the count */
- Count = *(CmdStream++);
-
- /* Add the base to the port */
- Port = PtrToUlong(Port) + Base;
-
- /* Move to next command */
- CmdStream++;
-
- /* Loop the cmd array */
- for (; Count; Count--, CmdStream++)
- {
- /* Get the byte we're writing */
- Value = (UCHAR)*CmdStream;
-
- /* Write UCHAR to the port */
- WRITE_PORT_UCHAR(Port, Value);
- }
- }
- }
- else if (Minor & CMD_STREAM_USHORT)
- {
- /* Get the ushort we're writing and advance in the
stream
*/
- ShortValue = *CmdStream;
- CmdStream++;
-
- /* Write USHORT to the port (which is in cmd) */
- WRITE_PORT_USHORT((PUSHORT)Base + Cmd, ShortValue);
- }
- else
- {
- /* The port is what is in the stream right now */
- Port = UlongToPtr((ULONG)*CmdStream);
-
- /* Get the uchar we're writing */
- Value = (UCHAR)*++CmdStream;
-
- /* Move to the next command */
- CmdStream++;
-
- /* Write UCHAR to the port (which is in cmd) */
- WRITE_PORT_UCHAR(PtrToUlong(Base) + Port, Value);
- }
- }
- else if (Major == 0x20)
- {
- /* Check the minor function. Note these are not flags
anymore. */
- switch (Minor)
- {
- case 0:
- /* The port is what is in the stream right now */
- ShortPort = UlongToPtr(*CmdStream);
-
- /* Move to the next command and get the count */
- Count = *(CmdStream++);
-
- /* Move to the next command and get the value to
write */
- ShortValue =
*(CmdStream++);
-
- /* Add the base to the port */
- ShortPort = PtrToUlong(ShortPort) + (PUSHORT)Base;
-
- /* Move to next command */
- CmdStream++;
-
- /* Make sure we have data */
- if (!ShortValue) continue;
-
- /* Loop the cmd array */
- for (; Count; Count--, CmdStream++, Value++)
- {
- /* Get the byte we're writing */
- ShortValue += (*CmdStream) << 8;
-
- /* Write USHORT to the port */
- WRITE_PORT_USHORT(ShortPort, ShortValue);
- }
- break;
- case 1:
- /* The port is what is in the stream right now. Add
the base
too */
- Port = *CmdStream + Base;
-
- /* Move to the next command and get the count */
- Count = *++CmdStream;
-
- /* Move to the next command and get the index to
write */
- Index =
(UCHAR)*++CmdStream;
-
- /* Move to next command */
- CmdStream++;
-
- /* Loop the cmd array */
- for (; Count; Count--, Index++)
- {
- /* Write the index */
- WRITE_PORT_UCHAR(Port, Index);
-
- /* Get the byte we're writing */
- Value = (UCHAR)*CmdStream;
-
- /* Move to next command */
- CmdStream++;
-
- /* Write UCHAR value to the port */
- WRITE_PORT_UCHAR(Port, Value);
- }
- break;
- case 2:
- /* The port is what is in the stream right now. Add
the base
too */
- Port = *CmdStream + Base;
-
- /* Read the current value and add the stream data
*/
- Value = READ_PORT_UCHAR(Port);
- Value &= *CmdStream++;
- Value ^= *CmdStream++;
-
- /* Write the value */
- WRITE_PORT_UCHAR(Port, Value);
- break;
- default:
- /* Unknown command, fail */
- return FALSE;
- }
- }
- else if (Major != 0xF0)
- {
- /* Unknown major function, fail */
- return FALSE;
- }
-
- /* Get the next command */
- Cmd = *CmdStream;
- }
-
- /* If we got here, return success */
- return TRUE;
-}
-
-BOOLEAN
-NTAPI
-VgaIsPresent(VOID)
-{
- UCHAR VgaReg, VgaReg2, VgaReg3;
- UCHAR SeqReg, SeqReg2;
- UCHAR i;
-
- /* Read the VGA Address Register */
- VgaReg = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE);
-
- /* Select Read Map Select Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-
- /* Read it back...it should be 4 */
- if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE)) & 0xF) !=
4)
return FALSE;
-
- /* Read the VGA Data Register */
- VgaReg2 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF);
-
- /* Enable all planes */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 3);
-
- /* Read it back...it should be 3 */
- if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != 0x3)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- return FALSE;
- }
-
- /* Select Bit Mask Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-
- /* Read it back...it should be 8 */
- if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE)) & 0xF) !=
8)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- return FALSE;
- }
-
- /* Read the VGA Data Register */
- VgaReg3 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF);
-
- /* Loop bitmasks */
- for (i = 0xBB; i; i >>= 1)
- {
- /* Set bitmask */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, i);
-
- /* Read it back...it should be the same */
- if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != i)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0xFF);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- return FALSE;
- }
- }
-
- /* Select Read Map Select Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-
- /* Read it back...it should be 3 */
- if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != 3)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0xFF);
- return FALSE;
- }
-
- /* Write the registers we read earlier */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, VgaReg);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, VgaReg2);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, VgaReg3);
-
- /* Read sequencer address */
- SeqReg = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4);
-
- /* Select memory mode register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4, 4);
-
- /* Read it back...it should still be 4 */
- if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4)) & 7) != 4)
- {
- /* Fail */
- return FALSE;
- }
-
- /* Read sequencer Data */
- SeqReg2 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5);
-
- /* Write null plane */
- WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x100);
-
- /* Write sequencer flag */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, SeqReg2 ^ 8);
-
- /* Read it back */
- if ((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5)) != (SeqReg2
^
8))
- {
- /* Not the same value...restore registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, 2);
- WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x300);
- return FALSE;
- }
-
- /* Now write the registers we read */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, SeqReg2);
- WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x300);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4, SeqReg);
-
- /* VGA is present! */
- return TRUE;
-}
-
-/* PUBLIC FUNCTIONS
**********************************************************/
-
/*
- * @implemented
+ * ReactOS Boot video driver
+ *
+ * Copyright (C) 2003 Casper S. Hornstroup
+ * Copyright (C) 2004, 2005 Filip Navara
+ *
+ * This program 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 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307,
USA.
+ *
+ * $Id$
*/
-BOOLEAN
-NTAPI
-VidInitialize(IN BOOLEAN SetMode)
-{
- ULONG Context = 0;
- PHYSICAL_ADDRESS TranslatedAddress;
- PHYSICAL_ADDRESS NullAddress = {{0}};
- ULONG AddressSpace = 1;
- BOOLEAN Result;
- ULONG_PTR Base;
-
- /* Make sure that we have a bus translation function */
- if (!HalFindBusAddressTranslation) return FALSE;
-
- /* Get the VGA Register address */
- Result = HalFindBusAddressTranslation(NullAddress,
- &AddressSpace,
- &TranslatedAddress,
- &Context,
- TRUE);
- if (!Result) return FALSE;
-
- /* See if this is I/O Space, which we need to map */
-TryAgain:
- if (!AddressSpace)
- {
- /* Map it */
- Base = (ULONG_PTR)MmMapIoSpace(TranslatedAddress, 0x400,
MmNonCached);
- }
- else
- {
- /* The base is the translated address, no need to map I/O space
*/
- Base = TranslatedAddress.LowPart;
- }
-
- /* Set the VGA Register base and now check if we have a VGA device
*/
- VgaRegisterBase = Base;
- if (VgaIsPresent())
- {
- /* Translate the VGA Memory Address */
- NullAddress.LowPart = 0xA0000;
- AddressSpace = 0;
- Result = HalFindBusAddressTranslation(NullAddress,
- &AddressSpace,
- &TranslatedAddress,
- &Context,
- FALSE);
- if (Result)
- {
- /* Success! See if this is I/O Space, which we need to map
*/
- if (!AddressSpace)
- {
- /* Map it */
- Base = (ULONG_PTR)MmMapIoSpace(TranslatedAddress,
- 0x20000,
- MmNonCached);
- }
- else
- {
- /* The base is the translated address, no need to map
I/O
space */
- Base =
TranslatedAddress.LowPart;
- }
-
- /* Set the VGA Memory Base */
- VgaBase = Base;
-
- /* Now check if we have to set the mode */
- if (SetMode)
- {
- //
- // Reset the display
- //
- //HalResetDisplay();
- curr_x = 0;
- curr_y = 0;
-
- /* Initialize it */
- VgaInterpretCmdStream(AT_Initialization);
- return TRUE;
- }
- }
- }
- else
- {
- /* It's not, so unmap the I/O space if we mapped it */
- if (!AddressSpace) MmUnmapIoSpace((PVOID)VgaRegisterBase,
0x400);
- }
-
- /* If we got here, then we failed...let's try again */
- Result = HalFindBusAddressTranslation(NullAddress,
- &AddressSpace,
- &TranslatedAddress,
- &Context,
- TRUE);
- if (Result) goto TryAgain;
-
- /* If we got here, then we failed even past our re-try... */
- return FALSE;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidResetDisplay(IN BOOLEAN HalReset)
-{
- /* Clear the current position */
- curr_x = 0;
- curr_y = 0;
-
- /* Clear the screen with HAL if we were asked to */
- //if (HalReset) HalResetDisplay();
-
- /* Re-initialize the VGA Display */
- VgaInterpretCmdStream(AT_Initialization);
-
- /* Re-initialize the palette and fill the screen black */
- InitializePalette();
- VidSolidColorFill(0, 0, 639, 479, 0);
-}
-
+
+/* INCLUDES
******************************************************************/
> +
> +#include "bootvid.h"
> +#include "resource.h"
> +
> +#define NDEBUG
> +#include <debug.h +
+static volatile LONG ShutdownNotify;
+static KEVENT ShutdownCompleteEvent;
+
+/* DATA
**********************************************************************/
+
+static RGBQUAD _MainPalette[16];
+static UCHAR _Square1[9 * 4];
+static UCHAR _Square2[9 * 4];
+static UCHAR _Square3[9 * 4];
+
+/* FUNCTIONS
*****************************************************************/
+
+static VOID NTAPI
+BootVidAnimationThread(PVOID Ignored)
+{
+ UCHAR PaletteBitmapBuffer[sizeof(BITMAPINFOHEADER) +
sizeof(_MainPalette)];
+ PBITMAPINFOHEADER PaletteBitmap =
(PBITMAPINFOHEADER)PaletteBitmapBuffer;
+ LPRGBQUAD Palette =
(LPRGBQUAD)(PaletteBitmapBuffer +
sizeof(BITMAPINFOHEADER));
+ ULONG Iteration, Index, ClrUsed;
+ UINT AnimBarPos;
+ LARGE_INTEGER Interval;
+
+ /*
+ * Build a bitmap containing the fade in palette. The palette
entries
+ * are then processed in a loop and set using VidBitBlt function.
+ */
+
+ ClrUsed = sizeof(_MainPalette) / sizeof(_MainPalette[0]);
+ RtlZeroMemory(PaletteBitmap, sizeof(BITMAPINFOHEADER));
+ PaletteBitmap->biSize = sizeof(BITMAPINFOHEADER);
+ PaletteBitmap->biBitCount = 4;
+ PaletteBitmap->biClrUsed = ClrUsed;
+
+ /*
+ * Main animation loop.
+ */
+
+ for (Iteration = 0, AnimBarPos = 0; !ShutdownNotify; Iteration++)
+ {
+ if (Iteration <= PALETTE_FADE_STEPS)
+ {
+ for (Index = 0; Index < ClrUsed; Index++)
+ {
+ Palette[Index].rgbRed =
+ _MainPalette[Index].rgbRed * Iteration /
PALETTE_FADE_STEPS;
+ Palette[Index].rgbGreen =
+ _MainPalette[Index].rgbGreen * Iteration /
PALETTE_FADE_STEPS;
+ Palette[Index].rgbBlue =
+ _MainPalette[Index].rgbBlue * Iteration /
PALETTE_FADE_STEPS;
+ }
+
+ VidBitBlt(PaletteBitmapBuffer, 0, 0);
+ }
+#ifdef USE_PROGRESS_BAR
+ else
+ {
+ break;
+ }
+
+ Interval.QuadPart = -PALETTE_FADE_TIME;
+#else
+
+#if 0
+ if (AnimBarPos == 0)
+ {
+ VidSolidColorFill(0x173, 354, 0x178, 354 + 9, 0);
+ }
+ else if (AnimBarPos > 3)
+ {
+ VidSolidColorFill(0xe3 + AnimBarPos * 8, 354,
+ 0xe8 + AnimBarPos * 8, 354 + 9,
+ 0);
+ }
+
+ if (AnimBarPos >= 3)
+ {
+ VidBufferToScreenBlt(_Square1, 0xeb + AnimBarPos * 8, 354, 6,
9,
4);
+ }
+ if (AnimBarPos >= 2 && AnimBarPos <= 16)
+ {
+ VidBufferToScreenBlt(_Square2, 0xf3 + AnimBarPos * 8, 354, 6,
9,
4);
+ }
+ if (AnimBarPos >= 1 && AnimBarPos <= 15)
+ {
+ VidBufferToScreenBlt(_Square3, 0xfb + AnimBarPos * 8, 354, 6,
9,
4);
+ }
+#endif
+
+ if (Iteration <= PALETTE_FADE_STEPS)
+ {
+ Interval.QuadPart = -PALETTE_FADE_TIME;
+ if ((Iteration % 5) == 0)
+ AnimBarPos++;
+ }
+ else
+ {
+ Interval.QuadPart = -PALETTE_FADE_TIME * 5;
+ AnimBarPos++;
+ }
+ AnimBarPos = Iteration % 18;
+#endif
+
+ /* Wait for a bit. */
+ KeDelayExecutionThread(KernelMode, FALSE, &Interval);
+ }
+
+ DPRINT("Finishing bootvid thread.\n");
+ KeSetEvent(&ShutdownCompleteEvent, 0, FALSE);
+
+ PsTerminateSystemThread(0);
+}
+
+
+NTSTATUS NTAPI
+BootVidDisplayBootLogo(PVOID ImageBase)
+{
+ PBITMAPINFOHEADER BitmapInfoHeader;
+ LPRGBQUAD Palette;
+ static const ULONG BitmapIds[2] = {IDB_BOOTIMAGE, IDB_BAR};
+ PUCHAR BitmapData[2];
+ ULONG Index;
+ HANDLE BitmapThreadHandle;
+ CLIENT_ID BitmapThreadId;
+ NTSTATUS Status;
+
+ KeInitializeEvent(&ShutdownCompleteEvent, NotificationEvent, FALSE);
+
+ /*
+ * Get the bitmaps from the executable.
+ */
+
+ for (Index = 0; Index < sizeof(BitmapIds) / sizeof(BitmapIds[0]);
Index++)
+ {
+ PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
+ LDR_RESOURCE_INFO ResourceInfo;
+ ULONG Size;
+
+ ResourceInfo.Type = /* RT_BITMAP */ 2;
+ ResourceInfo.Name = BitmapIds[Index];
+ ResourceInfo.Language = 0x09;
+
+ Status = LdrFindResource_U(
+ ImageBase,
+ &ResourceInfo,
+ RESOURCE_DATA_LEVEL,
+ &ResourceDataEntry);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("LdrFindResource_U() failed with status 0x%.08x\n",
Status);
+ return Status;
+ }
+
+ Status = LdrAccessResource(
+ ImageBase,
+ ResourceDataEntry,
+ (PVOID*)&BitmapData[Index],
+ &Size);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("LdrAccessResource() failed with status 0x%.08x\n",
Status);
+ return Status;
+ }
+ }
+
+
+ /*
+ * Initialize the graphics output.
+ */
+
+ if (!VidInitialize(TRUE))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /*
+ * Load the bar bitmap and get the square data from it.
+ */
+
+ VidBitBlt(BitmapData[1], 0, 0);
+ VidScreenToBufferBlt(_Square1, 0, 0, 6, 9, 4);
+ VidScreenToBufferBlt(_Square2, 8, 0, 6, 9, 4);
+ VidScreenToBufferBlt(_Square3, 16, 0, 6, 9, 4);
+
+ /*
+ * Save the main image palette and replace it with black palette, so
+ * we can do fade in effect later.
+ */
+
+ BitmapInfoHeader = (PBITMAPINFOHEADER)BitmapData[0];
+ Palette = (LPRGBQUAD)(BitmapData[0] + BitmapInfoHeader->biSize);
+ RtlCopyMemory(_MainPalette, Palette, sizeof(_MainPalette));
+ RtlZeroMemory(Palette, sizeof(_MainPalette));
+
+ /*
+ * Display the main image.
+ */
+
+ VidBitBlt(BitmapData[0], 0, 0);
+
+ /*
+ * Start a thread that handles the fade in and bar animation
effects.
+ */
+
+ Status = PsCreateSystemThread(
+ &BitmapThreadHandle,
+ THREAD_ALL_ACCESS,
+ NULL,
+ NULL,
+ &BitmapThreadId,
+ BootVidAnimationThread,
+ NULL);
+
+ if (!NT_SUCCESS(Status))
+ {
+ VidCleanUp();
+ return Status;
+ }
+
+ ZwClose(BitmapThreadHandle);
+
+ return STATUS_SUCCESS;
+}
+
+
+VOID NTAPI
+BootVidUpdateProgress(ULONG Progress)
+{
+#ifdef USE_PROGRESS_BAR
+ if (ShutdownNotify == 0)
+ {
+ VidSolidColorFill(0x103, 354, 0x103 + (Progress * 120 / 100), 354
+
9, 1);
> + }
> +#endif
> +}
> +
> +
> +VOID NTAPI
> +BootVidFinalizeBootLogo(VOID)
> +{
> + InterlockedIncrement(&ShutdownNotify);
> + DPRINT1("Waiting for bootvid thread to finish.\n");
> + KeWaitForSingleObject(&ShutdownCompleteEvent, Executive, KernelMode,
> + FALSE, NULL);
> + DPRINT1("Bootvid thread to finish.\n");
> + //VidResetDisplay();
> +}
> +
> +
> +NTSTATUS STDCALL
> +DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
> +{
> + return STATUS_SUCCESS;
> +}
---
branches/olpc/drivers/base/bootvid/bootvid.def (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.def Fri Jun 15 14:58:37
2007
> @@ -1,15 +1,14 @@
> -LIBRARY BOOTVID.DLL
> +LIBRARY bootvid.sys
---
branches/olpc/drivers/base/bootvid/bootvid.rbuild (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.rbuild Fri Jun 15
14:58:37
2007
> @@ -2,11 +2,13 @@
> <importlibrary definition="bootvid.def"></importlibrary --- branches/olpc/drivers/base/bootvid/vga.c
(original)
+++ branches/olpc/drivers/base/bootvid/vga.c (removed)
@@ -1,1274 +1,0 @@
-#include "precomp.h"
-
-/* GLOBALS
*******************************************************************/
-
-ULONG ScrollRegion[4] =
-{
- 0,
- 0,
- 640 - 1,
- 480 - 1
-};
-UCHAR lMaskTable[8] =
-{
- (1 << 8) - (1 << 0),
- (1 << 7) - (1 << 0),
- (1 << 6) - (1 << 0),
- (1 << 5) - (1 << 0),
- (1 << 4) - (1 << 0),
- (1 << 3) - (1 << 0),
- (1 << 2) - (1 << 0),
- (1 << 1) - (1 << 0)
-};
-UCHAR rMaskTable[8] =
-{
- (1 << 7),
- (1 << 7)+ (1 << 6),
- (1 << 7)+ (1 << 6) + (1 << 5),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) +
(1 << 2),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) +
(1 << 2) + (1
<< 1),
- (1 << 7)+ (1 << 6) + (1 <<
5) + (1 << 4) + (1 << 3) + (1 << 2) + (1
<< 1) +
- (1 << 0),
-};
-UCHAR PixelMask[8] =
-{
- (1 << 7),
- (1 << 6),
- (1 << 5),
- (1 << 4),
- (1 << 3),
- (1 << 2),
- (1 << 1),
- (1 << 0),
-};
-ULONG lookup[16] =
-{
- 0x0000,
- 0x0100,
- 0x1000,
- 0x1100,
- 0x0001,
- 0x0101,
- 0x1001,
- 0x1101,
- 0x0010,
- 0x0110,
- 0x1010,
- 0x1110,
- 0x0011,
- 0x0111,
- 0x1011,
- 0x1111,
-};
-
-ULONG TextColor = 0xF;
-ULONG curr_x = 0;
-ULONG curr_y = 0;
-BOOLEAN NextLine = FALSE;
-ULONG_PTR VgaRegisterBase = 0;
-ULONG_PTR VgaBase = 0;
-
-/* PRIVATE FUNCTIONS
*********************************************************/
-
-VOID
-NTAPI
-ReadWriteMode(UCHAR Mode)
-{
- UCHAR Value;
-
- /* Switch to graphics mode register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 5);
-
- /* Get the current register value, minus the current mode */
- Value = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) & 0xF4;
-
- /* Set the new mode */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, Mode | Value);
-}
-
-VOID
-NTAPI
-__outpb(IN ULONG Port,
- IN ULONG Value)
-{
- /* Write to the VGA Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + Port, (UCHAR)Value);
-}
-
-VOID
-NTAPI
-__outpw(IN ULONG Port,
- IN ULONG Value)
-{
- /* Write to the VGA Register */
- WRITE_PORT_USHORT((PUSHORT)(VgaRegisterBase + Port),
(USHORT)Value);
-}
-
-VOID
-NTAPI
-SetPixel(IN ULONG Left,
- IN ULONG Top,
- IN UCHAR Color)
-{
- PUCHAR PixelPosition;
-
- /* Calculate the pixel position. */
- PixelPosition = (PUCHAR)VgaBase + (Left >> 3) + (Top * 80);
-
- /* Switch to mode 10 */
- ReadWriteMode(10);
-
- /* Clear the 4 planes (we're already in unchained mode here) */
- __outpw(0x3C4, 0xF02);
-
- /* Select the color don't care register */
- __outpw(0x3CE, 7);
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (PixelMask[Left & 7] << 8) | 8);
-
- /* Read the current pixel value and add our color */
- WRITE_REGISTER_UCHAR(PixelPosition,
- READ_REGISTER_UCHAR(PixelPosition) & Color);
-}
-
-VOID
-NTAPI
-DisplayCharacter(CHAR Character,
- ULONG Left,
- ULONG Top,
- ULONG TextColor,
- ULONG BackTextColor)
-{
- PUCHAR FontChar;
- ULONG i, j, XOffset;
-
- /* Get the font line for this character */
- FontChar = &FontData[Character * 13 - Top];
-
- /* Loop each pixel height */
- i = 13;
- do
- {
- /* Loop each pixel width */
- j = 128;
- XOffset = Left;
- do
- {
- /* Check if we should draw this pixel */
- if (FontChar[Top] & (UCHAR)j)
- {
- /* We do, use the given Text Color */
- SetPixel(XOffset, Top, (UCHAR)TextColor);
- }
- else if (BackTextColor < 16)
- {
- /* This is a background pixel. We're drawing it unless
it's */
> - /* transparent. */
> - SetPixel(XOffset, Top, (UCHAR)BackTextColor);
> - }
> -
> - /* Increase X Offset */
> - XOffset++;
> - } while (j >>= 1);
> -
> - /* Move to the next Y ordinate */
> - Top++;
> - } while (--i);
> -}
> -
> -VOID
> -NTAPI
> -DisplayStringXY(PUCHAR String,
> - ULONG Left,
> - ULONG Top,
> - ULONG TextColor,
> - ULONG BackColor)
> -{
> - /* Loop every character */
> - while (*String)
> - {
> - /* Display a character */
> - DisplayCharacter(*String, Left, Top, TextColor, BackColor);
> -
> - /* Move to next character and next position */
> - String++;
> - Left += 8;
> - }
> -}
> -
> -VOID
> -NTAPI
> -SetPaletteEntryRGB(IN ULONG Id,
> - IN ULONG Rgb)
> -{
> - PCHAR Colors = (PCHAR)&Rgb;
> -
> - /* Set the palette index */
> - __outpb(0x3C8, (UCHAR)Id);
> -
> - /* Set RGB colors */
> - __outpb(0x3C9, Colors[2] >> 2);
> - __outpb(0x3C9, Colors[1] >> 2);
> - __outpb(0x3C9, Colors[0] >> 2);
> -}
> -
> -VOID
> -NTAPI
> -InitPaletteWithTable(IN PULONG Table,
> - IN ULONG Count)
> -{
> - ULONG i;
> - PULONG Entry = Table;
> -
> - /* Loop every entry */
> - for (i = 0; i < Count; i++, Entry++)
> - {
> - /* Set the entry */
> - SetPaletteEntryRGB(i, *Entry);
> - }
> -}
> -
> -VOID
> -NTAPI
> -SetPaletteEntry(IN ULONG Id,
> - IN ULONG PaletteEntry)
> -{
> - /* Set the palette index */
> - __outpb(0x3C8, (UCHAR)Id);
> -
> - /* Set RGB colors */
> - __outpb(0x3C9, PaletteEntry & 0xFF);
> - __outpb(0x3C9, (PaletteEntry >>= 8) & 0xFF);
> - __outpb(0x3C9, (PaletteEntry >> 8) & 0xFF);
> -}
> -
> -VOID
> -NTAPI
> -InitializePalette(VOID)
> -{
> - ULONG PaletteEntry[16] = {0,
> - 0x20,
> - 0x2000,
> - 0x2020,
> - 0x200000,
> - 0x200020,
> - 0x202000,
> - 0x202020,
> - 0x303030,
> - 0x3F,
> - 0x3F00,
> - 0x3F3F,
> - 0x3F0000,
> - 0x3F003F,
> - 0x3F3F00,
> - 0x3F3F3F};
> - ULONG i;
> -
> - /* Loop all the entries and set their palettes */
> - for (i = 0; i < 16; i++) SetPaletteEntry(i, PaletteEntry[i]);
> -}
> -
> -VOID
> -NTAPI
> -VgaScroll(ULONG Scroll)
> -{
> - ULONG Top;
> - ULONG SourceOffset, DestOffset;
> - ULONG Offset;
> - ULONG i, j;
> -
> - /* Set memory positions of the scroll */
> - SourceOffset = VgaBase + (ScrollRegion[1] * 80) + (ScrollRegion[0]
> > - DestOffset = SourceOffset + (Scroll * 80);
-
- /* Clear the 4 planes */
- __outpw(0x3C4, 0xF02);
-
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Set Mode 1 */
- ReadWriteMode(1);
-
- /* Save top and check if it's above the bottom */
- Top = ScrollRegion[1];
- if (Top > ScrollRegion[3]) return;
-
- /* Start loop */
- do
- {
- /* Set number of bytes to loop and start offset */
- Offset = ScrollRegion[0] >> 3;
- j = SourceOffset;
-
- /* Check if this is part of the scroll region */
- if (Offset <= (ScrollRegion[2] >> 3))
- {
- /* Update position */
- i = DestOffset - SourceOffset;
-
- /* Loop the X axis */
- do
- {
- /* Write value in the new position so that we can do
the
scroll */
- WRITE_REGISTER_UCHAR((PUCHAR)j,
- READ_REGISTER_UCHAR((PUCHAR)j +
i));
-
- /* Move to the next memory location to write to */
- j++;
-
- /* Move to the next byte in the region */
- Offset++;
-
- /* Make sure we don't go past the scroll region */
- } while (Offset <= (ScrollRegion[2] >> 3));
- }
-
- /* Move to the next line */
- SourceOffset += 80;
- DestOffset += 80;
-
- /* Increase top */
- Top++;
-
- /* Make sure we don't go past the scroll region */
- } while (Top <= ScrollRegion[3]);
-}
-
-VOID
-NTAPI
-PreserveRow(IN ULONG CurrentTop,
- IN ULONG TopDelta,
- IN BOOLEAN Direction)
-{
- PUCHAR Position1, Position2;
- ULONG Count;
-
- /* Clear the 4 planes */
- __outpw(0x3C4, 0xF02);
-
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Set Mode 1 */
- ReadWriteMode(1);
-
- /* Check which way we're preserving */
- if (Direction)
- {
- /* Calculate the position in memory for the row */
- Position1 = (PUCHAR)VgaBase + CurrentTop * 80;
- Position2 = (PUCHAR)VgaBase + 0x9600;
- }
- else
- {
- /* Calculate the position in memory for the row */
- Position1 = (PUCHAR)VgaBase + 0x9600;
- Position2 = (PUCHAR)VgaBase + CurrentTop * 80;
- }
-
- /* Set the count and make sure it's above 0 */
- Count = TopDelta * 80;
- if (Count)
- {
- /* Loop every pixel */
- do
- {
- /* Write the data back on the other position */
- WRITE_REGISTER_UCHAR(Position1,
READ_REGISTER_UCHAR(Position2));
-
- /* Increase both positions */
- Position2++;
- Position1++;
- } while (--Count);
- }
-}
-
-VOID
-NTAPI
-BitBlt(IN ULONG Left,
- IN ULONG Top,
- IN ULONG Width,
- IN ULONG Height,
- IN PUCHAR Buffer,
- IN ULONG BitsPerPixel,
- IN ULONG Delta)
-{
- ULONG LeftAnd, LeftShifted, LeftPlusOne, LeftPos;
- ULONG lMask, rMask;
- UCHAR NotlMask;
- ULONG Distance;
- ULONG DistanceMinusLeftBpp;
- ULONG SomeYesNoFlag, SomeYesNoFlag2;
- PUCHAR PixelPosition, m;
- PUCHAR i, k;
- ULONG j;
- ULONG x;
- ULONG Plane;
- UCHAR LeftArray[84];
- PUCHAR CurrentLeft;
- PUCHAR l;
- ULONG LoopCount;
- UCHAR pMask, PlaneShift;
- BOOLEAN Odd;
- UCHAR Value;
-
- /* Check if the buffer isn't 4bpp */
- if (BitsPerPixel != 4)
- {
- /* FIXME: TODO */
- DbgPrint("Unhandled BitBlt\n"
- "%lxx%lx @ (%lx,%lx)\n"
- "Bits Per Pixel %lx\n"
- "Buffer: %p. Delta: %lx\n",
- Width,
- Height,
- Left,
- Top,
- BitsPerPixel,
- Buffer,
- Delta);
- return;
- }
-
- /* Get the masks and other values */
- LeftAnd = Left & 0x7;
- lMask = lMaskTable[LeftAnd];
- Distance = Width + Left;
- rMask = rMaskTable[(Distance - 1) & 0x7];
- Left >>= 3;
-
- /* Set some values */
- SomeYesNoFlag = FALSE;
- SomeYesNoFlag2 = FALSE;
- Distance = (Distance - 1) >> 3;
- DistanceMinusLeftBpp = Distance - Left;
-
- /* Check if the distance is equal to the left position and add the
masks */
- if (Left == Distance) lMask += rMask;
-
- /* Check if there's no distance offset */
- if (DistanceMinusLeftBpp)
- {
- /* Set the first flag on */
- SomeYesNoFlag = TRUE;
-
- /* Decrease offset and check if we still have one */
- if (--DistanceMinusLeftBpp)
- {
- /* Still have a distance offset */
- SomeYesNoFlag2 = TRUE;
- }
- }
-
- /* Calculate initial pixel position */
- PixelPosition = (PUCHAR)VgaBase + (Top * 80) + Left;
-
- /* Set loop buffer variable */
- i = Buffer;
-
- /* Switch to mode 0 */
- ReadWriteMode(0);
-
- /* Leave now if the height is 0 */
- if (Height <= 0) return;
-
- /* Set more weird values */
- CurrentLeft = &LeftArray[Left];
- NotlMask = ~(UCHAR)lMask;
- LeftPlusOne = Left + 1;
- LeftShifted = (lMask << 8) | 8;
- j = Height;
-
- /* Start the height loop */
- do
- {
- /* Start the plane loop */
- Plane = 0;
- do
- {
- /* Clear the current value */
- *CurrentLeft = 0;
- LoopCount = 0;
-
- /* Set the buffer loop variable for this loop */
- k = i;
-
- /* Calculate plane shift and pixel mask */
- PlaneShift = 1 << Plane;
- pMask = PixelMask[LeftAnd];
-
- /* Check if we have a width */
- if (Width > 0)
- {
- /* Loop it */
- l = CurrentLeft;
- x = Width;
- do
- {
- /* Check if we're odd and increase the loop count
*/
- Odd = LoopCount & 1 ? TRUE : FALSE;
- LoopCount++;
- if (Odd)
- {
- /* Check for the plane shift */
- if (*k & PlaneShift)
- {
- /* Write the pixel mask */
- *l |= pMask;
- }
-
- /* Increase buffer position */
- k++;
- }
- else
- {
- /* Check for plane shift */
- if ((*k >> 4) & PlaneShift)
- {
- /* Write the pixel mask */
- *l |= pMask;
- }
- }
-
- /* Shift the pixel mask */
- pMask >>= 1;
- if (!pMask)
- {
- /* Move to the next current left position and
clear it
*/
- l++;
- *l = 0;
-
- /* Set the pixel mask to 0x80 */
- pMask = 0x80;
- }
- } while (--x);
- }
-
- /* Set the plane value */
- __outpw(0x3C4, (1 << (Plane + 8) | 2));
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (USHORT)LeftShifted);
-
- /* Read the current Pixel value */
- Value = READ_REGISTER_UCHAR(PixelPosition);
-
- /* Add our mask */
- Value = (Value & NotlMask) | *CurrentLeft;
-
- /* Set current left for the loop, and write new pixel value
*/
- LeftPos = LeftPlusOne;
- WRITE_REGISTER_UCHAR(PixelPosition, Value);
-
- /* Set loop pixel position and check if we should loop */
- m = PixelPosition + 1;
- if (SomeYesNoFlag2)
- {
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Check if we have any distance left */
- if (DistanceMinusLeftBpp > 0)
- {
- /* Start looping it */
- x = DistanceMinusLeftBpp;
- do
- {
- /* Write the value */
- WRITE_REGISTER_UCHAR(m, LeftArray[LeftPos]);
-
- /* Go to the next position */
- m++;
- LeftPos++;
- } while (--x);
- }
- }
-
- /* Check if the first flag is on */
- if (SomeYesNoFlag)
- {
- /* Set the mask value */
- __outpw(0x3CE, (rMask << 8) | 8);
-
- /* Read the current Pixel value */
- Value = READ_REGISTER_UCHAR(m);
-
- /* Add our mask */
- Value = (Value & ~(UCHAR)rMask) | LeftArray[LeftPos];
-
- /* Set current left for the loop, and write new pixel
value */
- WRITE_REGISTER_UCHAR(m, Value);
- }
- } while (++Plane < 4);
-
- /* Update pixel position, buffer and height */
- PixelPosition += 80;
- i += Delta;
- } while (--j);
-}
-
-VOID
-NTAPI
-RleBitBlt(IN ULONG Left,
- IN ULONG Top,
- IN ULONG Width,
- IN ULONG Height,
- IN PUCHAR Buffer)
-{
- ULONG YDelta;
- ULONG x;
- ULONG RleValue, NewRleValue;
- ULONG Color, Color2;
- ULONG i, j;
- ULONG Code;
-
- /* Set Y height and current X value and start loop */
- YDelta = Top + Height - 1;
- x = Left;
- for (;;)
- {
- /* Get the current value and advance in the buffer */
- RleValue = *Buffer;
- Buffer++;
- if (RleValue)
- {
- /* Check if we've gone past the edge */
- if ((x + RleValue) > (Width + Left))
- {
- /* Fixeup the pixel value */
- RleValue = Left - x + Width;
- }
-
- /* Get the new value */
- NewRleValue = *Buffer;
-
- /* Get the two colors */
- Color = NewRleValue >> 4;
- Color2 = NewRleValue & 0xF;
-
- /* Increase buffer positition */
- Buffer++;
-
- /* Check if we need to do a fill */
- if (Color == Color2)
- {
- /* Do a fill and continue the loop */
- RleValue += x;
- VidSolidColorFill(x, YDelta, RleValue - 1, YDelta,
(UCHAR)Color);
- x = RleValue;
- continue;
- }
-
- /* Check if the pixel value is 1 or below */
- if (RleValue > 1)
- {
- /* Set loop variables */
- i = (RleValue - 2) / 2 + 1;
- do
- {
- /* Set the pixels */
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- SetPixel(x, YDelta, (UCHAR)Color2);
- x++;
-
- /* Decrease pixel value */
- RleValue -= 2;
- } while (--i);
- }
-
- /* Check if there is any value at all */
- if (RleValue)
- {
- /* Set the pixel and increase posititon */
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- }
-
- /* Start over */
- continue;
- }
-
- /* Get the current pixel value */
- RleValue = *Buffer;
- Code = RleValue;
- switch (Code)
- {
- /* Case 0 */
- case 0:
-
- /* Set new x value, decrease distance and restart */
- x = Left;
- YDelta--;
- Buffer++;
- continue;
-
- /* Case 1 */
- case 1:
-
- /* Done */
- return;
-
- /* Case 2 */
- case 2:
-
- /* Set new x value, decrease distance and restart */
- Buffer++;
- x += *Buffer;
- Buffer++;
- YDelta -= *Buffer;
- Buffer++;
- continue;
-
- /* Other values */
- default:
-
- Buffer++;
- break;
- }
-
- /* Check if we've gone past the edge */
- if ((x + RleValue) > (Width + Left))
- {
- /* Set fixed up loop count */
- i = RleValue - Left - Width + x;
-
- /* Fixup pixel value */
- RleValue -= i;
- }
- else
- {
- /* Clear loop count */
- i = 0;
- }
-
- /* Check the value now */
- if (RleValue > 1)
- {
- /* Set loop variables */
- j = (RleValue - 2) / 2 + 1;
- do
- {
- /* Get the new value */
- NewRleValue = *Buffer;
-
- /* Get the two colors */
- Color = NewRleValue >> 4;
- Color2 = NewRleValue & 0xF;
-
- /* Increase buffer position */
- Buffer++;
-
- /* Set the pixels */
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- SetPixel(x, YDelta, (UCHAR)Color2);
- x++;
-
- /* Decrease pixel value */
- RleValue -= 2;
- } while (--j);
- }
-
- /* Check if there is any value at all */
- if (RleValue)
- {
- /* Set the pixel and increase position */
- Color = *Buffer >> 4;
- Buffer++;
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- i--;
- }
-
- /* Check loop count now */
- if ((LONG)i > 0)
- {
- /* Decrease it */
- i--;
-
- /* Set new position */
- Buffer = Buffer + (i / 2) + 1;
- }
-
- /* Check if we need to increase the buffer */
- if ((ULONG_PTR)Buffer & 1) Buffer++;
- }
-}
-
-/* PUBLIC FUNCTIONS
**********************************************************/
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-VidSetTextColor(ULONG Color)
-{
- ULONG OldColor;
-
- /* Save the old color and set the new one */
- OldColor = TextColor;
- TextColor = Color;
- return OldColor;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidDisplayStringXY(PUCHAR String,
- ULONG Left,
- ULONG Top,
- BOOLEAN Transparent)
-{
- ULONG BackColor;
-
- /* If the caller wanted transparent, then send the special value
(16), else
*/
- /* use our default and call the helper
routine. */
- BackColor = (Transparent) ? 16 : 14;
- DisplayStringXY(String, Left, Top, 12, BackColor);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidSetScrollRegion(ULONG x1,
- ULONG y1,
- ULONG x2,
- ULONG y2)
-{
- /* Assert alignment */
- ASSERT((x1 & 0x7) == 0);
- ASSERT((x2 & 0x7) == 7);
-
- /* Set Scroll Region */
- ScrollRegion[0] = x1;
- ScrollRegion[1] = y1;
- ScrollRegion[2] = x2;
- ScrollRegion[3] = y2;
-
- /* Set current X and Y */
- curr_x = x1;
- curr_y = y1;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidCleanUp(VOID)
-{
- /* Select bit mask register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-
- /* Clear it */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 255);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidBufferToScreenBlt(IN PUCHAR Buffer,
- IN ULONG Left,
- IN ULONG Top,
- IN ULONG Width,
- IN ULONG Height,
- IN ULONG Delta)
-{
- /* Make sure we have a width and height */
- if (!(Width) || !(Height)) return;
-
- /* Call the helper function */
- BitBlt(Left, Top, Width, Height, Buffer, 4, Delta);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidDisplayString(PUCHAR String)
-{
- ULONG TopDelta = 14;
-
- /* Start looping the string */
- while (*String)
- {
- /* Treat new-line separately */
- if (*String == '\n')
- {
- /* Modify Y position */
- curr_y += TopDelta;
- if (curr_y >= ScrollRegion[3])
- {
- /* Scroll the view */
- VgaScroll(TopDelta);
- curr_y -= TopDelta;
-
- /* Preserve row */
- PreserveRow(curr_y, TopDelta, TRUE);
- }
-
- /* Update current X */
- curr_x = ScrollRegion[0];
-
- /* Preseve the current row */
- PreserveRow(curr_y, TopDelta, FALSE);
- }
- else if (*String == '\r')
- {
- /* Update current X */
- curr_x = ScrollRegion[0];
-
- /* Check if we're being followed by a new line */
- if (String[1] != '\n') NextLine = TRUE;
- }
- else
- {
- /* Check if we had a \n\r last time */
- if (NextLine)
- {
- /* We did, preserve the current row */
- PreserveRow(curr_y, TopDelta, TRUE);
- NextLine = FALSE;
- }
-
- /* Display this character */
- DisplayCharacter(*String, curr_x, curr_y, TextColor, 16);
- curr_x += 8;
-
- /* Check if we should scroll */
- if (curr_x > ScrollRegion[2])
- {
- /* Update Y position and check if we should scroll it
*/
- curr_y += TopDelta;
- if (curr_y > ScrollRegion[3])
- {
- /* Do the scroll */
- VgaScroll(TopDelta);
- curr_y -= TopDelta;
-
- /* Save the row */
- PreserveRow(curr_y, TopDelta, TRUE);
- }
-
- /* Update X */
- curr_x = ScrollRegion[0];
- }
- }
-
- /* Get the next character */
- String++;
- }
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidBitBlt(PUCHAR Buffer,
- ULONG Left,
- ULONG Top)
-{
- PBITMAPINFOHEADER BitmapInfoHeader;
- LONG Delta;
- PUCHAR BitmapOffset;
-
- /* Get the Bitmap Header */
- BitmapInfoHeader = (PBITMAPINFOHEADER)Buffer;
-
- /* Initialize the palette */
- InitPaletteWithTable((PULONG)(Buffer + BitmapInfoHeader->biSize),
- (BitmapInfoHeader->biClrUsed) ?
- BitmapInfoHeader->biClrUsed : 16);
-
- /* Make sure we can support this bitmap */
- ASSERT((BitmapInfoHeader->biBitCount * BitmapInfoHeader->biPlanes)
<=
4);
-
- /* Calculate the delta and align it on 32-bytes, then calculate the
actual
*/
- /* start of the bitmap data. */
- Delta = (BitmapInfoHeader->biBitCount * BitmapInfoHeader->biWidth)
+
31;
- Delta >>= 3;
- Delta &= ~3;
- BitmapOffset = Buffer + sizeof(BITMAPINFOHEADER) + 16 *
sizeof(ULONG);
-
- /* Check the compression of the bitmap */
- if (BitmapInfoHeader->biCompression == 2)
- {
- /* Make sure we have a width and a height */
- if ((BitmapInfoHeader->biWidth) &&
(BitmapInfoHeader->biHeight))
- {
- /* We can use RLE Bit Blt */
- RleBitBlt(Left,
- Top,
- BitmapInfoHeader->biWidth,
- BitmapInfoHeader->biHeight,
- BitmapOffset);
- }
- }
- else
- {
- /* Check if the height is negative */
- if (BitmapInfoHeader->biHeight < 0)
- {
- /* Make it positive in the header */
- BitmapInfoHeader->biHeight *= -1;
- }
- else
- {
- /* Update buffer offset */
- BitmapOffset += ((BitmapInfoHeader->biHeight -1) * Delta);
- Delta *= -1;
- }
-
- /* Make sure we have a width and a height */
- if ((BitmapInfoHeader->biWidth) &&
(BitmapInfoHeader->biHeight))
- {
- /* Do the BitBlt */
- BitBlt(Left,
- Top,
- BitmapInfoHeader->biWidth,
- BitmapInfoHeader->biHeight,
- BitmapOffset,
- BitmapInfoHeader->biBitCount,
- Delta);
- }
- }
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidScreenToBufferBlt(PUCHAR Buffer,
- ULONG Left,
- ULONG Top,
- ULONG Width,
- ULONG Height,
- ULONG Delta)
-{
- ULONG Plane;
- ULONG XDistance;
- ULONG LeftDelta, RightDelta;
- ULONG PixelOffset;
- PUCHAR PixelPosition;
- PUCHAR k, i;
- PULONG m;
- UCHAR Value, Value2;
- UCHAR a;
- ULONG b;
- ULONG x, y;
-
- /* Calculate total distance to copy on X */
- XDistance = Left + Width - 1;
-
- /* Start at plane 0 */
- Plane = 0;
-
- /* Calculate the 8-byte left and right deltas */
- LeftDelta = Left & 7;
- RightDelta = 8 - LeftDelta;
-
- /* Clear the destination buffer */
- RtlZeroMemory(Buffer, Delta * Height);
-
- /* Calculate the pixel offset and convert the X distance into byte
form */
- PixelOffset = Top * 80 + (Left >> 3);
- XDistance >>= 3;
-
- /* Loop the 4 planes */
- do
- {
- /* Set the current pixel position and reset buffer loop
variable
*/
- PixelPosition = (PUCHAR)VgaBase +
PixelOffset;
- i = Buffer;
-
- /* Set Mode 0 */
- ReadWriteMode(0);
-
- /* Set the current plane */
- __outpw(0x3CE, (Plane << 8) | 4);
-
- /* Make sure we have a height */
- if (Height > 0)
- {
- /* Start the outer Y loop */
- y = Height;
- do
- {
- /* Read the current value */
- m = (PULONG)i;
- Value = READ_REGISTER_UCHAR(PixelPosition);
-
- /* Set Pixel Position loop variable */
- k = PixelPosition + 1;
-
- /* Check if we're still within bounds */
- if (Left <= XDistance)
- {
- /* Start X Inner loop */
- x = (XDistance - Left) + 1;
- do
- {
- /* Read the current value */
- Value2 = READ_REGISTER_UCHAR(k);
-
- /* Increase pixel position */
- k++;
-
- /* Do the blt */
- a = Value2 >> (UCHAR)RightDelta;
- a |= Value << (UCHAR)LeftDelta;
- b = lookup[a & 0xF];
- a >>= 4;
- b <<= 16;
- b |= lookup[a];
-
- /* Save new value to buffer */
- *m |= (b << Plane);
-
- /* Move to next destination location */
- m++;
-
- /* Write new value */
- Value = Value2;
- } while (--x);
- }
-
- /* Update pixel position */
- PixelPosition += 80;
- i += Delta;
- } while (--y);
- }
- } while (++Plane < 4);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidSolidColorFill(IN ULONG Left,
- IN ULONG Top,
- IN ULONG Right,
- IN ULONG Bottom,
- IN UCHAR Color)
-{
- ULONG rMask, lMask;
- ULONG LeftOffset, RightOffset, Distance;
- PUCHAR Offset;
- ULONG i, j;
-
- /* Get the left and right masks, shifts, and delta */
- LeftOffset = Left >> 3;
- lMask = (lMaskTable[Left & 0x7] << 8) | 8;
- RightOffset = Right >> 3;
- rMask = (rMaskTable[Right & 0x7] << 8) | 8;
- Distance = RightOffset - LeftOffset;
-
- /* If there is no distance, then combine the right and left masks
*/
- if (!Distance) lMask &= rMask;
-
- /* Switch to mode 10 */
- ReadWriteMode(10);
-
- /* Clear the 4 planes (we're already in unchained mode here) */
- __outpw(0x3C4, 0xF02);
-
- /* Select the color don't care register */
- __outpw(0x3CE, 7);
-
- /* Calculate pixel position for the read */
- Offset = VgaBase + (Top * 80) + (PUCHAR)LeftOffset;
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (USHORT)lMask);
-
- /* Check if the top coord is below the bottom one */
- if (Top <= Bottom)
- {
- /* Start looping each line */
- i = (Bottom - Top) + 1;
- do
- {
- /* Read the previous value and add our color */
- WRITE_REGISTER_UCHAR(Offset, READ_REGISTER_UCHAR(Offset) &
Color);
-
- /* Move to the next line */
- Offset += 80;
- } while (--i);
- }
-
- /* Check if we have a delta */
- if (Distance)
- {
- /* Calculate new pixel position */
- Offset = VgaBase + (Top * 80) + (PUCHAR)RightOffset;
- Distance--;
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (USHORT)rMask);
-
- /* Check if the top coord is below the bottom one */
- if (Top <= Bottom)
- {
- /* Start looping each line */
- i = (Bottom - Top) + 1;
- do
- {
- /* Read the previous value and add our color */
- WRITE_REGISTER_UCHAR(Offset,
- READ_REGISTER_UCHAR(Offset) &
Color);
> -
> - /* Move to the next line */
> - Offset += 80;
> - } while (--i);
> - }
> -
> - /* Check if we still have a delta */
> - if (Distance)
> - {
> - /* Calculate new pixel position */
> - Offset = VgaBase + (Top * 80) + (PUCHAR)(LeftOffset + 1);
> -
> - /* Set the bitmask to 0xFF for all 4 planes */
> - __outpw(0x3CE, 0xFF08);
> -
> - /* Check if the top coord is below the bottom one */
> - if (Top <= Bottom)
> - {
> - /* Start looping each line */
> - i = (Bottom - Top) + 1;
> - do
> - {
> - /* Loop the shift delta */
> - if (Distance > 0)
> - {
> - for (j = Distance; j; Offset++, j--)
> - {
> - /* Write the color */
> - WRITE_REGISTER_UCHAR(Offset, Color);
> - }
> - }
> -
> - /* Update position in memory */
> - Offset += (80 - Distance);
> - } while (--i);
> - }
> - }
> - }
> -}
> -