80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

On 808x, timers are no longer run on every cycle decrease from other devices, properly fixes the stack corruption that was crashing MasterWrite, consequently, the previous fix has been removed;

Browse Source 
Committed the machine files I forgot to commit before.
This commit is contained in:
OBattler
2019-10-20 20:33:59 +02:00
parent 9c42abf2bf
commit e967603e59
8 changed files with 2990 additions and 3121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/cpu/808x.c
View File

@@ -9,7 +9,7 @@
* 808x CPU emulation, mostly ported from reenigne's XTCE, which
* is cycle-accurate.
*
* Version: @(#)808x.c 1.0.9 2019/02/13
* Version: @(#)808x.c 1.0.10 2019/10/20
*
* Authors: Andrew Jenner, <https://www.reenigne.org>
* Miran Grca, <mgrca8@gmail.com>
@@ -258,8 +258,10 @@ fetch_and_bus(int c, int bus)
}
pfq_add(c, !bus);
clock_end();
clock_start();
if (bus < 2) {
clock_end();
clock_start();
}
}
@@ -276,10 +278,13 @@ wait(int c, int bus)
void
sub_cycles(int c)
{
if (c <= 0)
return;
cycles -= c;
if (!is286)
fetch_and_bus(c, 1);
fetch_and_bus(c, 2);
}

9
src/floppy/fdc.c
View File

