/* xtended_init:
* Selects the unchained 640x400 mode.
*/
static BITMAP *xtended_init(int w, int h, int v_w, int v_h, int color_depth)
{
unsigned long addr;
BITMAP *b;
/* Do not continue if this version of Allegro was built in C-only mode.
* The bank switchers assume asm-mode calling conventions, but the
* library would try to call them with C calling conventions.
*/
#ifdef ALLEGRO_NO_ASM
return NULL;
#endif
/* see modexsms.c */
_split_modex_screen_ptr = really_split_modex_screen;
/* check it is a valid resolution */
if (color_depth != 8) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Xtended mode only supports 8 bit color"));
return NULL;
}
if ((w != 640) || (h != 400) || (v_w > 640) || (v_h > 400)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Xtended mode only supports 640x400"));
return NULL;
}
/* lock everything that is used to draw mouse pointers */
LOCK_VARIABLE(__modex_vtable);
LOCK_FUNCTION(_x_draw_sprite);
LOCK_FUNCTION(_x_blit_from_memory);
LOCK_FUNCTION(_x_blit_to_memory);
/* set VESA mode 0x100 */
addr = _set_vga_mode(0x100);
if (!addr) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("VESA mode 0x100 not available"));
return NULL;
}
outportw(0x3C4, 0x0604); /* disable chain-4 */
/* we only use 1/4th of the width for the bitmap line pointers */
b = _make_bitmap(640/4, 400, addr, &gfx_xtended, 8, 640/4);
if (!b)
return NULL;
b->w = b->cr = 640;
b->vtable = &__modex_vtable;
b->id |= BMP_ID_PLANAR;
setup_x_magic(b);
return b;
}
/* gfx_gdi_init:
*/
static struct BITMAP *gfx_gdi_init(int w, int h, int v_w, int v_h, int color_depth)
{
/* virtual screen are not supported */
if ((v_w!=0 && v_w!=w) || (v_h!=0 && v_h!=h))
return NULL;
_enter_critical();
gfx_gdi.w = w;
gfx_gdi.h = h;
if (adjust_window(w, h) != 0) {
_TRACE(PREFIX_E "window size not supported.\n");
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Resolution not supported"));
goto Error;
}
/* the last flag serves as an end of loop delimiter */
gdi_dirty_lines = _AL_MALLOC_ATOMIC((h+1) * sizeof(char));
ASSERT(gdi_dirty_lines);
memset(gdi_dirty_lines, 0, (h+1) * sizeof(char));
gdi_dirty_lines[h] = 1;
/* create the screen surface */
screen_surf = _AL_MALLOC_ATOMIC(w * h * BYTES_PER_PIXEL(color_depth));
gdi_screen = _make_bitmap(w, h, (unsigned long)screen_surf, &gfx_gdi, color_depth, w * BYTES_PER_PIXEL(color_depth));
gdi_screen->write_bank = gfx_gdi_write_bank;
_screen_vtable.acquire = gfx_gdi_lock;
_screen_vtable.release = gfx_gdi_unlock;
_screen_vtable.unwrite_bank = gfx_gdi_unwrite_bank;
/* create render timer */
vsync_event = CreateEvent(NULL, FALSE, FALSE, NULL);
install_int(render_proc, RENDER_DELAY);
/* connect to the system driver */
win_gfx_driver = &win_gfx_driver_gdi;
/* set the default switching policy */
set_display_switch_mode(SWITCH_PAUSE);
/* grab input devices */
win_grab_input();
_exit_critical();
return gdi_screen;
Error:
_exit_critical();
gfx_gdi_exit(NULL);
return NULL;
}
/* Allocate and initialize a bitmap structure */
bitmap_t *bmp_create(int width, int height, int overdraw)
{
// uint8 *addr;
// int pitch;
//
// pitch = width + (overdraw * 2); /* left and right */
// addr = malloc((pitch * height) + 3); /* add max 32-bit aligned adjustment */
// if (NULL == addr)
// return NULL;
//printf("bmp_create\n");
return _make_bitmap((uint8*)fb, false, width, height, width, overdraw);
}
static int _refill_pool(struct allocman *alloc, utspace_trickle_t *trickle, uint32_t size_bits)
{
uint32_t i;
int error;
struct utspace_trickle_node *node;
uint32_t cookie;
node = _make_node(alloc, &error);
if (error) {
return error;
}
/* Check if there are untypeds >= 5 size_bits from us */
for (i = size_bits + 5 > 31 ? 31 : size_bits + 5; i < 32; i++) {
if (trickle->heads[i]) {
i = size_bits + 5;
break;
}
}
if (i == 32) {
/* Search for the biggest one near us */
for (i = size_bits + 5 > 31 ? 31 : size_bits + 5; i > size_bits; i--) {
if (trickle->heads[i]) {
break;
}
}
}
if (i != size_bits) {
cookie = _utspace_trickle_alloc(alloc, trickle, i, seL4_UntypedObject, NULL, &error);
if (!error) {
struct utspace_trickle_node *parent = _cookie_to_node(cookie);
uint32_t offset = _cookie_to_offset(cookie);
node->ut = parent->ut;
node->offset = parent->offset + (offset << (i));
if (parent->paddr) {
node->paddr = parent->paddr + (offset << (i));
} else {
node->paddr = 0;
}
node->parent_cookie = cookie;
node->bitmap_bits = i - size_bits + 1;
node->bitmap = _make_bitmap(node->bitmap_bits);
node->next = node->prev = NULL;
_insert_node(&trickle->heads[size_bits], node);
return 0;
}
}
_free_node(alloc, node);
return 1;
}
void _utspace_trickle_free(struct allocman *alloc, void *_trickle, uint32_t cookie, uint32_t size_bits)
{
utspace_trickle_t *trickle = (utspace_trickle_t*)_trickle;
struct utspace_trickle_node *node = _cookie_to_node(cookie);
uint32_t offset = _cookie_to_offset(cookie);
int in_list = !(node->bitmap == 0);
node->bitmap |= BIT(31 - offset);
if (node->bitmap == _make_bitmap(node->bitmap_bits)) {
if (node->parent_cookie) {
if (in_list) {
_remove_node(&trickle->heads[size_bits], node);
}
_utspace_trickle_free(alloc, trickle, node->parent_cookie, size_bits + node->bitmap_bits - 1);
_free_node(alloc, node);
} else if (!in_list) {
_insert_node(&trickle->heads[size_bits], node);
}
} else if (!in_list) {
_insert_node(&trickle->heads[size_bits], node);
}
}
/* _xdga2_gfxdrv_init_drv:
* Initializes driver and creates screen bitmap.
*/
static BITMAP *_xdga2_private_gfxdrv_init_drv(GFX_DRIVER *drv, int w, int h, int vw, int vh, int depth, int accel)
{
int dga_error_base, dga_major_version, dga_minor_version;
int mode, mask, red_shift = 0, green_shift = 0, blue_shift = 0;
long input_mask;
char tmp1[128], tmp2[128];
BITMAP *bmp;
/* This is just to test if the system driver has been installed properly */
if (_xwin.window == None)
return NULL;
/* Test that display is local. */
if (!_xdga2_private_display_is_local()) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("This driver needs local display"));
return NULL;
}
/* Choose convenient size. */
if ((w == 0) && (h == 0)) {
w = 640;
h = 480;
}
if ((w < 80) || (h < 80) || (w > 4096) || (h > 4096)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unsupported screen size"));
return NULL;
}
if (vw < w)
vw = w;
if (vh < h)
vh = h;
if (1
#ifdef ALLEGRO_COLOR8
&& (depth != 8)
#endif
#ifdef ALLEGRO_COLOR16
&& (depth != 15)
&& (depth != 16)
#endif
#ifdef ALLEGRO_COLOR24
&& (depth != 24)
#endif
#ifdef ALLEGRO_COLOR32
&& (depth != 32)
#endif
) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unsupported color depth"));
return NULL;
}
/* Checks presence of DGA extension */
if (!XDGAQueryExtension(_xwin.display, &dga_event_base, &dga_error_base) ||
!XDGAQueryVersion(_xwin.display, &dga_major_version, &dga_minor_version)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("DGA extension is not supported"));
return NULL;
}
/* Works only with DGA 2.0 or newer */
if (dga_major_version < 2) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("DGA 2.0 or newer is required"));
return NULL;
}
/* Attempts to access the framebuffer */
if (!XDGAOpenFramebuffer(_xwin.display, _xwin.screen)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Can not open framebuffer"));
return NULL;
}
/* Finds suitable video mode number */
mode = _xdga2_find_mode(w, h, vw, vh, depth);
if (!mode) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Resolution not supported"));
return NULL;
}
/* Sets DGA video mode */
dga_device = XDGASetMode(_xwin.display, _xwin.screen, mode);
if (dga_device == NULL) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Can not switch to DGA mode"));
return NULL;
}
_xwin.in_dga_mode = 2;
_set_current_refresh_rate(dga_device->mode.verticalRefresh);
set_display_switch_mode(SWITCH_NONE);
/* Installs DGA color map */
if (_dga_cmap) {
XFreeColormap(_xwin.display, _dga_cmap);
_dga_cmap = 0;
}
if ((dga_device->mode.visualClass == PseudoColor)
|| (dga_device->mode.visualClass == GrayScale)
|| (dga_device->mode.visualClass == DirectColor))
_dga_cmap = XDGACreateColormap(_xwin.display, _xwin.screen, dga_device, AllocAll);
else
_dga_cmap = XDGACreateColormap(_xwin.display, _xwin.screen, dga_device, AllocNone);
XDGAInstallColormap(_xwin.display, _xwin.screen, _dga_cmap);
/* Sets up direct color shifts */
if (depth != 8) {
for (mask = dga_device->mode.redMask, red_shift = 0; (mask & 1) == 0;
mask >>= 1, red_shift++);
for (mask = dga_device->mode.greenMask, green_shift = 0; (mask & 1) == 0;
mask >>= 1, green_shift++);
for (mask = dga_device->mode.blueMask, blue_shift = 0; (mask & 1) == 0;
mask >>= 1, blue_shift++);
}
switch (depth) {
case 15:
_rgb_r_shift_15 = red_shift;
_rgb_g_shift_15 = green_shift;
_rgb_b_shift_15 = blue_shift;
break;
case 16:
_rgb_r_shift_16 = red_shift;
_rgb_g_shift_16 = green_shift;
_rgb_b_shift_16 = blue_shift;
break;
case 24:
_rgb_r_shift_24 = red_shift;
_rgb_g_shift_24 = green_shift;
_rgb_b_shift_24 = blue_shift;
break;
case 32:
_rgb_r_shift_32 = red_shift;
_rgb_g_shift_32 = green_shift;
_rgb_b_shift_32 = blue_shift;
break;
}
/* Enables input */
XSync(_xwin.display, True);
input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
| ButtonReleaseMask | PointerMotionMask;
XDGASelectInput(_xwin.display, _xwin.screen, input_mask);
if (_xwin_keyboard_focused) {
(*_xwin_keyboard_focused)(FALSE, 0);
keyboard_got_focus = TRUE;
}
_mouse_on = TRUE;
/* Creates screen bitmap */
drv->linear = TRUE;
bmp = _make_bitmap(dga_device->mode.imageWidth, dga_device->mode.imageHeight,
(uintptr_t)dga_device->data, drv, depth,
dga_device->mode.bytesPerScanline);
if (!bmp) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Not enough memory"));
return NULL;
}
drv->w = bmp->cr = w;
drv->h = bmp->cb = h;
drv->vid_mem = dga_device->mode.imageWidth * dga_device->mode.imageHeight
* BYTES_PER_PIXEL(depth);
if (accel) {
/* Hardware acceleration has been requested */
/* Updates line switcher to accommodate framebuffer synchronization */
#ifdef ALLEGRO_NO_ASM
bmp->write_bank = _xdga2_write_line;
bmp->read_bank = _xdga2_write_line;
#else
bmp->write_bank = _xdga2_write_line_asm;
bmp->read_bank = _xdga2_write_line_asm;
#endif
_screen_vtable.acquire = _xdga2_acquire;
/* Checks for hardware acceleration support */
if (dga_device->mode.flags & XDGASolidFillRect) {
/* XDGAFillRectangle is available */
_orig_hline = _screen_vtable.hline;
_orig_vline = _screen_vtable.vline;
_orig_rectfill = _screen_vtable.rectfill;
_screen_vtable.hline = _xaccel_hline;
_screen_vtable.vline = _xaccel_vline;
_screen_vtable.rectfill = _xaccel_rectfill;
_screen_vtable.clear_to_color = _xaccel_clear_to_color;
gfx_capabilities |= (GFX_HW_HLINE | GFX_HW_FILL);
}
if (dga_device->mode.flags & XDGABlitRect) {
/* XDGACopyArea is available */
_screen_vtable.blit_to_self = _xaccel_blit_to_self;
_screen_vtable.blit_to_self_forward = _xaccel_blit_to_self;
_screen_vtable.blit_to_self_backward = _xaccel_blit_to_self;
gfx_capabilities |= GFX_HW_VRAM_BLIT;
}
if (dga_device->mode.flags & XDGABlitTransRect) {
/* XDGACopyTransparentArea is available */
_orig_draw_sprite = _screen_vtable.draw_sprite;
_orig_masked_blit = _screen_vtable.masked_blit;
_screen_vtable.masked_blit = _xaccel_masked_blit;
_screen_vtable.draw_sprite = _xaccel_draw_sprite;
if (_screen_vtable.color_depth == 8)
_screen_vtable.draw_256_sprite = _xaccel_draw_sprite;
gfx_capabilities |= GFX_HW_VRAM_BLIT_MASKED;
}
RESYNC();
}
/* Checks for triple buffering */
if (dga_device->mode.viewportFlags & XDGAFlipRetrace)
gfx_capabilities |= GFX_CAN_TRIPLE_BUFFER;
/* Sets up driver description */
uszprintf(_xdga2_driver_desc, sizeof(_xdga2_driver_desc),
uconvert_ascii("X-Windows DGA 2.0 graphics%s", tmp1),
uconvert_ascii(accel ? (gfx_capabilities ? " (accelerated)" : "") : " (software only)", tmp2));
drv->desc = _xdga2_driver_desc;
return bmp;
}
/* be_gfx_bwindow_init:
* Initializes specified video mode.
*/
extern "C" struct BITMAP *be_gfx_bwindow_init(int w, int h, int v_w, int v_h, int color_depth)
{
BITMAP *bmp;
if (1
#ifdef ALLEGRO_COLOR8
&& (color_depth != 8)
#endif
#ifdef ALLEGRO_COLOR16
&& (color_depth != 15)
&& (color_depth != 16)
#endif
#ifdef ALLEGRO_COLOR32
&& (color_depth != 32)
#endif
) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unsupported color depth"));
return NULL;
}
if ((!v_w) && (!v_h)) {
v_w = w;
v_h = h;
}
if ((w != v_w) || (h != v_h)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unsupported virtual resolution"));
return NULL;
}
set_display_switch_mode(SWITCH_PAUSE);
_be_allegro_window = new BeAllegroWindow(BRect(0, 0, w-1, h-1), wnd_title,
B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_NOT_RESIZABLE | B_NOT_ZOOMABLE,
B_CURRENT_WORKSPACE, v_w, v_h, color_depth);
_be_window = _be_allegro_window;
if (!_be_allegro_window->buffer->IsValid() ||
((color_depth == 8) && (!_be_allegro_window->aux_buffer->IsValid()))) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Not enough memory"));
goto cleanup;
}
_be_mouse_view = new BView(_be_allegro_window->Bounds(),
"allegro mouse view", B_FOLLOW_ALL_SIDES, 0);
_be_allegro_window->Lock();
_be_allegro_window->AddChild(_be_mouse_view);
_be_allegro_window->Unlock();
_be_mouse_window = _be_allegro_window;
_be_mouse_window_mode = true;
release_sem(_be_mouse_view_attached);
_be_allegro_window->MoveTo(6, 25);
_be_allegro_window->Show();
gfx_beos_bwindow.w = w;
gfx_beos_bwindow.h = h;
gfx_beos_bwindow.linear = TRUE;
gfx_beos_bwindow.vid_mem = _be_allegro_window->buffer->BitsLength();
bmp = _make_bitmap(v_w, v_h, (unsigned long)_be_allegro_window->buffer->Bits(),
&gfx_beos_bwindow, color_depth,
_be_allegro_window->buffer->BytesPerRow());
if (!bmp) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Not enough memory"));
goto cleanup;
}
#ifdef ALLEGRO_NO_ASM
bmp->read_bank = (void *)_be_gfx_bwindow_read_write_bank;
bmp->write_bank = (void *)_be_gfx_bwindow_read_write_bank;
_screen_vtable.unwrite_bank = (void *)_be_gfx_bwindow_unwrite_bank;
#else
bmp->read_bank = _be_gfx_bwindow_read_write_bank_asm;
bmp->write_bank = _be_gfx_bwindow_read_write_bank_asm;
_screen_vtable.unwrite_bank = _be_gfx_bwindow_unwrite_bank_asm;
#endif
_screen_vtable.acquire = be_gfx_bwindow_acquire;
_screen_vtable.release = be_gfx_bwindow_release;
_be_gfx_set_truecolor_shifts();
uszprintf(driver_desc, sizeof(driver_desc), get_config_text("BWindow object, %d bit BBitmap framebuffer"),
color_depth);
gfx_beos_bwindow.desc = driver_desc;
snooze(50000);
_be_gfx_initialized = true;
return bmp;
cleanup:
be_gfx_bwindow_exit(NULL);
return NULL;
}
/* modex_init:
* Selects a tweaked VGA mode and creates a screen bitmap for it.
*/
static BITMAP *modex_init(int w, int h, int v_w, int v_h, int color_depth)
{
TWEAKED_MODE *mode = xmodes;
VGA_REGISTER *reg;
BITMAP *b;
unsigned long addr;
int c;
/* Do not continue if this version of Allegro was built in C-only mode.
* The bank switchers assume asm-mode calling conventions, but the
* library would try to call them with C calling conventions.
*/
#ifdef ALLEGRO_NO_ASM
return NULL;
#endif
/* see modexsms.c */
_split_modex_screen_ptr = really_split_modex_screen;
/* check it is a valid resolution */
if (color_depth != 8) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Mode-X only supports 8 bit color"));
return NULL;
}
/* search the mode table for the requested resolution */
while ((mode->regs) && ((mode->w != w) || (mode->h != h)))
mode++;
if (!mode->regs) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Not a VGA mode-X resolution"));
return NULL;
}
/* round up virtual size if required (v_w must be a multiple of eight) */
v_w = MAX(w, (v_w+7) & 0xFFF8);
v_h = MAX(h, v_h);
if (v_h > 0x40000/v_w) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Virtual screen size too large"));
return NULL;
}
/* calculate virtual height = vram / width */
v_h = 0x40000 / v_w;
/* lock everything that is used to draw mouse pointers */
LOCK_VARIABLE(__modex_vtable);
LOCK_FUNCTION(_x_draw_sprite);
LOCK_FUNCTION(_x_blit_from_memory);
LOCK_FUNCTION(_x_blit_to_memory);
/* set the base video mode, then start tweaking things */
addr = _set_vga_mode(mode->parent);
if (!addr)
return NULL;
outportw(0x3C4, 0x0100); /* synchronous reset */
outportb(0x3D4, 0x11); /* enable crtc regs 0-7 */
outportb(0x3D5, inportb(0x3D5) & 0x7F);
outportw(0x3C4, 0x0604); /* disable chain-4 */
for (reg=mode->regs; reg->port; reg++) { /* set the VGA registers */
if (reg->port == 0x3C0) {
inportb(0x3DA);
outportb(0x3C0, reg->index | 0x20);
outportb(0x3C0, reg->value);
}
else if (reg->port == 0x3C2) {
outportb(reg->port, reg->value);
}
else {
outportb(reg->port, reg->index);
outportb(reg->port+1, reg->value);
}
}
if (mode->hrs) {
outportb(0x3D4, 0x11);
outportb(0x3D5, inportb(0x3D5)&0x7F);
outportb(0x3D4, 0x04);
outportb(0x3D5, inportb(0x3D5)+mode->hrs);
outportb(0x3D4, 0x11);
outportb(0x3D5,inportb(0x3D5)|0x80);
}
if (mode->shift) {
outportb(0x3CE, 0x05);
outportb(0x3CF, (inportb(0x3CF)&0x60)|0x40);
inportb(0x3DA);
outportb(0x3C0, 0x30);
outportb(0x3C0, inportb(0x3C1)|0x40);
for (c=0; c<16; c++) {
outportb(0x3C0, c);
outportb(0x3C0, c);
}
outportb(0x3C0, 0x20);
}
if (mode->repeat) {
outportb(0x3D4, 0x09);
outportb(0x3D5,(inportb(0x3D5)&0x60)|mode->repeat);
}
outportb(0x3D4, 0x13); /* set scanline length */
outportb(0x3D5, v_w/8);
outportw(0x3C4, 0x0300); /* restart sequencer */
/* We only use 1/4th of the real width for the bitmap line pointers,
* so they can be used directly for writing to vram, eg. the address
* for pixel(x,y) is bmp->line[y]+(x/4). Divide the x coordinate, but
* not the line pointer. The clipping position and bitmap width are
* stored in the linear pixel format, though, not as mode-X planes.
*/
b = _make_bitmap(v_w/4, v_h, addr, &gfx_modex, 8, v_w/4);
if (!b)
return NULL;
b->w = b->cr = v_w;
b->vtable = &__modex_vtable;
b->id |= BMP_ID_PLANAR;
setup_x_magic(b);
gfx_modex.w = w;
gfx_modex.h = h;
if (_timer_use_retrace) {
gfx_modex.request_scroll = request_modex_scroll;
gfx_modex.poll_scroll = poll_modex_scroll;
}
else {
gfx_modex.request_scroll = NULL;
gfx_modex.poll_scroll = NULL;
}
#ifdef ALLEGRO_LINUX
b->vtable->acquire = __al_linux_acquire_bitmap;
b->vtable->release = __al_linux_release_bitmap;
#endif
return b;
}
/* allocate and initialize a hardware bitmap */
bitmap_t *bmp_createhw(uint8 *addr, int width, int height, int pitch)
{
return _make_bitmap(addr, true, width, height, pitch, 0); /* zero overdraw */
}