[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.
Magnus Olsen
magnus at greatlord.com
Fri Jun 15 21:14:52 CEST 2007
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 at videotron.ca>
To: <ros-dev at 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.
> Screwing up compatibility continues! Here's an idea, let's rename all the
kernel exports!
>
> -----Original Message-----
> From: ros-diffs-bounces at reactos.org [mailto:ros-diffs-bounces at reactos.org]
On Behalf Of fireball at svn.reactos.org
> Sent: Friday, June 15, 2007 3:59 AM
> To: ros-diffs at 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/bootdata.c?rev=27185&view=auto
>
============================================================================
==
> --- 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
> -};
>
> Modified: branches/olpc/drivers/base/bootvid/bootvid.c
> URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootvid.c?rev=27186&r1=27185&r2=27186&view=diff
>
============================================================================
==
> --- 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>
> +
> +//#define USE_PROGRESS_BAR
> +
> +/* GLOBALS
*******************************************************************/
> +
> +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;
> +}
>
> 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/bootvid.def?rev=27186&r1=27185&r2=27186&view=diff
>
============================================================================
==
> --- 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
>
> EXPORTS
> -VidBitBlt at 12
> -VidBufferToScreenBlt at 24
> -VidCleanUp at 0
> -VidDisplayString at 4
> -VidDisplayStringXY
> -VidInitialize at 4
> -VidResetDisplay at 4
> -VidScreenToBufferBlt at 24
> -VidSetScrollRegion at 16
> -VidSetTextColor at 4
> -VidSolidColorFill at 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/bootvid.rbuild?rev=27186&r1=27185&r2=27186&view=diff
>
============================================================================
==
> --- 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>
> <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/bootvid.rc?rev=27186&r1=27185&r2=27186&view=diff
>
============================================================================
==
> --- 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/precomp.h?rev=27185&view=auto
>
============================================================================
==
> --- 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?rev=27185&view=auto
>
============================================================================
==
> --- 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] >>
3);
> - 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);
> - }
> - }
> - }
> -}
> -
>
>
>
> _______________________________________________
> Ros-dev mailing list
> Ros-dev at reactos.org
> http://www.reactos.org/mailman/listinfo/ros-dev
More information about the Ros-dev
mailing list