[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.
Michael Fritscher
michael at fritscher.net
Sat Jun 16 04:07:13 CEST 2007
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 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
>
> _______________________________________________
> 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