@@ -9,7 +9,7 @@
* Implementation of the NEC uPD-765 and compatible floppy disk
* controller.
*
* Version: @(#)fdc.c 1.0.20 2019/10/09
* Version: @(#)fdc.c 1.0.21 2019/10/20
*
* Authors: Miran Grca, <mgrca8@gmail.com>
* Sarah Walker, <tommowalker@tommowalker.co.uk>
@@ -248,13 +248,6 @@ fdc_is_mfm(fdc_t *fdc)
}
int
fdc_is_dma(fdc_t *fdc)
{
return ((fdc->flags & FDC_FLAG_PCJR) || !fdc->dma) ? 0 : 1;
}
void
fdc_request_next_sector_id(fdc_t *fdc)
{

3
src/floppy/fdc.h
View File

@@ -9,7 +9,7 @@
* Implementation of the NEC uPD-765 and compatible floppy disk
* controller.
*
* Version: @(#)fdc.h 1.0.7 2019/10/09
* Version: @(#)fdc.h 1.0.8 2019/10/20
*
* Authors: Miran Grca, <mgrca8@gmail.com>
* Sarah Walker, <tommowalker@tommowalker.co.uk>
@@ -148,7 +148,6 @@ extern int fdc_get_drive(fdc_t *fdc);
extern int fdc_get_perp(fdc_t *fdc);
extern int fdc_get_format_n(fdc_t *fdc);
extern int fdc_is_mfm(fdc_t *fdc);
extern int fdc_is_dma(fdc_t *fdc);
extern double fdc_get_hut(fdc_t *fdc);
extern double fdc_get_hlt(fdc_t *fdc);
extern void fdc_request_next_sector_id(fdc_t *fdc);

29
src/floppy/fdd.c
View File

@@ -8,15 +8,15 @@
*
* Implementation of the floppy drive emulation.
*
* Version: @(#)fdd.c 1.0.14 2019/02/11
* Version: @(#)fdd.c 1.0.15 2019/10/20
*
* Authors: Fred N. van Kempen, <decwiz@yahoo.com>
* Miran Grca, <mgrca8@gmail.com>
* Sarah Walker, <tommowalker@tommowalker.co.uk>
*
* Copyright 2018 Fred N. van Kempen.
* Copyright 2016-2018 Miran Grca.
* Copyright 2008-2018 Sarah Walker.
* Copyright 2018,2019 Fred N. van Kempen.
* Copyright 2016-2019 Miran Grca.
* Copyright 2008-2019 Sarah Walker.
*
* 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
@@ -594,8 +594,7 @@ fdd_set_motor_enable(int drive, int motor_enable)
static void
fdd_poll(void *priv)
{
int drive, i;
uint64_t shift;
int drive;
DRIVE *drv = (DRIVE *) priv;
drive = drv->id;
@@ -603,19 +602,15 @@ fdd_poll(void *priv)
if (drive >= FDD_NUM)
fatal("Attempting to poll floppy drive %i that is not supposed to be there\n", drive);
shift = fdc_is_dma(fdd_fdc) ? 5ULL : 0ULL;
timer_advance_u64(&fdd_poll_time[drive], fdd_byteperiod(drive) << shift);
timer_advance_u64(&fdd_poll_time[drive], fdd_byteperiod(drive));
shift = 1ULL << shift;
for (i = 0; i < shift; i++) {
if (drv->poll)
drv->poll(drive);
if (drv->poll)
drv->poll(drive);
if (fdd_notfound) {
fdd_notfound--;
if (!fdd_notfound)
fdc_noidam(fdd_fdc);
}
if (fdd_notfound) {
fdd_notfound--;
if (!fdd_notfound)
fdc_noidam(fdd_fdc);
}
}

5200
src/machine/m_amstrad.c
View File

File diff suppressed because it is too large Load Diff

39
src/machine/m_olivetti_m24.c
View File

@@ -260,7 +260,7 @@ vid_poll(void *priv)
olim24_t *m24 = (olim24_t *)priv;
uint16_t ca = (m24->crtc[15] | (m24->crtc[14] << 8)) & 0x3fff;
int drawcursor;
int x, c;
int x, c, xs_temp, ys_temp;
int oldvc;
uint8_t chr, attr;
uint16_t dat, dat2;
@@ -462,21 +462,36 @@ vid_poll(void *priv)
else
x = (m24->crtc[1] << 4) + 16;
m24->lastline++;
if ((x != xsize) || ((m24->lastline - m24->firstline) != ysize) || video_force_resize_get()) {
xsize = x;
ysize = m24->lastline - m24->firstline;
if (xsize < 64) xsize = 656;
if (ysize < 32) ysize = 200;
set_screen_size(xsize, ysize + 16);
if (video_force_resize_get())
video_force_resize_set(0);
xs_temp = x;
ys_temp = (m24->lastline - m24->firstline);
if ((xs_temp > 0) && (ys_temp > 0)) {
if (xsize < 64) xs_temp = 656;
if (ysize < 32) ys_temp = 200;
if (!enable_overscan)
xs_temp -= 16;
if ((xs_temp != xsize) || (ys_temp != ysize) || video_force_resize_get()) {
xsize = xs_temp;
ysize = ys_temp;
set_screen_size(xsize, ysize + (enable_overscan ? 16 : 0));
if (video_force_resize_get())
video_force_resize_set(0);
}
if (enable_overscan) {
video_blit_memtoscreen_8(0, m24->firstline - 8, 0, (m24->lastline - m24->firstline) + 16,
xsize, (m24->lastline - m24->firstline) + 16);
} else
video_blit_memtoscreen_8(8, m24->firstline, 0, (m24->lastline - m24->firstline),
xsize, (m24->lastline - m24->firstline));
}
video_blit_memtoscreen_8(0, m24->firstline - 8, 0, (m24->lastline - m24->firstline) + 16, xsize, (m24->lastline - m24->firstline) + 16);
frames++;
video_res_x = xsize - 16;
video_res_x = xsize;
video_res_y = ysize;
if (m24->cgamode & 1) {
video_res_x /= 8;
@@ -848,6 +863,8 @@ machine_olim24_init(const machine_t *model)
io_sethandler(0x0066, 2, m24_read, NULL, NULL, NULL, NULL, NULL, m24);
/* Initialize the video adapter. */
// loadfont(L"roms/machines/olivetti_m24/ATT-FONT-DUMPED-VERIFIED.BIN", 1);
loadfont(L"roms/machines/olivetti_m24/m24 graphics board go380 258 pqbq.bin", 1);
m24->vram = malloc(0x8000);
overscan_x = overscan_y = 16;
mem_mapping_add(&m24->mapping, 0xb8000, 0x08000,

206
src/machine/m_pcjr.c
View File

@@ -8,15 +8,15 @@
*
* Emulation of the IBM PCjr.
*
* Version: @(#)m_pcjr.c 1.0.12 2018/11/12
* Version: @(#)m_pcjr.c 1.0.13 2019/10/11
*
* Authors: Sarah Walker, <http://pcem-emulator.co.uk/>
* Miran Grca, <mgrca8@gmail.com>
* Fred N. van Kempen, <decwiz@yahoo.com>
*
* Copyright 2008-2018 Sarah Walker.
* Copyright 2016-2018 Miran Grca.
* Copyright 2017,2018 Fred N. van Kempen.
* Copyright 2008-2019 Sarah Walker.
* Copyright 2016-2019 Miran Grca.
* Copyright 2017-2019 Fred N. van Kempen.
*/
#include <stdarg.h>
#include <stdint.h>
@@ -244,7 +244,7 @@ vid_poll(void *p)
pcjr_t *pcjr = (pcjr_t *)p;
uint16_t ca = (pcjr->crtc[15] | (pcjr->crtc[14] << 8)) & 0x3fff;
int drawcursor;
int x, c;
int x, c, xs_temp, ys_temp;
int oldvc;
uint8_t chr, attr;
uint16_t dat;
@@ -270,10 +270,13 @@ vid_poll(void *p)
cols[0] = (pcjr->array[2] & 0xf) + 16;
for (c = 0; c < 8; c++) {
((uint32_t *)buffer32->line[pcjr->displine])[c] = cols[0];
if (pcjr->array[0] & 1)
((uint32_t *)buffer32->line[pcjr->displine])[c + (pcjr->crtc[1] << 3) + 8] = cols[0];
else
((uint32_t *)buffer32->line[pcjr->displine])[c + (pcjr->crtc[1] << 4) + 8] = cols[0];
if (pcjr->array[0] & 1) {
buffer32->line[(pcjr->displine << 1)][c + (pcjr->crtc[1] << 3) + 8] =
buffer32->line[(pcjr->displine << 1) + 1][c + (pcjr->crtc[1] << 3) + 8] = cols[0];
} else {
buffer32->line[(pcjr->displine << 1)][c + (pcjr->crtc[1] << 4) + 8] =
buffer32->line[(pcjr->displine << 1) + 1][c + (pcjr->crtc[1] << 4) + 8] = cols[0];
}
}
switch (pcjr->addr_mode) {
@@ -294,14 +297,18 @@ vid_poll(void *p)
dat = (pcjr->vram[((pcjr->ma << 1) & mask) + offset] << 8) |
pcjr->vram[((pcjr->ma << 1) & mask) + offset + 1];
pcjr->ma++;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 8] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 9] = pcjr->array[((dat >> 12) & pcjr->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 10] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 11] = pcjr->array[((dat >> 8) & pcjr->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 12] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 13] = pcjr->array[((dat >> 4) & pcjr->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 14] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 15] = pcjr->array[(dat & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 3) + 8] = buffer32->line[(pcjr->displine << 1)][(x << 3) + 9] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 8] = buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 9] =
pcjr->array[((dat >> 12) & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 3) + 10] = buffer32->line[(pcjr->displine << 1)][(x << 3) + 11] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 10] = buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 11] =
pcjr->array[((dat >> 8) & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 3) + 12] = buffer32->line[(pcjr->displine << 1)][(x << 3) + 13] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 12] = buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 13] =
pcjr->array[((dat >> 4) & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 3) + 14] = buffer32->line[(pcjr->displine << 1)][(x << 3) + 15] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 14] = buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 15] =
pcjr->array[(dat & pcjr->array[1]) + 16] + 16;
}
break;
case 0x12: /*160x200x16*/
@@ -309,22 +316,26 @@ vid_poll(void *p)
dat = (pcjr->vram[((pcjr->ma << 1) & mask) + offset] << 8) |
pcjr->vram[((pcjr->ma << 1) & mask) + offset + 1];
pcjr->ma++;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 8] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 9] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 10] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 11] = pcjr->array[((dat >> 12) & pcjr->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 12] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 13] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 14] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 15] = pcjr->array[((dat >> 8) & pcjr->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 16] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 17] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 18] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 19] = pcjr->array[((dat >> 4) & pcjr->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 20] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 21] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 22] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + 23] = pcjr->array[(dat & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 4) + 8] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 9] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + 10] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 11] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 8] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 9] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 10] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 11] =
pcjr->array[((dat >> 12) & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 4) + 12] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 13] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + 14] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 15] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 12] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 13] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 14] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 15] =
pcjr->array[((dat >> 8) & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 4) + 16] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 17] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + 18] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 19] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 16] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 17] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 18] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 19] =
pcjr->array[((dat >> 4) & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 4) + 20] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 21] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + 22] = buffer32->line[(pcjr->displine << 1)][(x << 4) + 23] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 20] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 21] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 22] = buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + 23] =
pcjr->array[(dat & pcjr->array[1]) + 16] + 16;
}
break;
case 0x03: /*640x200x4*/
@@ -335,7 +346,8 @@ vid_poll(void *p)
for (c = 0; c < 8; c++) {
chr = (dat >> 7) & 1;
chr |= ((dat >> 14) & 2);
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + 8 + c] = pcjr->array[(chr & pcjr->array[1]) + 16] + 16;
buffer32->line[(pcjr->displine << 1)][(x << 3) + 8 + c] = buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + 8 + c] =
pcjr->array[(chr & pcjr->array[1]) + 16] + 16;
dat <<= 1;
}
}
@@ -355,15 +367,22 @@ vid_poll(void *p)
cols[0] = pcjr->array[((attr >> 4) & pcjr->array[1]) + 16] + 16;
}
if (pcjr->sc & 8) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + c + 8] = cols[0];
for (c = 0; c < 8; c++) {
buffer32->line[(pcjr->displine << 1)][(x << 3) + c + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + c + 8] = cols[0];
}
} else {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + c + 8] = cols[(fontdat[chr][pcjr->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
for (c = 0; c < 8; c++) {
buffer32->line[(pcjr->displine << 1)][(x << 3) + c + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + c + 8] =
cols[(fontdat[chr][pcjr->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
}
}
if (drawcursor) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[pcjr->displine])[(x << 3) + c + 8] ^= 15;
for (c = 0; c < 8; c++) {
buffer32->line[(pcjr->displine << 1)][(x << 3) + c + 8] ^= 15;
buffer32->line[(pcjr->displine << 1) + 1][(x << 3) + c + 8] ^= 15;
}
}
pcjr->ma++;
}
@@ -384,17 +403,26 @@ vid_poll(void *p)
}
pcjr->ma++;
if (pcjr->sc & 8) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[0];
for (c = 0; c < 8; c++) {
buffer32->line[(pcjr->displine << 1)][(x << 4) + (c << 1) + 8] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + (c << 1) + 1 + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + (c << 1) + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + (c << 1) + 1 + 8] = cols[0];
}
} else {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[(fontdat[chr][pcjr->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
for (c = 0; c < 8; c++) {
buffer32->line[(pcjr->displine << 1)][(x << 4) + (c << 1) + 8] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + (c << 1) + 1 + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + (c << 1) + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + (c << 1) + 1 + 8] =
cols[(fontdat[chr][pcjr->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
}
}
if (drawcursor) {
for (c = 0; c < 16; c++)
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + c + 8] ^= 15;
for (c = 0; c < 16; c++) {
buffer32->line[(pcjr->displine << 1)][(x << 4) + c + 8] ^= 15;
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + c + 8] ^= 15;
}
}
}
break;
@@ -408,8 +436,10 @@ vid_poll(void *p)
pcjr->vram[((pcjr->ma << 1) & mask) + offset + 1];
pcjr->ma++;
for (c = 0; c < 8; c++) {
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[dat >> 14];
buffer32->line[(pcjr->displine << 1)][(x << 4) + (c << 1) + 8] =
buffer32->line[(pcjr->displine << 1)][(x << 4) + (c << 1) + 1 + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + (c << 1) + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + (c << 1) + 1 + 8] = cols[dat >> 14];
dat <<= 2;
}
}
@@ -422,7 +452,9 @@ vid_poll(void *p)
pcjr->vram[((pcjr->ma << 1) & mask) + offset + 1];
pcjr->ma++;
for (c = 0; c < 16; c++) {
((uint32_t *)buffer32->line[pcjr->displine])[(x << 4) + c + 8] = cols[dat >> 15];
buffer32->line[(pcjr->displine << 1)][(x << 4) + c + 8] =
buffer32->line[(pcjr->displine << 1) + 1][(x << 4) + c + 8] =
cols[dat >> 15];
dat <<= 1;
}
}
@@ -430,18 +462,30 @@ vid_poll(void *p)
}
} else {
if (pcjr->array[3] & 4) {
if (pcjr->array[0] & 1) hline(buffer32, 0, pcjr->displine, (pcjr->crtc[1] << 3) + 16, (pcjr->array[2] & 0xf) + 16);
else hline(buffer32, 0, pcjr->displine, (pcjr->crtc[1] << 4) + 16, (pcjr->array[2] & 0xf) + 16);
if (pcjr->array[0] & 1) {
hline(buffer32, 0, (pcjr->displine << 1), (pcjr->crtc[1] << 3) + 16, (pcjr->array[2] & 0xf) + 16);
hline(buffer32, 0, (pcjr->displine << 1) + 1, (pcjr->crtc[1] << 3) + 16, (pcjr->array[2] & 0xf) + 16);
} else {
hline(buffer32, 0, (pcjr->displine << 1), (pcjr->crtc[1] << 4) + 16, (pcjr->array[2] & 0xf) + 16);
hline(buffer32, 0, (pcjr->displine << 1) + 1, (pcjr->crtc[1] << 4) + 16, (pcjr->array[2] & 0xf) + 16);
}
} else {
cols[0] = pcjr->array[0 + 16] + 16;
if (pcjr->array[0] & 1) hline(buffer32, 0, pcjr->displine, (pcjr->crtc[1] << 3) + 16, cols[0]);
else hline(buffer32, 0, pcjr->displine, (pcjr->crtc[1] << 4) + 16, cols[0]);
if (pcjr->array[0] & 1) {
hline(buffer32, 0, (pcjr->displine << 1), (pcjr->crtc[1] << 3) + 16, cols[0]);
hline(buffer32, 0, (pcjr->displine << 1) + 1, (pcjr->crtc[1] << 3) + 16, cols[0]);
} else {
hline(buffer32, 0, (pcjr->displine << 1), (pcjr->crtc[1] << 4) + 16, cols[0]);
hline(buffer32, 0, (pcjr->displine << 1) + 1, (pcjr->crtc[1] << 4) + 16, cols[0]);
}
}
}
if (pcjr->array[0] & 1) x = (pcjr->crtc[1] << 3) + 16;
else x = (pcjr->crtc[1] << 4) + 16;
if (pcjr->composite)
Composite_Process(pcjr->array[0], 0, x >> 2, ((uint32_t *)buffer32->line[pcjr->displine]));
if (pcjr->composite) {
Composite_Process(pcjr->array[0], 0, x >> 2, buffer32->line[(pcjr->displine << 1)]);
Composite_Process(pcjr->array[0], 0, x >> 2, buffer32->line[(pcjr->displine << 1) + 1]);
}
pcjr->sc = oldsc;
if (pcjr->vc == pcjr->crtc[7] && !pcjr->sc) {
pcjr->stat |= 8;
@@ -501,24 +545,44 @@ vid_poll(void *p)
if (pcjr->array[0] & 1) x = (pcjr->crtc[1] << 3) + 16;
else x = (pcjr->crtc[1] << 4) + 16;
pcjr->lastline++;
if ((x != xsize) || ((pcjr->lastline - pcjr->firstline) != ysize) || video_force_resize_get()) {
xsize = x;
ysize = pcjr->lastline - pcjr->firstline;
if (xsize < 64) xsize = 656;
if (ysize < 32) ysize = 200;
set_screen_size(xsize, (ysize << 1) + 16);
if (video_force_resize_get())
video_force_resize_set(0);
xs_temp = x;
ys_temp = (pcjr->lastline - pcjr->firstline) << 1;
if ((xs_temp > 0) && (ys_temp > 0)) {
if (xs_temp < 64) xs_temp = 656;
if (ys_temp < 32) ys_temp = 400;
if (!enable_overscan)
xs_temp -= 16;
if ((xs_temp != xsize) || (ys_temp != ysize) || video_force_resize_get()) {
xsize = xs_temp;
ysize = ys_temp;
set_screen_size(xsize, ysize + (enable_overscan ? 16 : 0));
if (video_force_resize_get())
video_force_resize_set(0);
}
if (enable_overscan) {
if (pcjr->composite)
video_blit_memtoscreen(0, (pcjr->firstline - 4) << 1, 0, ((pcjr->lastline - pcjr->firstline) + 8) << 1,
xsize, ((pcjr->lastline - pcjr->firstline) + 8) << 1);
else
video_blit_memtoscreen_8(0, (pcjr->firstline - 4) << 1, 0, ((pcjr->lastline - pcjr->firstline) + 8) << 1,
xsize, ((pcjr->lastline - pcjr->firstline) + 8) << 1);
} else {
if (pcjr->composite)
video_blit_memtoscreen(8, pcjr->firstline << 1, 0, (pcjr->lastline - pcjr->firstline) << 1,
xsize, (pcjr->lastline - pcjr->firstline) << 1);
else
video_blit_memtoscreen_8(8, pcjr->firstline << 1, 0, (pcjr->lastline - pcjr->firstline) << 1,
xsize, (pcjr->lastline - pcjr->firstline) << 1);
}
}
if (pcjr->composite)
video_blit_memtoscreen(0, pcjr->firstline-4, 0, (pcjr->lastline - pcjr->firstline) + 8, xsize, (pcjr->lastline - pcjr->firstline) + 8);
else
video_blit_memtoscreen_8(0, pcjr->firstline-4, 0, (pcjr->lastline - pcjr->firstline) + 8, xsize, (pcjr->lastline - pcjr->firstline) + 8);
frames++;
video_res_x = xsize - 16;
video_res_x = xsize;
video_res_y = ysize;
}
pcjr->firstline = 1000;

612
src/machine/m_tandy.c
View File

@@ -8,13 +8,13 @@
*
* Emulation of Tandy models 1000, 1000HX and 1000SL2.
*
* Version: @(#)m_tandy.c 1.0.9 2018/10/22
* Version: @(#)m_tandy.c 1.0.10 2019/10/20
*
* Authors: Sarah Walker, <http://pcem-emulator.co.uk/>
* Miran Grca, <mgrca8@gmail.com>
*
* Copyright 2008-2018 Sarah Walker.
* Copyright 2016-2018 Miran Grca.
* Copyright 2008-2019 Sarah Walker.
* Copyright 2016-2019 Miran Grca.
*/
#include <stdarg.h>
#include <stdint.h>
@@ -662,7 +662,7 @@ vid_poll(void *priv)
t1kvid_t *vid = dev->vid;
uint16_t ca = (vid->crtc[15] | (vid->crtc[14] << 8)) & 0x3fff;
int drawcursor;
int x, c;
int x, c, xs_temp, ys_temp;
int oldvc;
uint8_t chr, attr;
uint16_t dat;
@@ -677,7 +677,6 @@ vid_poll(void *priv)
oldsc = vid->sc;
if ((vid->crtc[8] & 3) == 3)
vid->sc = (vid->sc << 1) & 7;
if (vid->dispon) {
if (vid->displine < vid->firstline) {
vid->firstline = vid->displine;
@@ -687,61 +686,96 @@ vid_poll(void *priv)
cols[0] = (vid->array[2] & 0xf) + 16;
for (c = 0; c < 8; c++) {
if (vid->array[3] & 4) {
((uint32_t *)buffer32->line[vid->displine])[c] = cols[0];
if (vid->mode & 1)
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 3) + 8] = cols[0];
else
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 4) + 8] = cols[0];
buffer32->line[(vid->displine << 1)][c] = buffer32->line[(vid->displine << 1) + 1][c] = cols[0];
if (vid->mode & 1) {
buffer32->line[(vid->displine << 1)][c + (vid->crtc[1] << 3) + 8] =
buffer32->line[(vid->displine << 1) + 1][c + (vid->crtc[1] << 3) + 8] = cols[0];
} else {
buffer32->line[(vid->displine << 1)][c + (vid->crtc[1] << 4) + 8] =
buffer32->line[(vid->displine << 1) + 1][c + (vid->crtc[1] << 4) + 8] = cols[0];
}
} else if ((vid->mode & 0x12) == 0x12) {
((uint32_t *)buffer32->line[vid->displine])[c] = 0;
if (vid->mode & 1)
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 3) + 8] = 0;
else
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 4) + 8] = 0;
buffer32->line[(vid->displine << 1)][c] = buffer32->line[(vid->displine << 1) + 1][c] = 0;
if (vid->mode & 1) {
buffer32->line[(vid->displine << 1)][c + (vid->crtc[1] << 3) + 8] =
buffer32->line[(vid->displine << 1) + 1][c + (vid->crtc[1] << 3) + 8] = 0;
} else {
buffer32->line[(vid->displine << 1)][c + (vid->crtc[1] << 4) + 8] =
buffer32->line[(vid->displine << 1) + 1][c + (vid->crtc[1] << 4) + 8] = 0;
}
} else {
((uint32_t *)buffer32->line[vid->displine])[c] = (vid->col & 15) + 16;
if (vid->mode & 1)
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 3) + 8] = (vid->col & 15) + 16;
else
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 4) + 8] = (vid->col & 15) + 16;
buffer32->line[(vid->displine << 1)][c] = buffer32->line[(vid->displine << 1) + 1][c] = (vid->col & 15) + 16;
if (vid->mode & 1) {
buffer32->line[(vid->displine << 1)][c + (vid->crtc[1] << 3) + 8] =
buffer32->line[(vid->displine << 1) + 1][c + (vid->crtc[1] << 3) + 8] = (vid->col & 15) + 16;
} else {
buffer32->line[(vid->displine << 1)][c + (vid->crtc[1] << 4) + 8] =
buffer32->line[(vid->displine << 1) + 1][c + (vid->crtc[1] << 4) + 8] = (vid->col & 15) + 16;
}
}
}
if ((vid->array[3] & 0x10) && (vid->mode & 1)) { /*320x200x16*/
if (dev->is_sl2 && (vid->array[5] & 1)) { /*640x200x16*/
for (x = 0; x < vid->crtc[1]*2; x++) {
dat = (vid->vram[(vid->ma << 1) & 0xffff] << 8) |
vid->vram[((vid->ma << 1) + 1) & 0xffff];
vid->ma++;
buffer32->line[(vid->displine << 1)][(x << 2) + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 2) + 8] =
vid->array[((dat >> 12) & 0xf) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 2) + 9] = buffer32->line[(vid->displine << 1) + 1][(x << 2) + 9] =
vid->array[((dat >> 8) & 0xf) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 2) + 10] = buffer32->line[(vid->displine << 1) + 1][(x << 2) + 10] =
vid->array[((dat >> 4) & 0xf) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 2) + 11] = buffer32->line[(vid->displine << 1) + 1][(x << 2) + 11] =
vid->array[(dat & 0xf) + 16] + 16;
}
} else if ((vid->array[3] & 0x10) && (vid->mode & 1)) { /*320x200x16*/
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000) + 1];
vid->ma++;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 9] = vid->array[((dat >> 12) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 10] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 11] = vid->array[((dat >> 8) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 12] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 13] = vid->array[((dat >> 4) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 14] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 15] = vid->array[(dat & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 3) + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 8] =
buffer32->line[(vid->displine << 1)][(x << 3) + 9] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 9] =
vid->array[((dat >> 12) & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 3) + 10] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 10] =
buffer32->line[(vid->displine << 1)][(x << 3) + 11] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 11] =
vid->array[((dat >> 8) & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 3) + 12] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 12] =
buffer32->line[(vid->displine << 1)][(x << 3) + 13] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 13] =
vid->array[((dat >> 4) & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 3) + 14] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 14] =
buffer32->line[(vid->displine << 1)][(x << 3) + 15] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 15] =
vid->array[(dat & vid->array[1]) + 16] + 16;
}
} else if (vid->array[3] & 0x10) { /*160x200x16*/
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000) + 1];
if (dev->is_sl2) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000) + 1];
} else {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000) + 1];
}
vid->ma++;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 9] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 10] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 11] = vid->array[((dat >> 12) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 12] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 13] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 14] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 15] = vid->array[((dat >> 8) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 16] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 17] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 18] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 19] = vid->array[((dat >> 4) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 20] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 21] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 22] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 23] = vid->array[(dat & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 4) + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 8] =
buffer32->line[(vid->displine << 1)][(x << 4) + 9] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 9] =
buffer32->line[(vid->displine << 1)][(x << 4) + 10] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 10] =
buffer32->line[(vid->displine << 1)][(x << 4) + 11] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 11] =
vid->array[((dat >> 12) & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 4) + 12] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 12] =
buffer32->line[(vid->displine << 1)][(x << 4) + 13] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 13] =
buffer32->line[(vid->displine << 1)][(x << 4) + 14] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 14] =
buffer32->line[(vid->displine << 1)][(x << 4) + 15] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 15] =
vid->array[((dat >> 8) & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 4) + 16] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 16] =
buffer32->line[(vid->displine << 1)][(x << 4) + 17] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 17] =
buffer32->line[(vid->displine << 1)][(x << 4) + 18] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 18] =
buffer32->line[(vid->displine << 1)][(x << 4) + 19] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 19] =
vid->array[((dat >> 4) & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 4) + 20] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 20] =
buffer32->line[(vid->displine << 1)][(x << 4) + 21] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 21] =
buffer32->line[(vid->displine << 1)][(x << 4) + 22] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 22] =
buffer32->line[(vid->displine << 1)][(x << 4) + 23] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + 23] =
vid->array[(dat & vid->array[1]) + 16] + 16;
}
} else if (vid->array[3] & 0x08) { /*640x200x4 - this implementation is a complete guess!*/
for (x = 0; x < vid->crtc[1]; x++) {
@@ -751,7 +785,8 @@ vid_poll(void *priv)
for (c = 0; c < 8; c++) {
chr = (dat >> 6) & 2;
chr |= ((dat >> 15) & 1);
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 8 + c] = vid->array[(chr & vid->array[1]) + 16] + 16;
buffer32->line[(vid->displine << 1)][(x << 3) + 8 + c] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + 8 + c] =
vid->array[(chr & vid->array[1]) + 16] + 16;
dat <<= 1;
}
}
@@ -770,15 +805,21 @@ vid_poll(void *priv)
cols[0] = vid->array[((attr >> 4) & vid->array[1]) + 16] + 16;
}
if (vid->sc & 8) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + c + 8] = cols[0];
for (c = 0; c < 8; c++) {
buffer32->line[(vid->displine << 1)][(x << 3) + c + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + c + 8] =
cols[0];
}
} else {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + c + 8] = cols[(fontdat[chr][vid->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
for (c = 0; c < 8; c++) {
buffer32->line[(vid->displine << 1)][(x << 3) + c + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 3) + c + 8] =
cols[(fontdat[chr][vid->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
}
}
if (drawcursor) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + c + 8] ^= 15;
for (c = 0; c < 8; c++) {
buffer32->line[(vid->displine << 1)][(x << 3) + c + 8] ^= 15;
buffer32->line[(vid->displine << 1) + 1][(x << 3) + c + 8] ^= 15;
}
}
vid->ma++;
}
@@ -799,356 +840,20 @@ vid_poll(void *priv)
vid->ma++;
if (vid->sc & 8) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[0];
buffer32->line[(vid->displine << 1)][(x << 4) + (c << 1) + 8] = buffer32->line[(vid->displine << 1)][(x << 4) + (c << 1) + 1 + 8] =
cols[0];
} else {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[(fontdat[chr][vid->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
for (c = 0; c < 8; c++) {
buffer32->line[(vid->displine << 1)][(x << 4) + (c << 1) + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + (c << 1) + 8] =
buffer32->line[(vid->displine << 1)][(x << 4) + (c << 1) + 1 + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + (c << 1) + 1 + 8] =
cols[(fontdat[chr][vid->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
}
}
if (drawcursor) {
for (c = 0; c < 16; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + c + 8] ^= 15;
}
}
} else if (! (vid->mode& 16)) {
cols[0] = (vid->col & 15) | 16;
col = (vid->col & 16) ? 24 : 16;
if (vid->mode & 4) {
cols[1] = col | 3;
cols[2] = col | 4;
cols[3] = col | 7;
} else if (vid->col & 32) {
cols[1] = col | 3;
cols[2] = col | 5;
cols[3] = col | 7;
} else {
cols[1] = col | 2;
cols[2] = col | 4;
cols[3] = col | 6;
}
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000) + 1];
vid->ma++;
for (c = 0; c < 8; c++) {
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[dat >> 14];
dat <<= 2;
}
}
} else {
cols[0] = 0;
cols[1] = vid->array[(vid->col & vid->array[1]) + 16] + 16;
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000) + 1];
vid->ma++;
for (c = 0; c < 16; c++) {
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + c + 8] = cols[dat >> 15];
dat <<= 1;
}
}
}
} else {
if (vid->array[3] & 4) {
if (vid->mode & 1)
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 3) + 16, (vid->array[2] & 0xf) + 16);
else
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 4) + 16, (vid->array[2] & 0xf) + 16);
} else {
cols[0] = ((vid->mode & 0x12) == 0x12) ? 0 : (vid->col & 0xf) + 16;
if (vid->mode & 1)
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 3) + 16, cols[0]);
else
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 4) + 16, cols[0]);
}
}
if (vid->mode & 1)
x = (vid->crtc[1] << 3) + 16;
else
x = (vid->crtc[1] << 4) + 16;
if (vid->composite)
Composite_Process(vid->mode, 0, x >> 2, ((uint32_t *)buffer32->line[vid->displine]));
vid->sc = oldsc;
if (vid->vc == vid->crtc[7] && !vid->sc)
vid->stat |= 8;
vid->displine++;
if (vid->displine >= 360)
vid->displine = 0;
} else {
timer_advance_u64(&vid->timer, vid->dispontime);
if (vid->dispon)
vid->stat &= ~1;
vid->linepos = 0;
if (vid->vsynctime) {
vid->vsynctime--;
if (! vid->vsynctime)
vid->stat &= ~8;
}
if (vid->sc == (vid->crtc[11] & 31) || ((vid->crtc[8] & 3) == 3 && vid->sc == ((vid->crtc[11] & 31) >> 1))) {
vid->con = 0;
vid->coff = 1;
}
if (vid->vadj) {
vid->sc++;
vid->sc &= 31;
vid->ma = vid->maback;
vid->vadj--;
if (! vid->vadj) {
vid->dispon = 1;
vid->ma = vid->maback = (vid->crtc[13] | (vid->crtc[12] << 8)) & 0x3fff;
vid->sc = 0;
}
} else if (vid->sc == vid->crtc[9] || ((vid->crtc[8] & 3) == 3 && vid->sc == (vid->crtc[9] >> 1))) {
vid->maback = vid->ma;
vid->sc = 0;
oldvc = vid->vc;
vid->vc++;
vid->vc &= 127;
if (vid->vc == vid->crtc[6])
vid->dispon = 0;
if (oldvc == vid->crtc[4]) {
vid->vc = 0;
vid->vadj = vid->crtc[5];
if (! vid->vadj)
vid->dispon = 1;
if (! vid->vadj)
vid->ma = vid->maback = (vid->crtc[13] | (vid->crtc[12] << 8)) & 0x3fff;
if ((vid->crtc[10] & 0x60) == 0x20)
vid->cursoron = 0;
else
vid->cursoron = vid->blink & 16;
}
if (vid->vc == vid->crtc[7]) {
vid->dispon = 0;
vid->displine = 0;
vid->vsynctime = 16;
if (vid->crtc[7]) {
if (vid->mode & 1)
x = (vid->crtc[1] << 3) + 16;
else
x = (vid->crtc[1] << 4) + 16;
vid->lastline++;
if ((x != xsize) || ((vid->lastline - vid->firstline) != ysize) || video_force_resize_get()) {
xsize = x;
ysize = vid->lastline - vid->firstline;
if (xsize < 64) xsize = 656;
if (ysize < 32) ysize = 200;
set_screen_size(xsize, (ysize << 1) + 16);
if (video_force_resize_get())
video_force_resize_set(0);
}
if (vid->composite)
video_blit_memtoscreen(0, vid->firstline-4, 0, (vid->lastline - vid->firstline) + 8, xsize, (vid->lastline - vid->firstline) + 8);
else
video_blit_memtoscreen_8(0, vid->firstline-4, 0, (vid->lastline - vid->firstline) + 8, xsize, (vid->lastline - vid->firstline) + 8);
frames++;
video_res_x = xsize - 16;
video_res_y = ysize;
if ((vid->array[3] & 0x10) && (vid->mode & 1)) { /*320x200x16*/
video_res_x /= 2;
video_bpp = 4;
} else if (vid->array[3] & 0x10) { /*160x200x16*/
video_res_x /= 4;
video_bpp = 4;
} else if (vid->array[3] & 0x08) { /*640x200x4 - this implementation is a complete guess!*/
video_bpp = 2;
} else if (vid->mode & 1) {
video_res_x /= 8;
video_res_y /= vid->crtc[9] + 1;
video_bpp = 0;
} else if (! (vid->mode & 2)) {
video_res_x /= 16;
video_res_y /= vid->crtc[9] + 1;
video_bpp = 0;
} else if (! (vid->mode & 16)) {
video_res_x /= 2;
video_bpp = 2;
} else {
video_bpp = 1;
}
}
vid->firstline = 1000;
vid->lastline = 0;
vid->blink++;
}
} else {
vid->sc++;
vid->sc &= 31;
vid->ma = vid->maback;
}
if ((vid->sc == (vid->crtc[10] & 31) || ((vid->crtc[8] & 3) == 3 && vid->sc == ((vid->crtc[10] & 31) >> 1))))
vid->con = 1;
}
}
static void
vid_poll_sl(void *priv)
{
tandy_t *dev = (tandy_t *)priv;
t1kvid_t *vid = dev->vid;
uint16_t ca = (vid->crtc[15] | (vid->crtc[14] << 8)) & 0x3fff;
int drawcursor;
int x, c;
int oldvc;
uint8_t chr, attr;
uint16_t dat;
int cols[4];
int col;
int oldsc;
if (! vid->linepos) {
timer_advance_u64(&vid->timer, vid->dispofftime);
vid->stat |= 1;
vid->linepos = 1;
oldsc = vid->sc;
if ((vid->crtc[8] & 3) == 3)
vid->sc = (vid->sc << 1) & 7;
if (vid->dispon) {
if (vid->displine < vid->firstline) {
vid->firstline = vid->displine;
video_wait_for_buffer();
}
vid->lastline = vid->displine;
cols[0] = (vid->array[2] & 0xf) + 16;
for (c = 0; c < 8; c++) {
if (vid->array[3] & 4) {
((uint32_t *)buffer32->line[vid->displine])[c] = cols[0];
if (vid->mode & 1)
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 3) + 8] = cols[0];
else
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 4) + 8] = cols[0];
} else if ((vid->mode & 0x12) == 0x12) {
((uint32_t *)buffer32->line[vid->displine])[c] = 0;
if (vid->mode & 1)
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 3) + 8] = 0;
else
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 4) + 8] = 0;
} else {
((uint32_t *)buffer32->line[vid->displine])[c] = (vid->col & 15) + 16;
if (vid->mode & 1)
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 3) + 8] = (vid->col & 15) + 16;
else
((uint32_t *)buffer32->line[vid->displine])[c + (vid->crtc[1] << 4) + 8] = (vid->col & 15) + 16;
}
}
if (vid->array[5] & 1) { /*640x200x16*/
for (x = 0; x < vid->crtc[1]*2; x++) {
dat = (vid->vram[(vid->ma << 1) & 0xffff] << 8) |
vid->vram[((vid->ma << 1) + 1) & 0xffff];
vid->ma++;
((uint32_t *)buffer32->line[vid->displine])[(x << 2) + 8] = vid->array[((dat >> 12) & 0xf)/*vid->array[1])*/ + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 2) + 9] = vid->array[((dat >> 8) & 0xf)/*vid->array[1])*/ + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 2) + 10] = vid->array[((dat >> 4) & 0xf)/*vid->array[1])*/ + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 2) + 11] = vid->array[(dat & 0xf)/*vid->array[1])*/ + 16] + 16;
}
} else if ((vid->array[3] & 0x10) && (vid->mode & 1)) { /*320x200x16*/
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000) + 1];
vid->ma++;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 9] = vid->array[((dat >> 12) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 10] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 11] = vid->array[((dat >> 8) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 12] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 13] = vid->array[((dat >> 4) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 14] =
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 15] = vid->array[(dat & vid->array[1]) + 16] + 16;
}
} else if (vid->array[3] & 0x10) { /*160x200x16*/
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000) + 1];
vid->ma++;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 9] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 10] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 11] = vid->array[((dat >> 12) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 12] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 13] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 14] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 15] = vid->array[((dat >> 8) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 16] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 17] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 18] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 19] = vid->array[((dat >> 4) & vid->array[1]) + 16] + 16;
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 20] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 21] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 22] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + 23] = vid->array[(dat & vid->array[1]) + 16] + 16;
}
} else if (vid->array[3] & 0x08) { /*640x200x4 - this implementation is a complete guess!*/
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 3) * 0x2000) + 1];
vid->ma++;
for (c = 0; c < 8; c++) {
chr = (dat >> 6) & 2;
chr |= ((dat >> 15) & 1);
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + 8 + c] = vid->array[(chr & vid->array[1]) + 16] + 16;
dat <<= 1;
}
}
} else if (vid->mode & 1) {
for (x = 0; x < vid->crtc[1]; x++) {
chr = vid->vram[ (vid->ma << 1) & 0x3fff];
attr = vid->vram[((vid->ma << 1) + 1) & 0x3fff];
drawcursor = ((vid->ma == ca) && vid->con && vid->cursoron);
if (vid->mode & 0x20) {
cols[1] = vid->array[ ((attr & 15) & vid->array[1]) + 16] + 16;
cols[0] = vid->array[(((attr >> 4) & 7) & vid->array[1]) + 16] + 16;
if ((vid->blink & 16) && (attr & 0x80) && !drawcursor)
cols[1] = cols[0];
} else {
cols[1] = vid->array[((attr & 15) & vid->array[1]) + 16] + 16;
cols[0] = vid->array[((attr >> 4) & vid->array[1]) + 16] + 16;
}
if (vid->sc & 8) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + c + 8] = cols[0];
} else {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + c + 8] = cols[(fontdat[chr][vid->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
}
if (drawcursor) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 3) + c + 8] ^= 15;
}
vid->ma++;
}
} else if (! (vid->mode & 2)) {
for (x = 0; x < vid->crtc[1]; x++) {
chr = vid->vram[ (vid->ma << 1) & 0x3fff];
attr = vid->vram[((vid->ma << 1) + 1) & 0x3fff];
drawcursor = ((vid->ma == ca) && vid->con && vid->cursoron);
if (vid->mode & 0x20) {
cols[1] = vid->array[ ((attr & 15) & vid->array[1]) + 16] + 16;
cols[0] = vid->array[(((attr >> 4) & 7) & vid->array[1]) + 16] + 16;
if ((vid->blink & 16) && (attr & 0x80) && !drawcursor)
cols[1] = cols[0];
} else {
cols[1] = vid->array[((attr & 15) & vid->array[1]) + 16] + 16;
cols[0] = vid->array[((attr >> 4) & vid->array[1]) + 16] + 16;
}
vid->ma++;
if (vid->sc & 8) {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[0];
} else {
for (c = 0; c < 8; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[(fontdat[chr][vid->sc & 7] & (1 << (c ^ 7))) ? 1 : 0];
}
if (drawcursor) {
for (c = 0; c < 16; c++)
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + c + 8] ^= 15;
for (c = 0; c < 16; c++) {
buffer32->line[(vid->displine << 1)][(x << 4) + c + 8] ^= 15;
buffer32->line[(vid->displine << 1) + 1][(x << 4) + c + 8] ^= 15;
}
}
}
} else if (! (vid->mode & 16)) {
@@ -1167,14 +872,14 @@ vid_poll_sl(void *priv)
cols[2] = col | 4;
cols[3] = col | 6;
}
for (x = 0; x < vid->crtc[1]; x++) {
dat = (vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000)] << 8) |
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000) + 1];
vid->ma++;
for (c = 0; c < 8; c++) {
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 8] =
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + (c << 1) + 1 + 8] = cols[dat >> 14];
buffer32->line[(vid->displine << 1)][(x << 4) + (c << 1) + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + (c << 1) + 8] =
buffer32->line[(vid->displine << 1)][(x << 4) + (c << 1) + 1 + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + (c << 1) + 1 + 8] =
cols[dat >> 14];
dat <<= 2;
}
}
@@ -1186,23 +891,30 @@ vid_poll_sl(void *priv)
vid->vram[((vid->ma << 1) & 0x1fff) + ((vid->sc & 1) * 0x2000) + 1];
vid->ma++;
for (c = 0; c < 16; c++) {
((uint32_t *)buffer32->line[vid->displine])[(x << 4) + c + 8] = cols[dat >> 15];
buffer32->line[(vid->displine << 1)][(x << 4) + c + 8] = buffer32->line[(vid->displine << 1) + 1][(x << 4) + c + 8] =
cols[dat >> 15];
dat <<= 1;
}
}
}
} else {
if (vid->array[3] & 4) {
if (vid->mode & 1)
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 3) + 16, (vid->array[2] & 0xf) + 16);
else
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 4) + 16, (vid->array[2] & 0xf) + 16);
if (vid->mode & 1) {
hline(buffer32, 0, (vid->displine << 1), (vid->crtc[1] << 3) + 16, (vid->array[2] & 0xf) + 16);
hline(buffer32, 0, (vid->displine << 1) + 1, (vid->crtc[1] << 3) + 16, (vid->array[2] & 0xf) + 16);
} else {
hline(buffer32, 0, (vid->displine << 1), (vid->crtc[1] << 4) + 16, (vid->array[2] & 0xf) + 16);
hline(buffer32, 0, (vid->displine << 1) + 1, (vid->crtc[1] << 4) + 16, (vid->array[2] & 0xf) + 16);
}
} else {
cols[0] = ((vid->mode & 0x12) == 0x12) ? 0 : (vid->col & 0xf) + 16;
if (vid->mode & 1)
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 3) + 16, cols[0]);
else
hline(buffer32, 0, vid->displine, (vid->crtc[1] << 4) + 16, cols[0]);
if (vid->mode & 1) {
hline(buffer32, 0, (vid->displine << 1), (vid->crtc[1] << 3) + 16, cols[0]);
hline(buffer32, 0, (vid->displine << 1) + 1, (vid->crtc[1] << 3) + 16, cols[0]);
} else {
hline(buffer32, 0, (vid->displine << 1), (vid->crtc[1] << 4) + 16, cols[0]);
hline(buffer32, 0, (vid->displine << 1) + 1, (vid->crtc[1] << 4) + 16, cols[0]);
}
}
}
@@ -1210,8 +922,11 @@ vid_poll_sl(void *priv)
x = (vid->crtc[1] << 3) + 16;
else
x = (vid->crtc[1] << 4) + 16;
if (!dev->is_sl2 && vid->composite) {
Composite_Process(vid->mode, 0, x >> 2, buffer32->line[(vid->displine << 1)]);
Composite_Process(vid->mode, 0, x >> 2, buffer32->line[(vid->displine << 1) + 1]);
}
vid->sc = oldsc;
if (vid->vc == vid->crtc[7] && !vid->sc)
vid->stat |= 8;
vid->displine++;
@@ -1238,7 +953,7 @@ vid_poll_sl(void *priv)
vid->vadj--;
if (! vid->vadj) {
vid->dispon = 1;
if (vid->array[5] & 1)
if (dev->is_sl2 && (vid->array[5] & 1))
vid->ma = vid->maback = vid->crtc[13] | (vid->crtc[12] << 8);
else
vid->ma = vid->maback = (vid->crtc[13] | (vid->crtc[12] << 8)) & 0x3fff;
@@ -1249,7 +964,10 @@ vid_poll_sl(void *priv)
vid->sc = 0;
oldvc = vid->vc;
vid->vc++;
vid->vc &= 255;
if (dev->is_sl2)
vid->vc &= 255;
else
vid->vc &= 127;
if (vid->vc == vid->crtc[6])
vid->dispon = 0;
if (oldvc == vid->crtc[4]) {
@@ -1258,7 +976,7 @@ vid_poll_sl(void *priv)
if (! vid->vadj)
vid->dispon = 1;
if (! vid->vadj) {
if (vid->array[5] & 1)
if (dev->is_sl2 && (vid->array[5] & 1))
vid->ma = vid->maback = vid->crtc[13] | (vid->crtc[12] << 8);
else
vid->ma = vid->maback = (vid->crtc[13] | (vid->crtc[12] << 8)) & 0x3fff;
@@ -1278,30 +996,54 @@ vid_poll_sl(void *priv)
else
x = (vid->crtc[1] << 4) + 16;
vid->lastline++;
if ((x != xsize) || ((vid->lastline - vid->firstline) != ysize) || video_force_resize_get()) {
xsize = x;
ysize = vid->lastline - vid->firstline;
if (xsize < 64) xsize = 656;
if (ysize < 32) ysize = 200;
set_screen_size(xsize, (ysize << 1) + 16);
if (video_force_resize_get())
video_force_resize_set(0);
xs_temp = x;
ys_temp = (vid->lastline - vid->firstline) << 1;
if ((xs_temp > 0) && (ys_temp > 0)) {
if (xs_temp < 64) xs_temp = 656;
if (ys_temp < 32) ys_temp = 400;
if (!enable_overscan)
xs_temp -= 16;
if (((xs_temp != xsize) || (ys_temp != ysize) || video_force_resize_get())) {
xsize = xs_temp;
ysize = ys_temp;
set_screen_size(xsize, ysize + (enable_overscan ? 16 : 0));
if (video_force_resize_get())
video_force_resize_set(0);
}
if (enable_overscan) {
if (!dev->is_sl2 && vid->composite)
video_blit_memtoscreen(0, (vid->firstline - 4) << 1, 0, ((vid->lastline - vid->firstline) + 8) << 1,
xsize, ((vid->lastline - vid->firstline) + 8) << 1);
else
video_blit_memtoscreen_8(0, (vid->firstline - 4) << 1, 0, ((vid->lastline - vid->firstline) + 8) << 1,
xsize, ((vid->lastline - vid->firstline) + 8) << 1);
} else {
if (!dev->is_sl2 && vid->composite)
video_blit_memtoscreen(8, vid->firstline << 1, 0, (vid->lastline - vid->firstline) << 1,
xsize, (vid->lastline - vid->firstline) << 1);
else
video_blit_memtoscreen_8(8, vid->firstline << 1, 0, (vid->lastline - vid->firstline) << 1,
xsize, (vid->lastline - vid->firstline) << 1);
}
}
video_blit_memtoscreen_8(0, vid->firstline-4, 0, (vid->lastline - vid->firstline) + 8, xsize, (vid->lastline - vid->firstline) + 8);
frames++;
video_res_x = xsize - 16;
video_res_x = xsize;
video_res_y = ysize;
if ((vid->array[3] & 0x10) && (vid->mode & 1)) { /*320x200x16*/
video_res_x /= 2;
video_bpp = 4;
video_bpp = 4;
} else if (vid->array[3] & 0x10) { /*160x200x16*/
video_res_x /= 4;
video_bpp = 4;
} else if (vid->array[3] & 0x08) { /*640x200x4 - this implementation is a complete guess!*/
video_bpp = 2;
video_bpp = 2;
} else if (vid->mode & 1) {
video_res_x /= 8;
video_res_y /= vid->crtc[9] + 1;
@@ -1375,13 +1117,9 @@ vid_init(tandy_t *dev)
overscan_x = overscan_y = 16;
io_sethandler(0x0065, 1, vid_in,NULL,NULL, vid_out,NULL,NULL, dev);
timer_add(&vid->timer, vid_poll_sl, dev, 1);
} else {
} else
vid->b8000_mask = 0x3fff;
timer_add(&vid->timer, vid_poll, dev, 1);
}
timer_add(&vid->timer, vid_poll, dev, 1);
mem_mapping_add(&vid->mapping, 0xb8000, 0x08000,
vid_read,NULL,NULL, vid_write,NULL,NULL, NULL, 0, dev);
io_sethandler(0x03d0, 16,