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.

[Michael Fritscher]

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" [e-mail]
> To: [e-mail]
> 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: [e-mail]
> > [mailto:[e-mail]]
>
> On Behalf Of [e-mail]
> > Sent: Friday, June 15, 2007 3:59 AM
> > To: [e-mail]
> > 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/bootda...
> >
> ============================================================================
> > --- 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/bootvi...
> >
> ============================================================================
> > --- 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) !=
>
> 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) !=
> > {
> >    /* 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/bootvi...
> >
> ============================================================================
> > --- 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@12
> > -VidBufferToScreenBlt@24
> > -VidCleanUp@0
> > -VidDisplayString@4
> > -VidDisplayStringXY
> > -VidInitialize@4
> > -VidResetDisplay@4
> > -VidScreenToBufferBlt@24
> > -VidSetScrollRegion@16
> > -VidSetTextColor@4
> > -VidSolidColorFill@20
> >
> > +VidInitialize
> > +VidCleanUp
> > +VidResetDisplay
> > +VidBufferToScreenBlt
> > +VidScreenToBufferBlt
> > +VidBitBlt
> > +VidSolidColorFill
> > +VidDisplayString
> > +BootVidDisplayBootLogo
> > +BootVidUpdateProgress
> > +BootVidFinalizeBootLogo
> > Propchange: branches/olpc/drivers/base/bootvid/bootvid.def
> > --- svn:needs-lock (original)
> > +++ svn:needs-lock (removed)
> > @@ -1,1 +1,0 @@
> > -*
> >
> > Modified: branches/olpc/drivers/base/bootvid/bootvid.rbuild
> > URL:
>
> http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootvi...
> >
> ============================================================================
> > --- 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/bootvi...
> >
> ============================================================================
> > --- 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/precom...
> >
> ============================================================================
> > --- 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?...
> >
> ============================================================================
> > --- 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
> > [e-mail]
> > http://www.reactos.org/mailman/listinfo/ros-dev
>
> Ros-dev mailing list
> [e-mail]
> http://www.reactos.org/mailman/listinfo/ros-dev