gs.cpp

/*
  VGATEST
  Use at your own risk.

  Copyright (C) 2019-2026  Marco Bortolin

  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 3 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, see <http://www.gnu.org/licenses/>.
*/

#include <conio.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdarg.h>

#include "common.h"
#include "utils.h"
#include "gs.h"


GfxScreen::GfxScreen()
{
    m_error = e_none;

    m_origMode = getBIOSMode();
    if(!isVga()) {
        m_error = e_notVgaDisplay;
        return;
    }

    m_fontAddr = NULL;
    m_fontHeight = 14;
    m_videoMem = ADDR_A0000;
    m_activeOffset = 0;
    m_maxx = 0;
    m_maxy = 0;
    m_width = 0;
    m_height = 0;
    m_scanlines = 0;
    m_pages = 0;
    m_lineSize = 0;
    m_pageSize = 0;
    m_chained = 0;
    m_modeName = NULL;
    m_colors = 0;
    m_crtc_addr = 0;
    m_isr1_addr = 0;
    m_overscanColor = 0;

    m_putPixelFn = NULL;
    m_getPixelFn = NULL;
    m_clearFn = NULL;
    m_drawTextFn = NULL;
    m_fillRectFn = NULL;
}

GfxScreen::~GfxScreen()
{
}

void GfxScreen::setMode(int16_t mode)
{
    m_error = e_none;
    m_modeName = NULL;
    m_videoMem = ADDR_A0000;
    
    switch (mode)
    {
    case v_b320x200_04h: mode_b320x200_04h(); break;
    case v_b640x200_06h: mode_b640x200_06h(); break;
    case v_b320x200_0Dh: mode_b320x200_0Dh(); break;
    case v_b640x200_0Eh: mode_b640x200_0Eh(); break;
    case v_b640x350_0Fh: mode_b640x350_0Fh(); break;
    case v_b640x350_10h: mode_b640x350_10h(); break;
    case v_b640x480_12h: mode_b640x480_12h(); break;
    case v_b320x200_13h: mode_b320x200_13h(); break;
    case v_t160x120:   mode_t160x120(); break;
    case v_t296x220:   mode_t296x220(); break;
    case v_t256x256_Q: mode_t256x256_Q(); break;
    case v_t320x200_Y: mode_t320x200_Y(); break;
    case v_t320x240_X: mode_t320x240_X(); break;
    case v_t320x400:   mode_t320x400(); break;
    case v_t360x270:   mode_t360x270(); break;
    case v_t360x360:   mode_t360x360(); break;
    case v_t360x480:   mode_t360x480(); break;
    case v_t400x300:   mode_t400x300(); break;
    default:
        m_error = e_modeNotSupported;
        break;
    }

    if (m_error != e_none) {
        return;
    }

    if(m_height < 350) {
        m_fontHeight = 8;
    } else if(m_height < 480) {
        m_fontHeight = 14;
    } else {
        m_fontHeight = 16;
    }
    m_fontAddr = getFont(m_fontHeight);
    m_activeOffset = m_videoMem;
    if(inp(MOR_READ) & 1) {
        m_crtc_addr = CRTC_ADDR_COL;
        m_isr1_addr = ISR1_ADDR_COL;
    } else {
        m_crtc_addr = CRTC_ADDR_MONO;
        m_isr1_addr = ISR1_ADDR_MONO;
    }
    m_maxx = m_width - 1;
    m_maxy = m_height - 1;

    if(m_crtc_addr == CRTC_ADDR_COL) {
        ACR_OUT_COL(ACR_OVERSCAN, m_overscanColor);
    }

    clear(color(c_black));
}

void GfxScreen::resetMode()
{
    setBIOSMode(m_origMode);

    m_width = 0;
    m_height = 0;
    m_scanlines = 0;
    m_maxx = 0;
    m_maxy = 0;
    m_pages = 0;
    m_lineSize = 0;
    m_pageSize = 0;
    m_chained = 0;
    m_modeName = NULL;
    m_crtc_addr = 0;
    m_isr1_addr = 0;

    m_putPixelFn = NULL;
    m_getPixelFn = NULL;
    m_clearFn = NULL;
    m_drawTextFn = NULL;
    m_fillRectFn = NULL;
}

void GfxScreen::clear_odd_even(int row, int lines, uint8_t color)
{
    /* address section differs depending on odd/even scanline */
    uint8_t *even_ptr = m_activeOffset;
    uint8_t *odd_ptr = m_activeOffset + 0x2000;
    
#ifdef __386__
    uint32_t c = (color << 24) | (color << 16) | (color << 8) | color;
#else
    uint16_t c = (color << 8) | color;
#endif
    while(lines--) {
        int y = row + lines;
        int bank_line = y / 2;
        uint8_t *base;
        if(y & 1) {
            base = odd_ptr;
        } else {
            base = even_ptr;
        }
#ifdef __386__
        fillLong(base + (m_lineSize * bank_line), c, m_lineSize >> 2);
#else
        fillWord(base + (m_lineSize * bank_line), c, m_lineSize >> 1);
#endif
    }
}

void GfxScreen::clear1(int row, int lines, uint8_t color)
{
    clear_odd_even(row, lines, color & 1 ? 0xFF : 0);
}

void GfxScreen::clear2(int row, int lines, uint8_t color)
{
    color &= 3;
    uint8_t c = color | (color << 2) | (color << 4) | (color << 6);

    clear_odd_even(row, lines, c);
}

void GfxScreen::clear4(int row, int lines, uint8_t color)
{
    setPlanarRWMode(0,0);

    // enable all planes
    SEQ_OUT(SEQ_MAPMASK, 0x0F);

    // CPU data to all planes will be
    // replaced by set/reset value
    GCR_OUT(GCR_EN_SETRESET, 0x0F);

    // set/reset value
    GCR_OUT(GCR_SETRESET, color);

    // enable all bits
    GCR_OUT(GCR_BITMASK, 0xff);

    // since set/reset is enabled for all planes, the written value is ignored
#ifdef __386__
    fillLong(m_activeOffset + (m_lineSize * row), 0, (m_lineSize*lines)/4);
#else
    fillWord(m_activeOffset + (m_lineSize * row), 0, (m_lineSize >> 1) * lines);
#endif
    
    // disable set/reset
    GCR_OUT(GCR_EN_SETRESET, 0x00);

    setPlanarRWMode(0,2);
}

