/* * vdc-draw.c - Rendering for the MOS 8563 (VDC) emulation. * * Written by * Andreas Boose * Ettore Perazzoli * Markus Brenner * * This file is part of VICE, the Versatile Commodore Emulator. * See README for copyright notice. * * 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. * */ #include "vice.h" #include #include #include "raster-cache-const.h" #include "raster-cache-fill.h" #include "raster-cache.h" #include "raster-modes.h" #include "types.h" #include "vdc-draw.h" #include "vdc-mem.h" #include "vdc-resources.h" #include "vdc.h" #include "vdctypes.h" /* The following tables are used to speed up the drawing. We do not use multi-dimensional arrays as we can optimize better this way... */ /* foreground(4) | background(4) | nibble(4) -> 4 pixels. */ static uint32_t hr_table[16 * 16 * 16]; /* foreground(4) | background(4) | nibble(4) -> 8 pixels (double width) pdl table is the low (right) nibble into 4 bytes, pdh the high (left) */ static uint32_t pdl_table[16 * 16 * 16]; static uint32_t pdh_table[16 * 16 * 16]; /* solid cursor (no blink), no cursor, 1/16 refresh blink, 1/32 refresh blink */ static const uint8_t crsrblink[4] = { 0x01, 0x00, 0x08, 0x10 }; /* bit mask used for register 22, to determine the number of pixels in a char actually displayed */ static const uint8_t mask[16] = { 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; /* Tables to help with semigraphics mode, which extends the rightmost active bit across the rest of the character and into any inter character gap */ static const uint8_t semigfxtest[16] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const uint8_t semigfxmask[16] = { 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const uint8_t displayedpixmask[17] = { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; static const int8_t displayedwidth[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 2, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 2, 3, 4, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 2, 3, 4, 5, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 1, 2, 3, 4, 5, 6, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1, 2, 3, 4, 5, 6, 7, 0, 8, 8, 8, 8, 8, 8, 8, 8, 2, 3, 4, 5, 6, 7, 8, 0, 1, 8, 8, 8, 8, 8, 8, 8, 3, 4, 5, 6, 7, 8, 8, 0, 1, 2, 8, 8, 8, 8, 8, 8, 4, 5, 6, 7, 8, 8, 8, 0, 1, 2, 3, 8, 8, 8, 8, 8, 5, 6, 7, 8, 8, 8, 8, 0, 1, 2, 3, 4, 8, 8, 8, 8, 6, 7, 8, 8, 8, 8, 8, 0, 1, 2, 3, 4, 5, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 0, 1, 2, 3, 4, 5, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8 }; static const uint8_t semigfxtype[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0,0xFF, 0, 0, 0, 0, 0, 0, 0, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0, 0,0xFF,0xFF, 0, 0, 0, 0, 0, 0, 0xFF,0xFF,0xFF,0xFF,0xFF, 0, 0, 0,0xFF,0xFF,0xFF, 0, 0, 0, 0, 0, 0xFF,0xFF,0xFF,0xFF, 0, 0, 0, 0,0xFF,0xFF,0xFF,0xFF, 0, 0, 0, 0, 0xFF,0xFF,0xFF, 0, 0, 0, 0, 0,0xFF,0xFF,0xFF,0xFF,0xFF, 0, 0, 0, 0xFF,0xFF, 0, 0, 0, 0, 0, 0,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0, 0, 0xFF, 0, 0, 0, 0, 0, 0, 0,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF }; static unsigned int dmask; /* used to mask off bits in the rendered character, if for example we are only showing 4pixels dmask=0xF0 */ static unsigned int d2mask; /* used to mask off bits in the intercharacter gap, if there is one, so that we only display the 'correct' number of pixels */ static unsigned int semi_gfx_test; /* a combo flag & bitmask, if 0 there is no semi-graphics effect. >0 it's the bit mask to check against, e.g. 0x08 for bit 3 */ static unsigned int semi_gfx_mask; /* used to mask 'on' the remainder of the character, e.g. for semi_gfx_test 0x08, semi_gfx_mask= 0x07 to mask on bits 0-2 inclusive */ static unsigned int semi_gfx_type; /* 0 = semi-graphics does not extend through intercharacter gap, 0xFF = it does */ /* These functions draw the background from `start_pixel' to `end_pixel'. */ /* static void draw_std_background(unsigned int start_pixel, unsigned int end_pixel) { memset(vdc.raster.draw_buffer_ptr + start_pixel, vdc.raster.idle_background_color, end_pixel - start_pixel + 1); } */ /* Initialize the drawing tables. */ static void init_drawing_tables(void) { uint32_t i; unsigned int f, b; for (i = 0; i <= 0xf; i++) { for (f = 0; f <= 0xf; f++) { for (b = 0; b <= 0xf; b++) { uint8_t fp, bp; uint8_t *p; int offset; fp = f; bp = b; offset = (f << 8) | (b << 4) | i; p = (uint8_t *)(hr_table + offset); *p = i & 0x8 ? fp : bp; *(p + 1) = i & 0x4 ? fp : bp; *(p + 2) = i & 0x2 ? fp : bp; *(p + 3) = i & 0x1 ? fp : bp; p = (uint8_t *)(pdh_table + offset); *p = i & 0x8 ? fp : bp; *(p + 1) = i & 0x8 ? fp : bp; *(p + 2) = i & 0x4 ? fp : bp; *(p + 3) = i & 0x4 ? fp : bp; p = (uint8_t *)(pdl_table + offset); *p = i & 0x2 ? fp : bp; *(p + 1) = i & 0x2 ? fp : bp; *(p + 2) = i & 0x1 ? fp : bp; *(p + 3) = i & 0x1 ? fp : bp; } } } } /* Calculate the displayed character width, and bit-masks for the character byte (d) & inter-character gap byte (d2) */ /* Various special cases here to cover weird observed behaviour */ static void calculate_draw_masks(void) { /* For the renderer to work we need to set shared variables: dmask - used to mask off bits in the rendered character, if for example we are only showing 4pixels dmask=0xF0 d2mask - used to mask off bits in the intercharacter gap, if there is one, so that we only display the 'correct' number of pixels semi_gfx_test - a combo flag & bitmask, if 0 there is no semi-graphics effect. >0 it's the bit mask to check against, e.g. 0x08 for bit 3 semi_gfx_mask - used to mask 'on' the remainder of the character, e.g. for semi_gfx_test 0x08, semi_gfx_mask= 0x07 to mask on bits 0-2 inclusive semi_gfx_type - flag/mask for the intercharacter gap, 0 = semi-graphics does not extend through intercharacter gap, 0xFF = it does i, displayedpixels is not required, just temp values used in calculations */ unsigned int i; int displayedpixels; if (vdc.regs[25] & 0x10) { /* double pixel / 40 column mode */ /* half the values for 40column mode are 0x10 further down, so compensate the table lookup */ if (!(vdc.regs[22] & 0x08) && (vdc.regs[22] >= 0x10)) { i = vdc.regs[22] - 0x10; } else { i = vdc.regs[22]; } displayedpixels = displayedwidth[i]; if (displayedpixels < 0) { /* invalid, i.e displays nothing but black. we don't support this quite yet so just set the displayed width to 0 */ displayedpixels = 0; dmask = 0x00; /* show no pixels */ semi_gfx_test = 0; /* always fail, so don't extend through any gap */ } else { if ((vdc.regs[25] & 0x20 ) /* Semi-graphics mode */ || (((vdc.regs[22] >> 4) & 0x0F) == (vdc.regs[22] & 0x0F))) { /* extra weirdness - in 40col mode if displayed width = total width, semigfx is enabled either way */ if (((vdc.regs[22] >> 4) & 0x0F) == (vdc.regs[22] & 0x0F)) { /* in extra weirdness the width is always at least 1 */ if ((vdc.regs[22] & 0x0F) <= 8 ) { displayedpixels = 1; } } else if (displayedpixels == 0) { displayedpixels = 8; /* there is no width 0 in semigfx mode, so override it if it happens, e.g. R22:0-3 = 7 */ } semi_gfx_test = semigfxtest[displayedpixels - 1]; /* .. set it as a mask to check the appropriate bit */ semi_gfx_type = semigfxtype[i]; /* 0 if semigfx mode is active but doesn't extend through intercharacter gap. 0xFF otherwise, doubles as a mask */ } else { /* regular text mode */ semi_gfx_test = 0; /* always fail, so don't extend through any gap */ } dmask = displayedpixmask[displayedpixels]; } if ((vdc.regs[22] >> 4) > 8) { /* if there is inter-char gap then... */ d2mask = displayedpixmask[(vdc.regs[22] >> 4) - 6]; /* ..calculate the mask to apply to display the correct # of pixels but no more */ } else { d2mask = 0x00; /* this shouldn't matter as it shouldn't try to render the interchar gap because there isn't one, but setting it to be thorough */ } } else { /* normal / 80 column mode */ displayedpixels = displayedwidth[vdc.regs[22]]; if (displayedpixels < 0) { /* invalid, i.e displays nothing but black. we don't support this quite yet so just set the displayed width to 0 */ displayedpixels = 0; dmask = 0x00; /* show no pixels */ semi_gfx_test = 0; /* always fail, so don't extend through any gap */ } else { if (vdc.regs[25] & 0x20) { /* Semi-graphics mode */ if (displayedpixels == 0) { displayedpixels = 8; /* there is no width 0 in semigfx mode, so override it if it happens, e.g. R22:0-3 = 7 */ } semi_gfx_test = semigfxtest[displayedpixels - 1]; /* .. set it as a mask to check the appropriate bit */ semi_gfx_type = semigfxtype[vdc.regs[22]]; /* 0 if semigfx mode is active but doesn't extend through intercharacter gap. 0xFF otherwise, doubles as a mask */ } else { /* regular text mode */ semi_gfx_test = 0; /* always fail, so don't extend through any gap */ } dmask = displayedpixmask[displayedpixels]; } if ((vdc.regs[22] >> 4) >= 8) { /* if there is inter-char gap then... */ d2mask = displayedpixmask[(vdc.regs[22] >> 4) - 6]; /* ..calculate the mask to apply to display the correct # of pixels but no more */ } else { d2mask = 0x00; /* this shouldn't matter as it shouldn't try to render the interchar gap because there isn't one, but setting it to be thorough */ } } semi_gfx_mask = semigfxmask[displayedpixels - 1]; /* mask for any extra pixels to turn on if semigrfx mode is active */ } /*-----------------------------------------------------------------------*/ inline static uint8_t get_attr_char_data(uint8_t c, uint8_t a, int l, uint8_t *char_mem, int bytes_per_char, int blink, int revers, int curpos, int index) /* c = character, a = attributes, l = line of char required , char_mem = pointer to character memory bytes_per_char = number of bytes per char definition blink / revers - these don't seem to be used curpos = where in the screen memory the cursor is index = where in the screen memory we are, to check against the cursor */ { uint8_t data; if (a & VDC_ALTCHARSET_ATTR) { /* swich to alternate charset if appropriate attribute bit set */ char_mem += 0x100 * vdc.bytes_per_char; /* 0x1000 or 0x2000, depending on character height */ } if (l > (signed)vdc.regs[23]) { /* Return nothing if > Vertical Character Size */ data = 0x00; } else { /* mask against r[22] - pixels per char mask */ data = char_mem[(c * bytes_per_char) + l] & mask[vdc.regs[22] & 0x0F]; } /* Pixels per char does not apply to the underline but the underline does blink, reverse and extend through inter-character spacing */ if ((l == (signed)vdc.regs[29]) && (a & VDC_UNDERLINE_ATTR)) { data = 0xFF; } if ((a & VDC_FLASH_ATTR) && (vdc.attribute_blink)) { data = 0x00; } if (vdc.regs[25] & 0x20) { /* Semi-graphics mode */ if (data & semigfxtest[vdc.regs[22] & 0x0F]) { /* if the far right pixel is on.. */ data |= semigfxmask[vdc.regs[22] & 0x0F]; /* .. mask the rest of the right hand side on */ } } if (a & VDC_REVERSE_ATTR) { /* reverse attribute set */ data ^= 0xFF; } if (vdc.regs[24] & 0x40) { /* Reverse screen bit */ data ^= 0xFF; } /* on a 80x25 text screen (2000 characters) this is only true for 1 character. */ if (curpos == index) { /* invert anything at all? */ if ((vdc.frame_counter | 1) & crsrblink[(vdc.regs[10] >> 5) & 3]) { /* invert current byte of the character? */ if ( ((l >= (vdc.regs[10] & 0x1F)) && (l < (vdc.regs[11] & 0x1F))) || ((l == (vdc.regs[10] & 0x1F)) && (l == (vdc.regs[11] & 0x1F))) || (((vdc.regs[10] & 0x1F) > (vdc.regs[11] & 0x1F)) && ((l >= (vdc.regs[10] & 0x1F)) || (l < (vdc.regs[11] & 0x1F)))) ) { /* The VDC cursor reverses the char */ data ^= 0xFF; } } } return data; } inline static int cache_data_fill_attr_text(uint8_t *dest, const uint8_t *src, uint8_t *attr, uint8_t *char_mem, int bytes_per_char, unsigned int length, int l, unsigned int *xs, unsigned int *xe, int no_check, int blink, int revers, int curpos) { unsigned int i; /* Fill (*dest) with (length) bytes of character data from (*src) - VDC screen memory - using attributes (*attr) - VDC attribute memory -, at vertical character reference (l) from VDC memory character set (*char_mem) */ if (no_check) { /* fill *dest regardless of any changes */ /* xs/xe seem to the start & end of any data that was updated/filled */ *xs = 0; *xe = length - 1; for (i = 0; i < length; i++, src++, attr++) { dest[i] = get_attr_char_data(src[0], attr[0], l, char_mem, bytes_per_char, blink, revers, curpos, i); } /* dest data was updated */ return 1; } else { uint8_t b; /* compare destination to data to look for any differences */ for (i = 0; i < length; i++, src++, attr++) { if (dest[i] != get_attr_char_data(src[0], attr[0], l, char_mem, bytes_per_char, blink, revers, curpos, i)) { break; } } if (i < length) { /* we found a difference */ *xs = *xe = i; /* xs/xe set start/end address for modified data */ /* compare & update *dest, adjusting *xe if needed */ for (; i < length; i++, src++, attr++) { b = get_attr_char_data(src[0], attr[0], l, char_mem, bytes_per_char, blink, revers, curpos, i); if (dest[i] != b) { dest[i] = b; *xe = i; } } /* dest data was updated */ return 1; } else { /* nothing changed from last run */ return 0; } } } inline static int cache_data_fill_attr_text_const(uint8_t *dest, const uint8_t *src, uint8_t attr, uint8_t *char_mem, int bytes_per_char, unsigned int length, int l, unsigned int *xs, unsigned int *xe, int no_check, int blink, int revers, int curpos) { unsigned int i; /* This route is basically identical to cache_data_fill_attr_text(), except that "attr" is a constant value rather than a pointer into VDC attribute memory, so every character byte has the same attributes. */ if (no_check) { /* fill *dest regardless of any changes */ *xs = 0; *xe = length - 1; for (i = 0; i < length; i++, src++) { dest[i] = get_attr_char_data(src[0], attr, l, char_mem, bytes_per_char, blink, revers, curpos, i); } /* dest data was updated */ return 1; } else { uint8_t b; for (i = 0; i < length; i++, src++) { if (dest[i] != get_attr_char_data(src[0], attr, l, char_mem, bytes_per_char, blink, revers, curpos, i)) { break; } } if (i < length) { /* we found a difference */ *xs = *xe = i; /* xs/xe set start/end address for modified data */ /* compare & update *dest, adjusting *xe if needed */ for (; i < length; i++, src++) { b = get_attr_char_data(src[0], attr, l, char_mem, bytes_per_char, blink, revers, curpos, i); if (dest[i] != b) { dest[i] = b; *xe = i; } } /* dest data was updated */ return 1; } else { /* nothing changed from last run */ return 0; } } } inline static int cache_data_fill(uint8_t *dest, const uint8_t *src, unsigned int length, int src_step, unsigned int *xs, unsigned int *xe, int no_check, int reverse) /* Bitmap mode - fill (*dest) with (length) bytes of bitmap data from (*src) */ { unsigned int i; if (no_check) { *xs = 0; *xe = length - 1; for (i = 0; i < length; i++, src += src_step) { /* vdc memory is a simple linear bitmap so copy it directly, reversing if needed */ dest[i] = src[0] ^ reverse; } return 1; } else { for (i = 0; i < length && dest[i] == (src[0] ^ reverse); i++, src += src_step) { /* do nothing */ } if (i < length) { *xs = *xe = i; for (; i < length; i++, src += src_step) { if (dest[i] != (src[0] ^ reverse)) { dest[i] = src[0] ^ reverse; *xe = i; } } return 1; } else { return 0; } } } /*-----------------------------------------------------------------------*/ static int get_std_text(raster_cache_t *cache, unsigned int *xs, unsigned int *xe, int rr) /* aka raster_modes_fill_cache() in raster */ { /* fill the line cache in text mode. The VDC combines text mode from a) the video RAM in conjunction with b) the character RAM c) the attribute RAM */ /* r=return value, cursor_pos=the cursor position in screen memory so that it can be drawn correctly */ int r, cursor_pos; cursor_pos = ( vdc.crsrpos & vdc.vdc_address_mask ) - vdc.screen_adr - vdc.mem_counter; if (vdc.regs[25] & 0x40) { /* attribute mode */ /* get the character definition data, with any attributes applied from attribute memory, into the raster cache foreground_data */ r = cache_data_fill_attr_text(cache->foreground_data, vdc.ram + vdc.screen_adr + vdc.mem_counter, vdc.ram + vdc.attribute_adr + vdc.mem_counter, vdc.ram + (vdc.chargen_adr & vdc.vdc_address_mask), vdc.bytes_per_char, vdc.screen_text_cols, vdc.raster.ycounter, xs, xe, rr, 0, 0, cursor_pos); /* fill the raster cache color_data_1 with the attributes from vdc memory */ r |= raster_cache_data_fill(cache->color_data_1, vdc.ram + vdc.attribute_adr + vdc.mem_counter, vdc.screen_text_cols, xs, xe, rr); } else { /* monochrome mode - attributes from register 26 */ /* get the character definition data, fixed attributes (only background colour, which doesn't actually do anything to these functions!) */ r = cache_data_fill_attr_text_const(cache->foreground_data, vdc.ram + vdc.screen_adr + vdc.mem_counter, (uint8_t)(vdc.regs[26] & 0x0f), vdc.ram + (vdc.chargen_adr & vdc.vdc_address_mask), vdc.bytes_per_char, (int)vdc.screen_text_cols, vdc.raster.ycounter, xs, xe, rr, 0, 0, cursor_pos); /* fill the raster cache color_data_1 with the foreground colour from vdc reg 26 */ r |= raster_cache_data_fill_const(cache->color_data_1, (uint8_t)(vdc.regs[26] >> 4), (int)vdc.screen_text_cols, xs, xe, rr); } return r; } static void draw_std_text_cached(raster_cache_t *cache, unsigned int xs, unsigned int xe) /* aka raster_modes_draw_line_cached() in raster */ { uint8_t *p, *q; uint32_t *table_ptr, *pdl_ptr, *pdh_ptr; unsigned int i; int icsi = -1; /* Inter Character Spacing Index - used as a combo flag/index as to whether there is any intercharacter gap to render */ if (vdc.regs[25] & 0x10) { /* double pixel a.k.a 40column mode */ if (vdc.charwidth > 16) { /* Is there inter character spacing to render? */ icsi = vdc.charwidth / 2 - 8; } } else { /* 80 column mode */ if (vdc.charwidth > 8) { /* Is there inter character spacing to render? */ icsi = vdc.charwidth - 8; } } p = vdc.raster.draw_buffer_ptr + vdc.border_width + ((vdc.regs[25] & 0x10) ? 2 : 0) + vdc.xsmooth * ((vdc.regs[25] & 0x10) ? 2 : 1) - (vdc.regs[22] >> 4) * ((vdc.regs[25] & 0x10) ? 2 : 1) + xs * vdc.charwidth; table_ptr = hr_table + ((vdc.regs[26] & 0x0f) << 4); pdl_ptr = pdl_table + ((vdc.regs[26] & 0x0f) << 4); pdh_ptr = pdh_table + ((vdc.regs[26] & 0x0f) << 4); if (vdc.regs[25] & 0x10) { /* double pixel mode */ for (i = xs; i <= (unsigned int)xe; i++, p += vdc.charwidth) { uint32_t *pdwl = pdl_ptr + ((cache->color_data_1[i] & 0x0f) << 8); uint32_t *pdwh = pdh_ptr + ((cache->color_data_1[i] & 0x0f) << 8); int d = cache->foreground_data[i]; *((uint32_t *)p) = *(pdwh + (d >> 4)); *((uint32_t *)p + 1) = *(pdwl + (d >> 4)); *((uint32_t *)p + 2) = *(pdwh + (d & 0x0f)); *((uint32_t *)p + 3) = *(pdwl + (d & 0x0f)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 16; if ((vdc.regs[25] & 0x20) && (d & semigfxtest[vdc.regs[22] & 0x0F])) { /* If semi-graphics mode and the rightmost active bit is set */ d = mask[icsi]; /* .. figure out how big it is based on the width of the gap */ } else { /* otherwise just draw the background */ d = 0; } if (cache->color_data_1[i] & VDC_REVERSE_ATTR) { /* reverse if the reverse attribute is set for this char */ d ^= 0xff; } if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* whole screen reverse */ d ^= 0xff; } *((uint32_t *)q) = *(pdwh + (d >> 4)); *((uint32_t *)q + 1) = *(pdwl + (d >> 4)); *((uint32_t *)q + 2) = *(pdwh + (d & 0x0f)); *((uint32_t *)q + 3) = *(pdwl + (d & 0x0f)); } } } else { /* normal text size */ for (i = xs; i <= (unsigned int)xe; i++, p += vdc.charwidth) { uint32_t *ptr = table_ptr + ((cache->color_data_1[i] & 0x0f) << 8); int d = cache->foreground_data[i]; *((uint32_t *)p) = *(ptr + (d >> 4)); *((uint32_t *)p + 1) = *(ptr + (d & 0x0f)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 8; if ((vdc.regs[25] & 0x20) && (d & semigfxtest[vdc.regs[22] & 0x0F])) { /* If semi-graphics mode and the rightmost active bit is set */ d = mask[icsi]; /* .. figure out how big it is based on the width of the gap */ } else { /* otherwise just draw the background */ d = 0; } if (cache->color_data_1[i] & VDC_REVERSE_ATTR) { /* reverse if the reverse attribute is set for this char */ d ^= 0xff; } if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* whole screen reverse */ d ^= 0xff; } *((uint32_t *)q) = *(ptr + (d >> 4)); *((uint32_t *)q + 1) = *(ptr + (d & 0x0f)); } } } /* fill the last few pixels of the display with bg colour if smooth scroll != 0 - if needed */ if (i == vdc.screen_text_cols) { for (i = vdc.xsmooth; i < (unsigned)(vdc.regs[22] >> 4); i++, p++) { *p = (vdc.regs[26] & 0x0f); } } } static void draw_std_text(void) /* raster_modes_draw_line() in raster - draw text mode when cache is not used This draws one raster line of text directly into the raster buffer (vdc.raster.draw_buffer_ptr), which is one byte per pixel, based on the VDC screen, attr(ibute) and char(set) ram (which are one byte per 8 pixels */ { uint8_t *p, *q; uint32_t *table_ptr, *pdl_ptr, *pdh_ptr, char_index; uint8_t *attr_ptr, *screen_ptr; unsigned int i, d, d2; unsigned int cpos = 0xFFFF; int icsi = -1; /* Inter Character Spacing Index - used as a combo flag/index as to whether there is any intercharacter gap to render */ cpos = ( vdc.crsrpos & vdc.vdc_address_mask ) - vdc.screen_adr - vdc.mem_counter; if(vdc.regs[25] & 0x10) { /* double pixel a.k.a 40column mode */ if (vdc.charwidth > 16) { /* Is there inter character spacing to render? */ icsi = vdc.charwidth / 2 - 8; } } else { /* 80 column mode */ if (vdc.charwidth > 8) { /* Is there inter character spacing to render? */ icsi = vdc.charwidth - 8; } } p = vdc.raster.draw_buffer_ptr + vdc.border_width + ((vdc.regs[25] & 0x10) ? 2 : 0) + vdc.xsmooth * ((vdc.regs[25] & 0x10) ? 2 : 1) - (vdc.regs[22] >> 4) * ((vdc.regs[25] & 0x10) ? 2 : 1); /* attr_ptr = vdc.ram + ((vdc.attribute_adr + vdc.mem_counter) & vdc.vdc_address_mask);*/ /* keep pre-buffer pointer set-up for testing */ attr_ptr = &vdc.attrbuf[vdc.attrbufdraw]; /* screen_ptr = vdc.ram + ((vdc.screen_adr + vdc.mem_counter) & vdc.vdc_address_mask);*/ /* as above */ screen_ptr = &vdc.scrnbuf[vdc.attrbufdraw]; char_index = (vdc.chargen_adr & vdc.vdc_address_mask) + vdc.raster.ycounter; calculate_draw_masks(); /* Now actually render everything */ if (vdc.regs[25] & 0x40) { /* Attribute mode - background colour from regs[26] but foreground from attribute ram */ table_ptr = hr_table + ((vdc.regs[26] & 0x0F) << 4); /* regs[26] & 0xF is the background colour */ pdl_ptr = pdl_table + ((vdc.regs[26] & 0x0F) << 4); pdh_ptr = pdh_table + ((vdc.regs[26] & 0x0F) << 4); for (i = 0; i < vdc.screen_text_cols; i++, p += vdc.charwidth) { if (vdc.raster.ycounter > (signed)vdc.regs[23]) { /* Return nothing if > Vertical Character Size */ d = 0x00; } else { d = vdc_ram_read(char_index + ((*(attr_ptr + i) & VDC_ALTCHARSET_ATTR) ? 0x100 * vdc.bytes_per_char : 0) /* the offset to the alternate character set is either 0x1000 or 0x2000, depending on the character size (16 or 32) */ + (*(screen_ptr + i) * vdc.bytes_per_char)); } d &= dmask; /* mask off to active pixels only */ d2 = 0x00; /* set underline if the underline attrib is set for this char */ /* Pixels per char does not apply to the underline but the underline does blink, reverse and extend through inter-character spacing */ if ((vdc.raster.ycounter == vdc.regs[29]) && (*(attr_ptr + i) & VDC_UNDERLINE_ATTR)) { d = 0xFF; d2 = 0xFF; } /* blink if the blink attribute is set for this char */ if (vdc.attribute_blink && (*(attr_ptr + i) & VDC_FLASH_ATTR)) { d = 0x00; d2 = 0x00; } /* Handle semi-graphics mode. Note semi_gfx_test doubles as a flag, if it's 0 this just falls through */ if (d & semi_gfx_test) { /* if the far right pixel is on.. */ d |= semi_gfx_mask; /* .. mask the rest of the right hand side on */ d2 = semi_gfx_type; /* this will get masked off later on, so we just set all (or none) inter-char pixels on for now */ } /* reverse if the reverse attribute is set for this char */ if (*(attr_ptr + i) & VDC_REVERSE_ATTR) { d ^= 0xFF; d2 ^= 0xFF; } if (cpos == i) { /* handle cursor if this is the cursor */ if ((vdc.frame_counter | 1) & crsrblink[(vdc.regs[10] >> 5) & 3]) { /* invert current byte of the character if we are within the cursor area */ if ( ((vdc.raster.ycounter >= (vdc.regs[10] & 0x1F)) && (vdc.raster.ycounter < (vdc.regs[11] & 0x1F))) || ((vdc.raster.ycounter == (vdc.regs[10] & 0x1F)) && (vdc.raster.ycounter == (vdc.regs[11] & 0x1F))) || (((vdc.regs[10] & 0x1F) > (vdc.regs[11] & 0x1F)) && ((vdc.raster.ycounter >= (vdc.regs[10] & 0x1F)) || (vdc.raster.ycounter < (vdc.regs[11] & 0x1F)))) ) { /* The VDC cursor reverses the char */ d ^= 0xFF; d2 ^= 0xFF; } } } if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* whole screen reverse */ d ^= 0xFF; d2 ^= 0xFF; } d2 &= d2mask; /* Mask off any extra "on" pixels from the inter-character gap */ /* actually render the byte into 8 bytes of colour pixels using the lookup tables */ if (vdc.regs[25] & 0x10) { /* double pixel mode */ uint32_t *pdwl = pdl_ptr + ((*(attr_ptr + i) & 0x0F) << 8); uint32_t *pdwh = pdh_ptr + ((*(attr_ptr + i) & 0x0F) << 8); *((uint32_t *)p) = *(pdwh + (d >> 4)); *((uint32_t *)p + 1) = *(pdwl + (d >> 4)); *((uint32_t *)p + 2) = *(pdwh + (d & 0x0F)); *((uint32_t *)p + 3) = *(pdwl + (d & 0x0F)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 16; *((uint32_t *)q) = *(pdwh + (d2 >> 4)); *((uint32_t *)q + 1) = *(pdwl + (d2 >> 4)); *((uint32_t *)q + 2) = *(pdwh + (d2 & 0x0F)); *((uint32_t *)q + 3) = *(pdwl + (d2 & 0x0F)); } } else { /* normal text size */ uint32_t *ptr = table_ptr + ((*(attr_ptr + i) & 0x0F) << 8); *((uint32_t *)p) = *(ptr + (d >> 4)); *((uint32_t *)p + 1) = *(ptr + (d & 0x0F)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 8; *((uint32_t *)q) = *(ptr + (d2 >> 4)); *((uint32_t *)q + 1) = *(ptr + (d2 & 0x0F)); } } } } else { /* Monochrome mode - foreground & background colours both from register 26 */ uint32_t *ptr = hr_table + (vdc.regs[26] << 4); uint32_t *pdwl = pdl_table + (vdc.regs[26] << 4); /* Pointers into the lookup tables */ uint32_t *pdwh = pdh_table + (vdc.regs[26] << 4); for (i = 0; i < vdc.screen_text_cols; i++, p += vdc.charwidth) { if (vdc.raster.ycounter > (signed)vdc.regs[23]) { /* Return nothing if > Vertical Character Size */ d = 0x00; } else { d = vdc_ram_read(char_index + (*(screen_ptr + i) * vdc.bytes_per_char)); } d &= dmask; /* mask off to active pixels only */ d2 = 0x00; /* Handle semi-graphics mode. Note semi_gfx_test doubles as a flag, if it's 0 this just falls through */ if (d & semi_gfx_test) { /* if the far right pixel is on.. */ d |= semi_gfx_mask; /* .. mask the rest of the right hand side on */ d2 = semi_gfx_type; /* this will get masked off later on, so we just set all (or none) inter-char pixels on for now */ } if (cpos == i) { /* handle cursor if this is the cursor */ if ((vdc.frame_counter | 1) & crsrblink[(vdc.regs[10] >> 5) & 3]) { /* invert current byte of the character if we are within the cursor area */ if ( ((vdc.raster.ycounter >= (vdc.regs[10] & 0x1F)) && (vdc.raster.ycounter < (vdc.regs[11] & 0x1F))) || ((vdc.raster.ycounter == (vdc.regs[10] & 0x1F)) && (vdc.raster.ycounter == (vdc.regs[11] & 0x1F))) || (((vdc.regs[10] & 0x1F) > (vdc.regs[11] & 0x1F)) && ((vdc.raster.ycounter >= (vdc.regs[10] & 0x1F)) || (vdc.raster.ycounter < (vdc.regs[11] & 0x1F)))) ) { /* The VDC cursor reverses the char */ d ^= 0xFF; d2 ^= 0xFF; } } } if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* whole screen reverse */ d ^= 0xFF; d2 ^= 0xFF; } d2 &= d2mask; /* Mask off any extra "on" pixels from the inter-character gap */ /* actually render the byte into 8 bytes of colour pixels using the lookup tables */ if (vdc.regs[25] & 0x10) { /* double pixel mode */ *((uint32_t *)p) = *(pdwh + (d >> 4)); *((uint32_t *)p + 1) = *(pdwl + (d >> 4)); *((uint32_t *)p + 2) = *(pdwh + (d & 0x0F)); *((uint32_t *)p + 3) = *(pdwl + (d & 0x0F)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 16; *((uint32_t *)q) = *(pdwh + (d2 >> 4)); *((uint32_t *)q + 1) = *(pdwl + (d2 >> 4)); *((uint32_t *)q + 2) = *(pdwh + (d2 & 0x0F)); *((uint32_t *)q + 3) = *(pdwl + (d2 & 0x0F)); } } else { /* normal text size */ *((uint32_t *)p) = *(ptr + (d >> 4)); *((uint32_t *)p + 1) = *(ptr + (d & 0x0F)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 8; *((uint32_t *)q) = *(ptr + (d2 >> 4)); *((uint32_t *)q + 1) = *(ptr + (d2 & 0x0F)); } } } } /* fill the last few pixels of the display with bg colour if smooth scroll != 0 */ for (i = vdc.xsmooth; i < (unsigned)(vdc.regs[22] >> 4); i++, p++) { *p = (vdc.regs[26] & 0x0F); } } static int get_std_bitmap(raster_cache_t *cache, unsigned int *xs, unsigned int *xe, int rr) /* aka raster_modes_fill_cache() in raster */ { /* r = return value */ int r; r = cache_data_fill(cache->foreground_data, vdc.ram + vdc.screen_adr + vdc.bitmap_counter, vdc.screen_text_cols + 1, 1, xs, xe, rr, (vdc.regs[24] & VDC_REVERSE_ATTR) ? 0xff : 0x0); if (vdc.regs[25] & 0x40) { /* attribute mode */ r |= raster_cache_data_fill(cache->color_data_1, vdc.ram + vdc.attribute_adr + vdc.mem_counter, vdc.screen_text_cols + 1, xs, xe, rr); } else { /* monochrome mode - attributes from register 26 */ r |= raster_cache_data_fill_const(cache->color_data_1, (uint8_t)(vdc.regs[26] >> 4), (int)vdc.screen_text_cols + 1, xs, xe, rr); } return r; } static void draw_std_bitmap_cached(raster_cache_t *cache, unsigned int xs, unsigned int xe) /* raster_modes_draw_line_cached() in raster */ { uint8_t *p; uint32_t *table_ptr, *pdl_ptr, *pdh_ptr; uint32_t *ptr, *pdwl, *pdwh; unsigned int i, d, j, fg, bg; p = vdc.raster.draw_buffer_ptr + vdc.border_width + ((vdc.regs[25] & 0x10) ? 2 : 0) + vdc.xsmooth * ((vdc.regs[25] & 0x10) ? 2 : 1) - (vdc.regs[22] >> 4) * ((vdc.regs[25] & 0x10) ? 2 : 1) + xs * vdc.charwidth; /* TODO: See if we even need to split these renderers between attr/mono, because the attr data is filled either way. draw_std_text_cached mode() doesn't differentiate */ if (vdc.regs[25] & 0x40) { /* attribute mode */ if (vdc.regs[25] & 0x10) { /* double pixel mode */ for (i = xs; i <= (unsigned int)xe; i++, p += vdc.charwidth) { d = cache->foreground_data[i]; pdwl = pdl_table + ((cache->color_data_1[i] & 0x0f) << 8) + (cache->color_data_1[i] & 0xf0); pdwh = pdh_table + ((cache->color_data_1[i] & 0x0f) << 8) + (cache->color_data_1[i] & 0xf0); *((uint32_t *)p) = *(pdwh + (d >> 4)); *((uint32_t *)p + 1) = *(pdwl + (d >> 4)); *((uint32_t *)p + 2) = *(pdwh + (d & 0x0f)); *((uint32_t *)p + 3) = *(pdwl + (d & 0x0f)); } } else { /* normal text size */ for (i = xs; i <= (unsigned int)xe; i++, p += vdc.charwidth) { d = cache->foreground_data[i]; table_ptr = hr_table + (cache->color_data_1[i] & 0xf0); ptr = table_ptr + ((cache->color_data_1[i] & 0x0f) << 8); *((uint32_t *)p) = *(ptr + (d >> 4)); *((uint32_t *)p + 1) = *(ptr + (d & 0x0f)); } } } else { /* monochrome mode - attributes from register 26 */ if (vdc.regs[25] & 0x10) { /* double pixel mode */ pdl_ptr = pdl_table + ((vdc.regs[26] & 0x0f) << 4); pdh_ptr = pdh_table + ((vdc.regs[26] & 0x0f) << 4); for (i = xs; i <= (unsigned int)xe; i++, p += vdc.charwidth) { d = cache->foreground_data[i]; pdwl = pdl_ptr + ((cache->color_data_1[i] & 0x0f) << 8); pdwh = pdh_ptr + ((cache->color_data_1[i] & 0x0f) << 8); *((uint32_t *)p) = *(pdwh + (d >> 4)); *((uint32_t *)p + 1) = *(pdwl + (d >> 4)); *((uint32_t *)p + 2) = *(pdwh + (d & 0x0f)); *((uint32_t *)p + 3) = *(pdwl + (d & 0x0f)); } } else { /* normal text size */ table_ptr = hr_table + ((vdc.regs[26] & 0x0f) << 4); for (i = xs; i <= (unsigned int)xe; i++, p += vdc.charwidth) { d = cache->foreground_data[i]; ptr = table_ptr + ((cache->color_data_1[i] & 0x0f) << 8); *((uint32_t *)p) = *(ptr + (d >> 4)); *((uint32_t *)p + 1) = *(ptr + (d & 0x0f)); } } } /* fill the last few pixels of the display with bg colour if xsmooth scroll != maximum */ d = cache->foreground_data[i]; if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* reverse screen bit */ d ^= 0xff; } if (vdc.regs[25] & 0x40) { /* attribute mode */ fg = cache->color_data_1[i] >> 4; bg = cache->color_data_1[i] & 0x0F; } else { /* monochrome mode - attributes from register 26 */ bg = vdc.regs[26] & 0x0F; fg = vdc.regs[26] >> 4; } for (i = vdc.xsmooth, j = 0x80; i < (unsigned)(vdc.regs[22] >> 4); i++, p++, j >>= 1) { if (d & j) { /* foreground */ *p = fg; } else { *p = bg; } } } static void draw_std_bitmap(void) /* raster_modes_draw_line() in raster - draw bitmap mode when cache is not used See draw_std_text(), this is for bitmap mode. */ { uint8_t *p, *q; uint8_t *attr_ptr; unsigned int i, d, d2, j, fg, bg, bitmap_index; int icsi = -1; /* Inter Character Spacing Index - used as a combo flag/index as to whether there is any intercharacter gap to render */ if(vdc.regs[25] & 0x10) { /* double pixel a.k.a 40column mode */ if (vdc.charwidth > 16) { /* Is there inter character spacing to render? */ icsi = vdc.charwidth / 2 - 8; } } else { /* 80 column mode */ if (vdc.charwidth > 8) { /* Is there inter character spacing to render? */ icsi = vdc.charwidth - 8; } } p = vdc.raster.draw_buffer_ptr + vdc.border_width + ((vdc.regs[25] & 0x10) ? 2 : 0) + vdc.xsmooth * ((vdc.regs[25] & 0x10) ? 2 : 1) - (vdc.regs[22] >> 4) * ((vdc.regs[25] & 0x10) ? 2 : 1); /*attr_ptr = vdc.ram + ((vdc.attribute_adr + vdc.mem_counter) & vdc.vdc_address_mask);*/ /* keep pre-buffer pointer set-up for testing */ attr_ptr = &vdc.attrbuf[vdc.attrbufdraw]; bitmap_index = vdc.screen_adr + vdc.bitmap_counter; calculate_draw_masks(); for (i = 0; i < vdc.mem_counter_inc; i++, p += vdc.charwidth) { uint32_t *ptr, *pdwl, *pdwh; if (vdc.regs[25] & 0x40) { /* attribute mode */ ptr = hr_table + (*(attr_ptr + i) & 0xf0) + ((*(attr_ptr + i) & 0x0f) << 8); pdwl = pdl_table + (*(attr_ptr + i) & 0xf0) + ((*(attr_ptr + i) & 0x0f) << 8); pdwh = pdh_table + (*(attr_ptr + i) & 0xf0) + ((*(attr_ptr + i) & 0x0f) << 8); } else { /* monochrome mode - attributes from register 26 */ ptr = hr_table + (vdc.regs[26] << 4); pdwl = pdl_table + (vdc.regs[26] << 4); /* Pointers into the lookup tables */ pdwh = pdh_table + (vdc.regs[26] << 4); } if (vdc.raster.ycounter > (signed)vdc.regs[23]) { /* Return nothing if > Vertical Character Size */ d = 0x00; } else { d = vdc_ram_read(bitmap_index + i); /* grab the data byte from the bitmap */ } d &= dmask; /* mask off to active pixels only */ d2 = 0x00; /* Handle semi-graphics mode. Note semi_gfx_test doubles as a flag, if it's 0 this just falls through */ if (d & semi_gfx_test) { /* if the far right pixel is on.. */ d |= semi_gfx_mask; /* .. mask the rest of the right hand side on */ d2 = semi_gfx_type; /* this will get masked off later on, so we just set all (or none) inter-char pixels on for now */ } if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* whole screen reverse */ d ^= 0xff; d2 ^= 0xFF; } d2 &= d2mask; /* Mask off any extra "on" pixels from the inter-character gap */ /* actually render the byte into 8 bytes of colour pixels using the lookup tables */ if (vdc.regs[25] & 0x10) { /* double pixel mode */ *((uint32_t *)p) = *(pdwh + (d >> 4)); *((uint32_t *)p + 1) = *(pdwl + (d >> 4)); *((uint32_t *)p + 2) = *(pdwh + (d & 0x0f)); *((uint32_t *)p + 3) = *(pdwl + (d & 0x0f)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 16; *((uint32_t *)q) = *(pdwh + (d2 >> 4)); *((uint32_t *)q + 1) = *(pdwl + (d2 >> 4)); *((uint32_t *)q + 2) = *(pdwh + (d2 & 0x0F)); *((uint32_t *)q + 3) = *(pdwl + (d2 & 0x0F)); } } else { /* normal pixel size */ *((uint32_t *)p) = *(ptr + (d >> 4)); *((uint32_t *)p + 1) = *(ptr + (d & 0x0f)); if (icsi >= 0) { /* if there's inter character spacing, then render it */ q = p + 8; *((uint32_t *)q) = *(ptr + (d2 >> 4)); *((uint32_t *)q + 1) = *(ptr + (d2 & 0x0F)); } } } /* fill the last few pixels of the display with bg colour if xsmooth scroll != maximum */ d = vdc_ram_read(bitmap_index + i); /* grab the data byte from the bitmap */ if (vdc.regs[24] & VDC_REVERSE_ATTR) { /* reverse screen bit */ d ^= 0xff; } if (vdc.regs[25] & 0x40) { /* attribute mode */ fg = *(attr_ptr + i) >> 4; bg = *(attr_ptr + i) & 0x0F; } else { /* monochrome mode - attributes from register 26 */ fg = vdc.regs[26] >> 4; bg = vdc.regs[26] & 0x0F; } for (i = vdc.xsmooth, j = 0x80; i < (unsigned)(vdc.regs[22] >> 4); i++, p++, j >>= 1) { if (d & j) { /* foreground */ *p = fg; } else { *p = bg; } } } static int get_idle(raster_cache_t *cache, unsigned int *xs, unsigned int *xe, int rr) /* aka raster_modes_fill_cache() in raster */ { if (rr || (vdc.regs[26] >> 4) != cache->color_data_1[0]) { *xs = 0; *xe = vdc.screen_text_cols; cache->color_data_1[0] = vdc.regs[26] >> 4; return 1; } return 0; } static void draw_idle_cached(raster_cache_t *cache, unsigned int xs, unsigned int xe) /* raster_modes_draw_line_cached() in raster */ { uint8_t *p; uint32_t idleval; unsigned int i; p = vdc.raster.draw_buffer_ptr + vdc.border_width + vdc.raster.xsmooth + xs * 8; idleval = *(hr_table + ((cache->color_data_1[0] & 0x0f) << 8)); for (i = xs; i <= (unsigned int)xe; i++, p += 8) { *((uint32_t *)p) = idleval; *((uint32_t *)p + 1) = idleval; } } static void draw_idle(void) /* raster_modes_draw_line() in raster - draw idle mode (just border) when cache is not used */ { /* TODO - can't we just memset()?? Or just let the border code in raster look after this?? */ uint8_t *p; uint32_t idleval; unsigned int i; p = vdc.raster.draw_buffer_ptr + vdc.border_width + vdc.raster.xsmooth; /* border colour is just the screen background colour from reg 26 bits 0-3 */ idleval = *(hr_table + ((vdc.regs[26] & 0x0f) << 4)); for (i = 0; i < vdc.mem_counter_inc; i++, p += ((vdc.regs[25] & 0x10) ? 16 : 8)) { *((uint32_t *)p) = idleval; *((uint32_t *)p + 1) = idleval; if (vdc.regs[25] & 0x10) { /* double pixel mode */ *((uint32_t *)p + 2) = idleval; *((uint32_t *)p + 3) = idleval; } } } static void setup_modes(void) { raster_modes_set(vdc.raster.modes, VDC_TEXT_MODE, get_std_text, /* raster_modes_fill_cache() in raster */ draw_std_text_cached, /* raster_modes_draw_line_cached() in raster */ draw_std_text, /* raster_modes_draw_line() in raster */ NULL, /* draw_std_background */ NULL); /* draw_std_text_foreground */ raster_modes_set(vdc.raster.modes, VDC_BITMAP_MODE, get_std_bitmap, /* aka raster_modes_fill_cache() in raster */ draw_std_bitmap_cached, /* raster_modes_draw_line_cached() in raster */ draw_std_bitmap, /* raster_modes_draw_line() in raster */ NULL, /* draw_std_background */ NULL); /* draw_std_text_foreground */ raster_modes_set(vdc.raster.modes, VDC_IDLE_MODE, get_idle, /* aka raster_modes_fill_cache() in raster */ draw_idle_cached, /* raster_modes_draw_line_cached() in raster */ draw_idle, /* raster_modes_draw_line() in raster */ NULL, /* draw_std_background */ NULL); /*draw_std_text_foreground */ } void vdc_draw_init(void) { init_drawing_tables(); setup_modes(); }