void GfxScreen::clear8(int row, int lines, uint8_t color)
{
    outp(SEQ_ADDR, 0x02);  // enable all planes
    outp(SEQ_DATA, 0x0F);

#ifdef __386__
    uint32_t c = (color << 24) | (color << 16) | (color << 8) | color;
    fillLong(m_activeOffset + (m_lineSize * row), c, (m_width*lines)/16);
#else
    uint16_t c = (color << 8) | color;
    fillWord(m_activeOffset + (m_lineSize * row), c, (m_width >> 3) * lines);
#endif
}

void GfxScreen::clear8chained(int row, int lines, uint8_t color)
{
#ifdef __386__
    uint32_t c = (color << 24) | (color << 16) | (color << 8) | color;
    fillLong(m_activeOffset + (m_lineSize * row), c, (m_width*lines)/4);
#else
    uint16_t c = (color << 8) | color;
    fillWord(m_activeOffset + (m_lineSize * row), c, (m_width >> 1) * lines);
#endif
}

void GfxScreen::clear(uint8_t color)
{
    clear(0, m_height, color);
}

int32_t GfxScreen::getPageOffset(uint8_t page)
{
    // only planar modes have more than 1 page
    // so if current mode is chained (m_pageSize / 4) is wrong but irrelevant
    return (page % m_pages) * (m_pageSize / 4);
}

void GfxScreen::setActivePage(uint8_t page)
{
    m_activeOffset = m_videoMem + getPageOffset(page);
}

void GfxScreen::setVisiblePage(uint8_t page)
{
    if(m_pages == 1) {
        vsync();
        return;
    }

    int32_t offset = getPageOffset(page);

    // wait for display disable
    while(inp(m_isr1_addr) & 0x01);

    // set start address
    setStartAddress(offset);

    // wait for vertical retrace
    while(!(inp(m_isr1_addr) & 0x08));
}

void GfxScreen::putPixel1(int16_t x, int16_t y, uint8_t color)
{
    uint8_t *ptr = m_activeOffset +  0x2000*(y%2) + m_lineSize*(y/2) + (x/8);
    int mask = (1<<7) >> (x%8); 
    uint8_t temp = *ptr;
    color &= 1;
    color <<= 7;
    color >>= (x%8);
    temp &= ~mask;
    temp |= color;
    *ptr = temp;
}

void GfxScreen::putPixel2(int16_t x, int16_t y, uint8_t color)
{
    uint8_t *ptr = m_activeOffset + 0x2000*(y%2) + m_lineSize*(y/2) + (2*x/8);
    int mask = (3<<6) >> (2*x%8);
    uint8_t temp = *ptr;
    color &= 3;
    color <<= 6;
    color >>= (2*x%8);
    temp &= ~mask;
    temp |= color;
    *ptr = temp;
}

void GfxScreen::putPixel4(int16_t x, int16_t y, uint8_t color)
{
    // clip to the mode width and height
    if(x < 0 || x > m_maxx || y < 0 || y > m_maxy) {
        return;
    }

    uint8_t bitmask = 1 << ((x & 0x07) ^ 0x07);
    outp(GCR_ADDR, GCR_BITMASK);
    outp(GCR_DATA, bitmask);

    uint16_t offset = y * m_lineSize + (x >> 3);
    volatile uint8_t dummy = *(m_activeOffset + offset); // load latches
    *(m_activeOffset + offset) = color % 16;
}

void GfxScreen::putPixel8(int16_t x, int16_t y, uint8_t color)
{
    // clip to the mode width and height
    if (x < 0 || x > m_maxx || y < 0 || y > m_maxy) {
        return;
    }

    // set the mask so that only one pixel gets written
    outp(SEQ_ADDR, SEQ_MAPMASK);
    outp(SEQ_DATA, 1 << (x & 0x3));

    // put pixel in memory
    *(m_activeOffset + (m_lineSize * y) + (x >> 2)) = color;
}

void GfxScreen::putPixel8chained(int16_t x, int16_t y, uint8_t color)
{
    // clip to the mode width and height
    if (x < 0 || x > m_maxx || y < 0 || y > m_maxy) {
        return;
    }

    // put pixel in memory
    *(m_activeOffset + (m_lineSize * y) + x) = color;
}

int16_t GfxScreen::getPixel1(int16_t x, int16_t y)
{
    uint8_t *ptr = m_activeOffset +  0x2000*(y%2) + m_lineSize*(y/2) + (x/8);
    int mask = (1<<7) >> (x%8); 
    uint8_t temp = *ptr;
    return (bool)(temp & mask);
}

int16_t GfxScreen::getPixel2(int16_t x, int16_t y)
{
    uint8_t *ptr = m_activeOffset + 0x2000*(y%2) + m_lineSize*(y/2) + (2*x/8);
    uint8_t temp = *ptr;
    temp >>= 6 - (2*x%8);
    temp &= 0x3;
    return temp;
}

int16_t GfxScreen::getPixel4(int16_t x, int16_t y)
{
    if(x < 0 || x > m_maxx || y < 0 || y > m_maxy) {
        return -1;
    }

    uint8_t *cell = (m_activeOffset + (m_lineSize * y) + x/8);
    int16_t value = 0;
    uint8_t bit = x & 7;

    GCR_OUT(GCR_READMAP_SEL, 0);
    value |= ((*cell)>>bit)&1;
    GCR_OUT(GCR_READMAP_SEL, 1);
    value |= (((*cell)>>bit)&1) << 1;
    GCR_OUT(GCR_READMAP_SEL, 2);
    value |= (((*cell)>>bit)&1) << 2;
    GCR_OUT(GCR_READMAP_SEL, 3);
    value |= (((*cell)>>bit)&1) << 3;

    return value;
}

int16_t GfxScreen::getPixel8(int16_t x, int16_t y)
{
    // clip to the mode width and height
    if (x < 0 || x > m_maxx || y < 0 || y > m_maxy) {
        return -1;
    }

    // set the mask so that only one pixel gets read
    outp(GCR_ADDR, 0x04);
    outp(GCR_DATA, x & 0x3);

    return *(m_activeOffset + (m_lineSize * y) + (x >> 2));
}

int16_t GfxScreen::getPixel8chained(int16_t x, int16_t y)
{
    // clip to the mode width and height
    if (x < 0 || x > m_maxx || y < 0 || y > m_maxy) {
        return -1;
    }

    return *(m_activeOffset + (m_lineSize * y) + x);
}

void GfxScreen::drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
{
    // Lines are NOT clipped.
    //
    // Algorithm derived from:
    //  Digital Line Drawing by Paul Heckbert
    //  from "Graphics Gems", Academic Press, 1990
    //
    int16_t x = x1;
    int16_t y = y1;

    int16_t dx = x2 - x1;
    int16_t ax = abs(dx) << 1;
    int16_t sx = sign(dx);

    int16_t dy = y2 - y1;
    int16_t ay = abs(dy) << 1;
    int16_t sy = sign(dy);

    int16_t d;

    if(ax > ay) {
        // x dominant
        d = ay - (ax >> 1);
        while(true) {
            putPixel(x, y, color);
            if(x == x2) {
                return;
            }
            if(d >= 0) {
                y += sy;
                d -= ax;
            }
            x += sx;
            d += ay;
        }
    } else {
        // y dominant
        d = ax - (ay >> 1);
        while(true) {
            putPixel(x, y, color);
            if(y == y2) {
                return;
            }
            if(d >= 0) {
                x += sx;
                d -= ay;
            }
            y += sy;
            d += ax;
        }
    }
}

void GfxScreen::drawCircle(int16_t cx, int16_t cy, int16_t r, uint8_t color)
{
    int32_t n=0, invradius=(1/(float)r)*0x10000L;
    int16_t dx=0, dy=r-1;

    putPixel(cx, cy, color);

    while(dx<=dy)
    {
        putPixel(cx+dy, cy-dx, color); // octant 0
        putPixel(cx+dx, cy-dy, color); // octant 1
        putPixel(cx-dx, cy-dy, color); // octant 2
        putPixel(cx-dy, cy-dx, color); // octant 3
        putPixel(cx-dy, cy+dx, color); // octant 4
        putPixel(cx-dx, cy+dy, color); // octant 5
        putPixel(cx+dx, cy+dy, color); // octant 6
        putPixel(cx+dy, cy+dx, color); // octant 7
        dx++;
        n += invradius;
        dy = (int16_t)((r * DATA_SIN_ACOS[(int16_t)(n>>6)]) >> 16);
    }
}

void GfxScreen::drawRectangle(int16_t x, int16_t y, int16_t width, int16_t height, uint8_t color)
{
    int x2 = x+width-1;
    int y2 = y+height-1;
    drawLine(x, y, x2, y, color);
    drawLine(x, y, x, y2, color);
    drawLine(x2, y, x2, y2, color);
    drawLine(x, y2, x2, y2, color);

}

void GfxScreen::drawChar8(int16_t x, int16_t y, uint8_t color, char c)
{
    uint8_t far *font = m_fontAddr + (c * m_fontHeight);

    for (int i = 0; i < m_fontHeight; i++) {
        uint8_t mask = *font;
        for (int j = 0; j < 8; j++) {
            if (mask & 0x80) {
                putPixel(x + j, y + i, color);
            }
            mask <<= 1;
        }
        font++;
    }
}

void GfxScreen::drawChar4(int16_t x, int16_t y, uint8_t color, char c)
{
    // draws a character in 4-bit / 16-color modes

    // C++ version of LISTING 26.1,
    // Graphics Programming Black Book by Michael Abrash.
    // This function needs write mode 3

    uint8_t *vga_offset = m_activeOffset + (y * m_lineSize) + x / 8;
    uint8_t xbit = x & 7;
    uint8_t far *font = m_fontAddr + c * m_fontHeight;

    outp(GCR_ADDR, GCR_ROTATE);
    uint8_t rot = inp(GCR_DATA);
    rot &= 0xe0;
    rot |= xbit;
    outp(GCR_DATA, rot);

    uint8_t leftmask = 0xff >> xbit;
    uint8_t rightmask = 0xff << (-xbit + 8);
    volatile uint8_t dummy;
    for(uint8_t i=0; i<m_fontHeight; i++) {
        GCR_OUT(GCR_BITMASK, leftmask);
        dummy = *vga_offset;
        *vga_offset = *font;

        GCR_OUT(GCR_BITMASK, rightmask);
        dummy = *vga_offset;
        *vga_offset = *font;

        font++;
        vga_offset += m_lineSize;
    }
}

void GfxScreen::printText(int16_t x, int16_t y, uint8_t color, const char *fmt, ...)
{
    char buf[200];

    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, 200, fmt, ap);
    va_end(ap);

    drawText(x, y, color, buf);
}

void GfxScreen::drawText8(int16_t x, int16_t y, uint8_t color, const char *string)
{
    while(*string) {
        drawChar8(x, y, color, *string++);
        x += 8;
    }
}

void GfxScreen::drawText4(int16_t x, int16_t y, uint8_t color, const char *string)
{
    setPlanarRWMode(0,3);

    outp(GCR_ADDR, GCR_SETRESET);
    uint8_t setrst = inp(GCR_DATA);
    setrst &= 0xf0;
    setrst |= color & 0x0f;
    outp(GCR_DATA, setrst);

    // x must be multiple of 8
    x &= 0xFFF8;

    while(*string) {
        drawChar4(x, y, color, *string++);
        x += 8;
    }

    setPlanarRWMode(0,2);
}

void GfxScreen::fillRectAny(int16_t x, int16_t y, int16_t width, int16_t height, uint8_t color)
{
    // fallback

    int16_t x1 = x;
    int16_t x2 = x + width - 1;
    int16_t y1 = y;
    int16_t y2 = y + height - 1;

    if(x1 < 0) {
        x1 = 0;
    }
    if(x2 > m_maxx) {
        x2 = m_maxx;
    }
    if(y1 < 0) {
        y1 = 0;
    }
    if (y2 > m_maxy) {
        y2 = m_maxy;
    }
    if(y2 < y1 || x2 < x1) {
        return;
    }
    
    height = y2 - y1;
    for(int h = 0; h < height; h++) {
        drawLine(x1, y1+h, x2, y1+h, color);
    }
}

void GfxScreen::fillRect4(int16_t x1, int16_t y1, int16_t width, int16_t height, uint8_t color)
{
    // this is similar to the fillRect8 algo, with bands of 8 bytes and masks.
    // differences are the size of pixels and the way of setting them.
    
    if(x1<0 || y1<0 || x1>m_maxx || y1>m_maxy || width==0 || height==0) {
        return;
    }
    if(x1 + width > m_width) {
        width = m_width - x1;
    }
    if(y1 + height > m_height) {
        height = m_height - y1;
    }
    const int x2 = x1 + width - 1;
    const int y2 = y1 + height - 1;

    static const uint8_t leftMask[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};
    static const uint8_t rightMask[8] = {0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};
    static const uint8_t middleMask[8][8] = {
        {0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff},
        {0x40, 0x60, 0x70, 0x78, 0x7c, 0x7e, 0x7f, 0x00},
        {0x20, 0x30, 0x38, 0x3c, 0x3e, 0x3f, 0x00, 0x00},
        {0x10, 0x18, 0x1c, 0x1e, 0x1f, 0x00, 0x00, 0x00},
        {0x08, 0x0c, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00},
        {0x04, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
    };
    
    // bands are groups of 8 pixels
    const int leftBit  = x1 & 7;
    const int rightBit = x2 & 7;
    const int leftBand = x1 >> 3;
    const int rightBand = x2 >> 3;
    const int middleBands = rightBand - (leftBand + 1);

    if(leftBand == rightBand) {
        uint8_t mask = middleMask[leftBit][rightBit];
        GCR_OUT(GCR_BITMASK, mask);
        uint8_t *addr = m_activeOffset + (m_lineSize * y1) + leftBand;
        for(; y1 < y2; y1++) {
            volatile uint8_t latches = *addr;
            *addr = color;
            addr += m_lineSize;
        }
    } else {
        uint8_t *top = m_activeOffset + (m_lineSize * y1);
        uint8_t *dest;
        uint8_t mask;
        
        dest = top + leftBand;
        mask = leftMask[leftBit];
        GCR_OUT(GCR_BITMASK, mask);
        for(int16_t i = y1; i < y2; i++) {
            // we need to load the latches first
            volatile uint8_t latches = *dest;
            *dest = color;
           dest += m_lineSize;
        }
        if(middleBands) {
            dest = top + leftBand + 1;
            GCR_OUT(GCR_BITMASK, 0xFF);
            for(int16_t i = y1; i < y2; i++) {
                memset(dest, color, middleBands);
                dest += m_lineSize;
            }
        }
        dest = top + rightBand;
        mask = rightMask[rightBit];
        GCR_OUT(GCR_BITMASK, mask);
        for(int16_t i = y1; i < y2; i++) {
            volatile uint8_t latches = *dest;
            *dest = color;
           dest += m_lineSize;
        }
    }
}

void GfxScreen::fillRect8(int16_t x, int16_t y, int16_t width, int16_t height, uint8_t color)
{
    static const int32_t middleMask[4][4] =
    {
        {0x1, 0x3, 0x7, 0xf},
        {0x0, 0x2, 0x6, 0xe},
        {0x0, 0x0, 0x4, 0xc},
        {0x0, 0x0, 0x0, 0x8},
    };
    static const int32_t leftMask[4] = {0xf, 0xe, 0xc, 0x8};
    static const int32_t rightMask[4] = {0x1, 0x3, 0x7, 0xf};
    
    int32_t x1 = x;
    int32_t x2 = x + width - 1;
    int32_t y1 = y;
    int32_t y2 = y + height - 1;

    // clip to the screen.
    if(x1 < 0) {
        x1 = 0;
    }
    if(x2 > m_maxx) {
        x2 = m_maxx;
    }
    if(y1 < 0) {
        y1 = 0;
    }
    if (y2 > m_maxy) {
        y2 = m_maxy;
    }
    if(y2 < y1 || x2 < x1) {
        return;
    }

    // in unchained 8bit modes we want to paint from the top down
    // and make use of the 4 pixel wide vertical bands
    int32_t leftBand = x1 >> 2;
    int32_t rightBand = x2 >> 2;
    int32_t leftBit = x1 & 3;
    int32_t rightBit = x2 & 3;
    uint8_t *top;
    uint8_t *where;
    int32_t mask;

    if(leftBand == rightBand) {
        // the whole rectangle is in one band
        mask = middleMask[leftBit][rightBit];
        outp(SEQ_ADDR, 0x02);
        outp(SEQ_DATA, mask);

        top = m_activeOffset + (m_lineSize * y1) + leftBand;
        for(int32_t i = y1; i <= y2; i++) {
            *top = color;
            top += m_lineSize;
        }
    } else {
        // spans 2 or more bands
        mask = leftMask[leftBit];
        outp(SEQ_ADDR, 0x02);
        outp(SEQ_DATA, mask);

        top = m_activeOffset + (m_lineSize * y1) + leftBand;
        where = top;
        // fill the left edge
        for(int32_t i = y1; i <= y2; i++) {
            *where = color;
            where += m_lineSize;
        }
        top++;

        outp(SEQ_ADDR, 0x02);
        outp(SEQ_DATA, 0x0f);

        int32_t bands = rightBand - (leftBand + 1);
        if(bands > 0) {
            where = top;
            // fill the middle
            for(int32_t i = y1; i <= y2; i++) {
                memset(where, color, bands);
                where += m_lineSize;
            }
            top += bands;
        }

        mask = rightMask[rightBit];

        outp(SEQ_ADDR, 0x02);
        outp(SEQ_DATA, mask);

        where = top;
        // fill the right edge
        for(int32_t i = y1; i <= y2; i++) {
            *where = color;
            where += m_lineSize;
        }
    }
}

void GfxScreen::fillRect8chained(int16_t x, int16_t y, int16_t width, int16_t height, uint8_t color)
{
    if(x<0 || y<0 || x>m_maxx || y>m_maxy || width==0 || height==0) {
        return;
    }
    if(x + width > m_width) {
        width = m_width - x;
    }
    if(y + height > m_height) {
        height = m_height - y;
    }

#ifdef __386__
    uint32_t c = color;
    c = (c << 8) | color;
    c = (c << 8) | color;
    c = (c << 8) | color;

    uint8_t *lineptr = m_activeOffset + (m_lineSize * y) + x;
    int dwords = width / 4;
    int bytes = width - dwords * 4;
    int linestep = dwords * 4 + (m_width - width);
    for(int l=0; l<height; l++) {
        for(int b=0; b<bytes; b++) {
            *lineptr++ = color;
        }
        fillLong(lineptr, c, dwords);
        lineptr += linestep;
    }
#else
    uint16_t c = (color << 8) | color;

    uint8_t *lineptr = m_activeOffset + (m_lineSize * y) + x;
    int words = width / 2;
    int bytes = width - (words * 2);
    int linestep = words * 2 + (m_width - width);
    for(int l=0; l<height; l++) {
        for(int b=0; b<bytes; b++) {
            *lineptr++ = color;
        }
        fillWord(lineptr, c, words);
        lineptr += linestep;
    }
#endif
}

//---------------------------------------------------
//
// Set one entry in the DAC color palette (256 color mode).
//

void GfxScreen::setColor256(int16_t index, uint16_t r, uint16_t g, uint16_t b)
{
    if (index < 0 || index > 255) {
        return;
    }

    while(!(inp(m_isr1_addr) & 0x01));    // wait for blanking

    outp(PAL_WRITE_ADDR, index);
    outp(PAL_DATA, r);
    outp(PAL_DATA, g);
    outp(PAL_DATA, b);
}

void GfxScreen::setPalette256(int16_t start, int16_t count, s_color *p)
{
    int16_t i;

    if(start < 0 || (start + count - 1) > 255) {
        return;
    }

    vsync();

    outp(PAL_WRITE_ADDR, start);
    for (i = 0; i < count; i++) {
        outp(PAL_DATA, p->red);
        outp(PAL_DATA, p->green);
        outp(PAL_DATA, p->blue);
        p++;
    }
}

void GfxScreen::setSplitScreen(uint16_t scanline)
{
    if(scanline < m_scanlines) {
        ::setSplitScreen(m_crtc_addr, scanline);
    }
}

void GfxScreen::setHPanning(uint8_t hPan)
{
    uint16_t isra = 0x03da;
    if(m_crtc_addr == CRTC_ADDR_MONO) {
        isra = 0x03ba;
    }
    ACR_OUT(isra, ACR_HPELPAN, hPan);
}

void GfxScreen::setVPanning(uint8_t vPan)
{
    int prs;
    CRTC_IN(m_crtc_addr, CRTC_PRESET_ROW_SCAN, prs);
    prs &= ~0x1f;
    prs |= (vPan & 0x1f);
    CRTC_OUT(m_crtc_addr, CRTC_PRESET_ROW_SCAN, prs);
}

void GfxScreen::setPanningMode(bool mode)
{
    uint16_t isra = 0x03da;
    if(m_crtc_addr == CRTC_ADDR_MONO) {
        isra = 0x03ba;
    }
    uint8_t reg;
    ACR_IN(isra, ACR_ATTMODE, reg);
    reg &= ~0x20;
    reg |= (mode << 5);
    ACR_OUT(isra, ACR_ATTMODE, reg);
}

void GfxScreen::setStartAddress(uint16_t address)
{
    ::setStartAddress(m_crtc_addr, address);
}

void GfxScreen::vsync()
{
    // wait until any previous retrace has ended
    while(inp(m_isr1_addr) & 0x08);
    // wait until a new retrace has just begun
    while(!(inp(m_isr1_addr) & 0x08));
}

void GfxScreen::wait_disp_enable()
{
    while((inp(m_isr1_addr) & 0x01));
}

void GfxScreen::setPlanarRWMode(int rmode, int wmode)
{
    outp(GCR_ADDR, 0x05); // R/W mode
    uint8_t mode = inp(GCR_DATA) & 0xF4;
    mode |= ((rmode&1)<<3) | (wmode&3);
    outp(GCR_DATA, mode);
}

void GfxScreen::setStdVGAColorMap()
{
    for(int i=0; i<256; i++) m_cval[i] = i;
    for(int i=0; i<256; i++) m_cmap[i] = i;
}

//****************************************************************************//
// MODE SETTING
//****************************************************************************//

void selectVGAFreq(int hpels, int lines)
{
    uint8_t reg = 0x23; // bit 0,1,5
    switch(hpels) {
        case 640:
        case 320:
            break;
        case 720:
        case 360:
            reg |= 0x04;
            break;
    }
    switch(lines) {
        default:
        case 400: reg |= 0x40; break;
        case 350: reg |= 0x80; break;
        case 480: reg |= 0xc0; break;
    }

    SEQ_OUT(0x00,0x01);   // synchronous reset while setting Misc Output
    outp(MOR_ADDR, reg);
    SEQ_OUT(0x00,0x03);   // undo reset (restart sequencer)
}

void GfxScreen::mode_b320x200_04h()
{
    setBIOSMode(0x04);

    m_videoMem = ADDR_B8000;
    m_width    = 320;
    m_height   = 200;
    m_scanlines = 400;
    m_pages    = 1;
    m_lineOffset = 40;
    m_lineSize = 80;
    m_chained  = 0;
    m_pageSize = 16000;
    m_modeName = "Mode 04h 320x200x4";
    m_colors   = 4;
    m_putPixelFn = putPixel2;
    m_getPixelFn = getPixel2;
    m_clearFn    = clear2;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRectAny;

    memset(m_cval, 0, 256);
    m_cval[0] = 0;
    m_cval[1] = 1;
    m_cval[2] = 2;
    m_cval[3] = 3;

    m_cmap[c_black  ] = 0;
    m_cmap[c_blue   ] = 1;
    m_cmap[c_green  ] = 1;
    m_cmap[c_cyan   ] = 1;
    m_cmap[c_red    ] = 2;
    m_cmap[c_magenta] = 2;
    m_cmap[c_brown  ] = 0;
    m_cmap[c_lgray  ] = 3;
    m_cmap[c_dgray  ] = 0;
    m_cmap[c_lblue  ] = 1;
    m_cmap[c_lgreen ] = 1;
    m_cmap[c_lcyan  ] = 1;
    m_cmap[c_lred   ] = 2;
    m_cmap[c_pink   ] = 2;
    m_cmap[c_yellow ] = 3;
    m_cmap[c_white  ] = 3;
    for(int i=16; i<256; i++) {
        m_cmap[i] = i%2;
    }
}

void GfxScreen::mode_b640x200_06h()
{
    setBIOSMode(0x06);

    m_videoMem = ADDR_B8000;
    m_width    = 640;
    m_height   = 200;
    m_scanlines = 400;
    m_pages    = 1;
    m_lineOffset = 40;
    m_lineSize = 80;
    m_chained  = 0;
    m_pageSize = 16000;
    m_modeName = "Mode 06h 640x200x2";
    m_colors   = 2;
    m_putPixelFn = putPixel1;
    m_getPixelFn = getPixel1;
    m_clearFn    = clear1;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRectAny;

    memset(m_cval, 0, 256);
    m_cval[0] = 0;
    m_cval[1] = 1;

    m_cmap[c_black  ] = 0;
    m_cmap[c_blue   ] = 0;
    m_cmap[c_green  ] = 1;
    m_cmap[c_cyan   ] = 1;
    m_cmap[c_red    ] = 1;
    m_cmap[c_magenta] = 1;
    m_cmap[c_brown  ] = 0;
    m_cmap[c_lgray  ] = 1;
    m_cmap[c_dgray  ] = 0;
    m_cmap[c_lblue  ] = 1;
    m_cmap[c_lgreen ] = 1;
    m_cmap[c_lcyan  ] = 1;
    m_cmap[c_lred   ] = 1;
    m_cmap[c_pink   ] = 1;
    m_cmap[c_yellow ] = 1;
    m_cmap[c_white  ] = 1;
    for(int i=16; i<256; i++) {
        m_cmap[i] = i%2;
    }
}

void GfxScreen::mode_b320x200_0Dh()
{
    setBIOSMode(0x0d);

    m_width    = 320;
    m_height   = 200;
    m_scanlines = 400;
    m_pages    = 8;
    m_lineOffset = 40;
    m_lineSize = 40;
    m_chained  = 0;
    m_pageSize = 32000;
    m_modeName = "Mode 0Dh 320x200x16";
    m_colors   = 16;
    m_putPixelFn = putPixel4;
    m_getPixelFn = getPixel4;
    m_clearFn    = clear4;
    m_drawTextFn = drawText4;
    m_fillRectFn = fillRect4;

    // put pixel needs write mode 2
    setPlanarRWMode(0,2);

    setStdVGAColorMap();
}

void GfxScreen::mode_b640x200_0Eh()
{
    setBIOSMode(0x0e);

    m_width    = 640;
    m_height   = 200;
    m_scanlines = 400;
    m_pages    = 4;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_chained  = 0;
    m_pageSize = 64000;
    m_modeName = "Mode 0Eh 640x200x16";
    m_colors   = 16;
    m_putPixelFn = putPixel4;
    m_getPixelFn = getPixel4;
    m_clearFn    = clear4;
    m_drawTextFn = drawText4;
    m_fillRectFn = fillRect4;

    // put pixel needs write mode 2
    setPlanarRWMode(0,2);

    setStdVGAColorMap();
}

void GfxScreen::mode_b640x350_0Fh()
{
    setBIOSMode(0x0f);

    m_width    = 640;
    m_height   = 350;
    m_scanlines = 350;
    m_pages    = 2;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_chained  = 0;
    m_pageSize = 112000;
    m_modeName = "Mode 0Fh 640x350 monochrome";
    m_colors   = 4;
    m_putPixelFn = putPixel4;
    m_getPixelFn = getPixel4;
    m_clearFn    = clear4;
    m_drawTextFn = drawText4;
    m_fillRectFn = fillRect4;

    // put pixel needs write mode 2
    setPlanarRWMode(0,2);

    memset(m_cval, 0, 256);
    m_cval[0] = 0;
    m_cval[1] = 1;
    m_cval[2] = 4;
    m_cval[3] = 5;

    m_cmap[c_black  ] = 0;
    m_cmap[c_blue   ] = 1;
    m_cmap[c_green  ] = 1;
    m_cmap[c_cyan   ] = 1;
    m_cmap[c_red    ] = 1;
    m_cmap[c_magenta] = 1;
    m_cmap[c_brown  ] = 1;
    m_cmap[c_lgray  ] = 3;
    m_cmap[c_dgray  ] = 1;
    m_cmap[c_lblue  ] = 3;
    m_cmap[c_lgreen ] = 3;
    m_cmap[c_lcyan  ] = 3;
    m_cmap[c_lred   ] = 3;
    m_cmap[c_pink   ] = 3;
    m_cmap[c_yellow ] = 3;
    m_cmap[c_white  ] = 3;
    for(int i=16; i<256; i++) {
        m_cmap[i] = i%4;
    }
}

void GfxScreen::mode_b640x350_10h()
{
    setBIOSMode(0x10);

    m_width    = 640;
    m_height   = 350;
    m_scanlines = 350;
    m_pages    = 2;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_chained  = 0;
    m_pageSize = 112000;
    m_modeName = "Mode 10h 640x350x16";
    m_colors   = 16;
    m_putPixelFn = putPixel4;
    m_getPixelFn = getPixel4;
    m_clearFn = clear4;
    m_drawTextFn = drawText4;
    m_fillRectFn = fillRect4;

    // put pixel needs write mode 2
    setPlanarRWMode(0,2);

    setStdVGAColorMap();
}

void GfxScreen::mode_b640x480_12h()
{
    setBIOSMode(0x12);

    m_width    = 640;
    m_height   = 480;
    m_scanlines = 480;
    m_pages    = 1;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_chained  = 0;
    m_pageSize = 153600;
    m_modeName = "Mode 12h 640x480x16";
    m_colors   = 16;
    m_putPixelFn = putPixel4;
    m_getPixelFn = getPixel4;
    m_clearFn = clear4;
    m_drawTextFn = drawText4;
    m_fillRectFn = fillRect4;

    // put pixel needs write mode 2
    setPlanarRWMode(0,2);

    setStdVGAColorMap();
}

void GfxScreen::mode_b320x200_13h()
{
    setBIOSMode(0x13);

    m_width    = 320;
    m_height   = 200;
    m_scanlines = 400;
    m_pages    = 1;
    m_lineOffset = 80;
    m_lineSize = 320;
    m_chained  = 1;
    m_pageSize = 64000;
    m_modeName = "Mode 13h 320x200x256 chain4";
    m_colors   = 256;
    m_putPixelFn = putPixel8chained;
    m_getPixelFn = getPixel8chained;
    m_clearFn   = clear8chained;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8chained;

    setStdVGAColorMap();
}

void GfxScreen::mode_t160x120()
{
    m_width   = 160;
    m_height  = 120;
    m_scanlines = 480;
    m_maxx    = 159;
    m_maxy    = 119;
    m_pages   = 13;
    m_lineOffset = 40;
    m_lineSize = 40;
    m_chained  = 0;
    m_pageSize = 19200;
    m_modeName = "160x120x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    selectVGAFreq(320, 480);

    unlockCRTC(CRTC_ADDR_COL);
    const int16_t crtc[] = {
        0x3200, // hor. total
        0x2701, // hor. display enable end
        0x2802, // blank start
        0x2003, // blank end
        0x2b04, // retrace start
        0x7005, // retrace end
        0x0d06, // vertical total
        0x3e07, // overflow register
        0x0008, // preset row scan
        0x4309, // max scan line/char heigth
        0xea10, // ver. retrace start
        0xac11, // ver. retrace end and lock
        0xdf12, // ver. display enable end
        0x1413, // offset/logical width
        0x0014, // underline location
        0xe715, // ver. blank start
        0x0616, // ver. blank end
        0xe317, // mode control
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);

    SEQ_OUT(0x01, 0x01); // Clocking Mode
    SEQ_OUT(0x03, 0x00); // Character Map Select
    SEQ_OUT(0x04, 0x06); // Memory Mode

    GCR_OUT(0x05, 0x40);
    GCR_OUT(0x06, 0x05);

    ACR_OUT_COL(0x10, 0x41);
    ACR_OUT_COL(0x11, 0x00);
    ACR_OUT_COL(0x12, 0x0f);
    ACR_OUT_COL(0x13, 0x00);
    ACR_OUT_COL(0x14, 0x00);
}

void GfxScreen::mode_t296x220()
{
    m_width    = 296;
    m_height   = 220;
    m_scanlines = 440;
    m_pages    = 4;
    m_lineOffset = 74;
    m_lineSize = 74;
    m_pageSize = 65120;
    m_modeName = "296x220x256 planar";
    m_colors   = 256;
    m_chained  = 0;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    selectVGAFreq(320, 480);

    unlockCRTC(CRTC_ADDR_COL);
    const int16_t crtc[] = {
        0x5f00, // hor. total
        0x4901, // hor. display enable end
        0x5002, // blank start
        0x8203, // blank end
        0x5304, // retrace start
        0x8005, // retrace end
        0x0d06, // vertical total
        0x3e07, // overflow register
        0x0008, // preset row scan
        0x4109, // max scan line/char heigth
        0xd710, // ver. retrace start
        0xac11, // ver. retrace end and lock
        0xb712, // ver. display enable end
        0x2513, // offset/logical width
        0x0014, // underline location
        0xe715, // ver. blank start
        0x0616, // ver. blank end
        0xe317, // mode control
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);

    SEQ_OUT(0x01, 0x01); // Clocking Mode
    SEQ_OUT(0x04, 0x06); // Memory Mode

    GCR_OUT(0x05, 0x40);
    GCR_OUT(0x06, 0x05);

    ACR_OUT_COL(0x10, 0x41);
    ACR_OUT_COL(0x13, 0x00);
}


void GfxScreen::mode_t256x256_Q()
{
    m_width    = 256;
    m_height   = 256;
    m_scanlines = 512;
    m_pages    = 1;
    m_lineOffset = 64;
    m_lineSize = 256;
    m_chained  = 1;
    m_pageSize = 65536;
    m_modeName = "Mode Q 256x256x256 chain4";
    m_colors   = 256;
    m_putPixelFn = putPixel8chained;
    m_getPixelFn = getPixel8chained;
    m_clearFn    = clear8chained;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8chained;

    setBIOSMode(0x13);

    unlockCRTC(CRTC_ADDR_COL);

    const int16_t crtc[] = {
        0x5f00, // hor. total
        0x3f01, // hor. display enable end
        0x4002, // blank start
        0x8203, // blank end
        0x4a04, // retrace start
        //0x4e04, // retrace start
        0x9a05, // retrace end
        0x2306, // vertical total
        0xb207, // overflow register
        0x0008, // preset row scan
        0x6109, // max scan line/char heigth
        0x0a10, // ver. retrace start
        0xac11, // ver. retrace end
        0xff12, // ver. display enable end
        0x2013, // offset/logical width
        0x4014, // underline location
        0x0715, // ver. blank start
        0x1a16, // ver. blank end
        //0x1716, // ver. blank end
        0xa317, // mode control
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);

    SEQ_OUT(0x01,0x01); // clock mode register
    SEQ_OUT(0x04,0x0e); // memory mode register
    GCR_OUT(0x05,0x40); // mode register
    GCR_OUT(0x06,0x05); // misc. register
    ACR_OUT_COL(0x10,0x41); // mode control

    setStdVGAColorMap();
}

void GfxScreen::mode_t320x200_Y()
{
    m_width    = 320;
    m_height   = 200;
    m_scanlines = 400;
    m_pages    = 4;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_pageSize = 64000;
    m_chained  = 0;
    m_modeName = "Mode Y 320x200x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    // Turn off Chain-4
    SEQ_OUT(0x04,0x06);

    // Turn off word mode
    CRTC_OUT_COL(0x17,0xe3);

    // Turn off doubleword mode
    CRTC_OUT_COL(0x14,0x00);
}

void GfxScreen::mode_t320x240_X()
{
    m_width    = 320;
    m_height   = 240;
    m_scanlines = 480;
    m_pages    = 3;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_pageSize = 76800;
    m_chained  = 0;
    m_modeName = "Mode X 320x240x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);    // start from mode 13h

    SEQ_OUT(0x04,0x06);   // disable chain4

    selectVGAFreq(320, 480);

    unlockCRTC(CRTC_ADDR_COL);

    // reprogram the crtc
    const int16_t crtc[] = {
        0x0d06,  // vertical total
        0x3e07,  // overflow (bit 8 of vertical counts)
        0x4109,  // cell height (2 to double-scan)
        0xea10,  // v sync start
        0xac11,  // v sync end and protect cr0-cr7
        0xdf12,  // vertical displayed
        0x0014,  // turn off dword mode
        0xe715,  // v blank start
        0x0616,  // v blank end
        0xe317,  // turn on byte mode
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);
}

void GfxScreen::mode_t320x400()
{
    m_width    = 320;
    m_height   = 400;
    m_scanlines = 400;
    m_pages    = 2;
    m_lineOffset = 80;
    m_lineSize = 80;
    m_pageSize = 128000;
    m_chained  = 0;
    m_modeName = "320x400x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    // Turn off the Chain-4 bit in SEQ #4
    SEQ_OUT(0x04,0x06);

    // Turn off word mode, by setting the Mode Control register
    // of the CRTC #17
    CRTC_OUT_COL(0x17,0xe3);

    // Turn off doubleword mode, by setting CRTC #14
    CRTC_OUT_COL(0x14,0x00);

    // Set MSL to 0 in the maximum scan line register.
    // This action turns 320x200 mode 13 into 320x400 mode 13+
    CRTC_OUT_COL(0x09,0x40);
}

void GfxScreen::mode_t360x270()
{
    m_width    = 360;
    m_height   = 270;
    m_scanlines = 540;
    m_pages    = 2;
    m_lineOffset = 90;
    m_lineSize = 90;
    m_pageSize = 97200;
    m_chained  = 0;
    m_modeName = "360x270x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    selectVGAFreq(360,480);

    unlockCRTC(CRTC_ADDR_COL);
    const int16_t crtc[] = {
        0x6b00, // hor. total
        0x5901, // hor. display enable end
        0x5a02, // blank start
        0x8e03, // blank end
        0x5e04, // retrace start
        0x8a05, // retrace end
        0x3006, // vertical total
        0xf007, // overflow register
        0x0008, // preset row scan
        0x6109, // max scan line/char heigth
        0x2010, // ver. retrace start
        0xa911, // ver. retrace end and lock
        0x1b12, // ver. display enable end
        0x2d13, // offset/logical width
        0x0014, // underline location
        0x1f15, // ver. blank start
        0x2f16, // ver. blank end
        0xe317, // mode control
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);

    SEQ_OUT(0x01,0x01);
    SEQ_OUT(0x04,0x06);
    GCR_OUT(0x05,0x40);
    GCR_OUT(0x06,0x05);
    ACR_OUT_COL(0x10,0x41);
    ACR_OUT_COL(0x13,0x00);
}

void GfxScreen::mode_t360x360()
{
    m_width    = 360;
    m_height   = 360;
    m_scanlines = 360;
    m_pages    = 2;
    m_lineOffset = 90;
    m_lineSize = 90;
    m_pageSize = 129600;
    m_chained  = 0;
    m_modeName = "360x360x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    selectVGAFreq(360, 400);

    unlockCRTC(CRTC_ADDR_COL);
    const int16_t crtc[] = {
        0x6b00, // hor. total
        0x5901, // hor. display enable end
        0x5a02, // blank start
        0x8e03, // blank end
        0x5e04, // retrace start
        0x8a05, // retrace end
        0xbf06, // vertical total
        0x1f07, // overflow register
        0x0008, // preset row scan
        0x4009, // max scan line/char heigth
        0x8810, // ver. retrace start
        0x8511, // ver. retrace end and lock
        0x6712, // ver. display enable end
        0x2d13, // offset/logical width
        0x0014, // underline location
        0x6d15, // ver. blank start
        0xba16, // ver. blank end
        0xe317, // mode control
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);

    SEQ_OUT(0x01,0x01);
    SEQ_OUT(0x04,0x06);
    GCR_OUT(0x05,0x40);
    GCR_OUT(0x06,0x05);
    ACR_OUT_COL(0x10,0x41);
    ACR_OUT_COL(0x13,0x00);
}

void GfxScreen::mode_t360x480()
{
    m_width    = 360;
    m_height   = 480;
    m_scanlines = 480;
    m_pages    = 1;
    m_lineOffset = 90;
    m_lineSize = 90;
    m_pageSize = 172800;
    m_chained  = 0;
    m_modeName = "360x480x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    //setBIOSMode(0x12);
    setBIOSMode(0x13);

    SEQ_OUT(0x04,0x06);   // disable chain4

    selectVGAFreq(360, 480);

    unlockCRTC(CRTC_ADDR_COL);

    // reprogram the crtc
    const int16_t crtc[] = {
        0x6b00,  // horz total
        0x5901,  // horz displayed
        0x5a02,  // start horz blanking
        0x8e03,  // end horz blanking
        0x5e04,  // start h sync
        0x8a05,  // end h sync
        0x0d06,  // vertical total
        0x3e07,  // overflow
        0x4009,  // cell height
        0xea10,  // v sync start
        0xac11,  // v sync end and protect cr0-cr7
        0xdf12,  // vertical displayed
        0x2d13,  // offset
        0x0014,  // turn off dword mode
        0xe715,  // v blank start
        0x0616,  // v blank end
        0xe317,  // turn on byte mode
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);
}

void GfxScreen::mode_t400x300()
{
    m_width    = 400;
    m_height   = 300;
    m_scanlines = 300;
    m_pages    = 2;
    m_lineOffset = 100;
    m_lineSize = 100;
    m_pageSize = 120000;
    m_chained  = 0;
    m_modeName = "400x300x256 planar";
    m_colors   = 256;
    m_putPixelFn = putPixel8;
    m_getPixelFn = getPixel8;
    m_clearFn    = clear8;
    m_drawTextFn = drawText8;
    m_fillRectFn = fillRect8;

    setStdVGAColorMap();

    setBIOSMode(0x13);

    selectVGAFreq(720, 480);

    unlockCRTC(CRTC_ADDR_COL);
    const int16_t crtc[] = {
        0x7100, // hor. total
        0x6301, // hor. display enable end
        0x6402, // blank start
        0x9203, // blank end
        0x6704, // retrace start
        0x8205, // retrace end
        0x4606, // vertical total
        0x1f07, // overflow register
        0x0008, // preset row scan
        0x4009, // max scan line/char heigth
        0x3110, // ver. retrace start
        0x8011, // ver. retrace end and lock
        0x2b12, // ver. display enable end
        0x3213, // offset/logical width
        0x0014, // underline location
        0x2f15, // ver. blank start
        0x4416, // ver. blank end
        0xe317, // mode control
        -1
    };
    setVGARegisters(CRTC_ADDR_COL, &crtc[0]);

    SEQ_OUT(0x01,0x01);
    SEQ_OUT(0x02,0x0f);
    SEQ_OUT(0x04,0x06);
    GCR_OUT(0x05,0x40);
    GCR_OUT(0x06,0x05);
    ACR_OUT_COL(0x10,0x41);
    ACR_OUT_COL(0x13,0x00);
}