Retro/pcem
Watch
1
0
Fork
You've already forked pcem
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
pcem/src/vid_pgc.c
SarahW 1242754343 Fix IM-1024 timing.
2019-04-24 17:48:00 +01:00

2477 lines
58 KiB
C
Raw Blame History

/*PGC emulation*/
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include "ibm.h"
#include "device.h"
#include "io.h"
#include "mem.h"
#include "timer.h"
#include "thread.h"
#include "video.h"
#include "vid_pgc.h"
#include <assert.h>
/* This implements just enough of the Professional Graphics Controller to
* act as a basis for the Vermont Microsystems IM-1024.
*
* PGC features implemented include:
* > The CGA-compatible display modes
* > Switching to and from native mode
* > Communicating with the host PC
*
* Numerous features are implemented partially or not at all, such as:
* > 2D drawing
* > 3D drawing
* > Command lists
* Some of these are marked TODO.
*
* The PGC has two display modes: CGA (in which it appears in the normal CGA
* memory and I/O ranges) and native (in which all functions are accessed
* through reads and writes to 1k of memory at 0xC6000). The PGC's 8088
* processor monitors this buffer and executes instructions left there
* for it. We simulate this behaviour with a separate thread.
*/
#define PGC_CGA_WIDTH 640
#define PGC_CGA_HEIGHT 400
static int pgc_parse_command(pgc_core_t *pgc, const pgc_command_t **pcmd);
int pgc_clist_byte(pgc_core_t *pgc, uint8_t *val);
static const char *pgc_err_msgs[] =
{
"Range \r",
"Integer \r",
"Memory \r",
"Overflow\r",
"Digit \r",
"Opcode \r",
"Running \r",
"Stack \r",
"Too long\r",
"Area \r",
"Missing \r"
};
#define HWORD(u) ((u) >> 16)
#define LWORD(u) ((u) & 0xFFFF)
/* Initial palettes */
uint32_t init_palette[6][256] =
{
#include "pgc_palettes.h"
};
/* When idle, the PGC drawing thread sleeps. pgc_wake() awakens it - but
* not immediately. Like the Voodoo, it has a short delay so that writes
* can be batched */
#define WAKE_DELAY (TIMER_USEC * 500)
void pgc_wake(pgc_core_t *pgc)
{
if (!timer_is_enabled(&pgc->wake_timer))
{
timer_set_delay_u64(&pgc->wake_timer, WAKE_DELAY);
}
}
/* When the wake timer expires, that's when the drawing thread is actually
* woken */
static void pgc_wake_timer(void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
PGCLOG(("pgc: Waking up\n"));
thread_set_event(pgc->pgc_wake_thread);
}
/* This is called by the drawing thread when it's waiting for the host
* to put more input in its input FIFO, or drain output from its output
* FIFO. */
void pgc_sleep(pgc_core_t *pgc)
{
PGCLOG(("pgc: Sleeping on %d %d %d 0x%02x 0x%02x\n",
pgc->waiting_input_fifo,
pgc->waiting_output_fifo,
pgc->waiting_error_fifo,
pgc->mapram[0x300], pgc->mapram[0x301]));
/* Race condition: If host wrote to the PGC during the pclog() that
* won't be noticed */
if (pgc->waiting_input_fifo && pgc->mapram[0x300] != pgc->mapram[0x301])
{
pgc->waiting_input_fifo = 0;
return;
}
/* Same if they read */
if (pgc->waiting_output_fifo && pgc->mapram[0x302] != (uint8_t)(pgc->mapram[0x303] - 1))
{
pgc->waiting_output_fifo = 0;
return;
}
thread_wait_event(pgc->pgc_wake_thread, -1);
thread_reset_event(pgc->pgc_wake_thread);
}
/* Switch between CGA mode (DISPLAY 1) and native mode (DISPLAY 0) */
void pgc_setdisplay(pgc_core_t *pgc, int cga)
{
PGCLOG(("pgc_setdisplay(%d): cga_selected=%d cga_enabled=%d\n",
cga, pgc->cga_selected, pgc->cga_enabled));
if (pgc->cga_selected != (pgc->cga_enabled && cga))
{
pgc->cga_selected = (pgc->cga_enabled && cga);
if (pgc->cga_selected)
{
mem_mapping_enable(&pgc->cga_mapping);
pgc->screenw = PGC_CGA_WIDTH;
pgc->screenh = PGC_CGA_HEIGHT;
}
else
{
mem_mapping_disable(&pgc->cga_mapping);
pgc->screenw = pgc->visw;
pgc->screenh = pgc->vish;
}
pgc_recalctimings(pgc);
}
}
/* Convert coordinates based on the current window / viewport to raster
* coordinates. */
void pgc_dto_raster(pgc_core_t *pgc, double *x, double *y)
{
/* double x0 = *x, y0 = *y; */
*x += (pgc->vp_x1 - pgc->win_x1);
*y += (pgc->vp_y1 - pgc->win_y1);
/* PGCLOG(("Coords to raster: (%f, %f) -> (%f, %f)\n", x0, y0, *x, *y)); */
}
/* Overloads that take ints */
void pgc_sto_raster(pgc_core_t *pgc, int16_t *x, int16_t *y)
{
double xd = *x, yd = *y;
pgc_dto_raster(pgc, &xd, &yd);
*x = (int16_t)xd;
*y = (int16_t)yd;
}
void pgc_ito_raster(pgc_core_t *pgc, int32_t *x, int32_t *y)
{
double xd = *x, yd = *y;
pgc_dto_raster(pgc, &xd, &yd);
*x = (int32_t)xd;
*y = (int32_t)yd;
}
/* Add a byte to a command list. We allow command lists to be
* arbitrarily large */
int pgc_commandlist_append(pgc_commandlist_t *list, uint8_t v)
{
if (list->listmax == 0 || list->list == NULL)
{
list->list = malloc(4096);
if (!list->list)
{
PGCLOG(("Out of memory initialising command list\n"));
return 0;
}
list->listmax = 4096;
}
while (list->wrptr >= list->listmax)
{
uint8_t *buf = realloc(list->list, 2 * list->listmax);
if (!buf)
{
PGCLOG(("Out of memory growing command list\n"));
return 0;
}
list->list = buf;
list->listmax *= 2;
}
list->list[list->wrptr++] = v;
return 1;
}
/* Beginning of a command list. Parse commands up to the next CLEND,
* storing them (in hex form) in the named command list. */
static void hndl_clbeg(pgc_core_t *pgc)
{
uint8_t param;
pgc_commandlist_t cl;
const pgc_command_t *cmd;
memset(&cl, 0, sizeof(cl));
if (!pgc_param_byte(pgc, &param)) return;
PGCLOG(("CLBEG(%d)\n", param));
while (1)
{
if (!pgc_parse_command(pgc, &cmd))
{
/* PGC has been reset */
return;
}
if (!cmd)
{
pgc_error(pgc, PGC_ERROR_OPCODE);
return;
}
else if (pgc->hex_command == 0x71) /* CLEND */
{
pgc->clist[param] = cl;
return;
}
else
{
if (!pgc_commandlist_append(&cl, pgc->hex_command))
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
return;
}
if (cmd->parser)
{
if (!(*cmd->parser)(pgc, &cl, cmd->p))
{
return;
}
}
}
}
}
static void hndl_clend(pgc_core_t *pgc)
{
/* Shouldn't happen outside a CLBEG */
}
/* Execute a command list. If one was already executing, remember it so
* we can return to it afterwards. */
static void hndl_clrun(pgc_core_t *pgc)
{
uint8_t param;
pgc_commandlist_t *clprev = pgc->clcur;
if (!pgc_param_byte(pgc, &param)) return;
pgc->clcur = &pgc->clist[param];
pgc->clcur->rdptr = 0;
pgc->clcur->repeat = 1;
pgc->clcur->chain = clprev;
}
/* Execute a command list multiple times. */
static void hndl_cloop(pgc_core_t *pgc)
{
uint8_t param;
int16_t repeat;
pgc_commandlist_t *clprev = pgc->clcur;
if (!pgc_param_byte(pgc, &param)) return;
if (!pgc_param_word(pgc, &repeat)) return;
pgc->clcur = &pgc->clist[param];
pgc->clcur->rdptr = 0;
pgc->clcur->repeat = repeat;
pgc->clcur->chain = clprev;
}
/* Read back a command list */
static void hndl_clread(pgc_core_t *pgc)
{
uint8_t param;
int n;
if (!pgc_param_byte(pgc, &param)) return;
for (n = 0; n < pgc->clist[param].wrptr; n++)
{
if (!pgc_result_byte(pgc, pgc->clist[param].list[n]))
return;
}
}
/* Delete a command list */
static void hndl_cldel(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc_param_byte(pgc, &param)) return;
memset(&pgc->clist[param], 0, sizeof(pgc_commandlist_t));
}
/* Clear the screen to a specified colour */
static void hndl_clears(pgc_core_t *pgc)
{
uint8_t param;
int y;
if (!pgc_param_byte(pgc, &param)) return;
for (y = 0; y < pgc->screenh; y++)
memset(pgc->vram + y * pgc->maxw, param, pgc->screenw);
}
/* Select drawing colour */
static void hndl_color(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc_param_byte(pgc, &param)) return;
pgc->colour = param;
PGCLOG(("COLOR(%d)\n", param));
}
/* Set drawing mode.
*
* 0 => Draw
* 1 => Invert
* 2 => XOR (IM-1024)
* 3 => AND (IM-1024)
*
*/
static void hndl_linfun(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc_param_byte(pgc, &param)) return;
/* TODO: Not range-checked. Strictly speaking we should limit to 0-1
* for the PGC and 0-3 for the IM-1024. */
pgc->draw_mode = param;
PGCLOG(("LINFUN(%d)\n", param));
}
/* Set the line drawing pattern */
static void hndl_linpat(pgc_core_t *pgc)
{
uint16_t param;
if (!pgc_param_word(pgc, (int16_t *)&param)) return;
pgc->line_pattern = param;
PGCLOG(("LINPAT(0x%04x)\n", param));
}
/* Set the polygon fill mode (0=hollow, 1=filled, 2=fast fill) */
static void hndl_prmfil(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc_param_byte(pgc, &param)) return;
PGCLOG(("PRMFIL(%d)\n", param));
if (param < 3)
{
pgc->fill_mode = param;
}
else
{
pgc_error(pgc, PGC_ERROR_RANGE);
}
}
/* Set the 2D drawing position */
static void hndl_move(pgc_core_t *pgc)
{
int32_t x = 0, y = 0;
if (!pgc_param_coord(pgc, &x)) return;
if (!pgc_param_coord(pgc, &y)) return;
pgc->x = x;
pgc->y = y;
PGCLOG(("MOVE %x.%04x,%x.%04x\n", HWORD(x), LWORD(x), HWORD(y), LWORD(y)));
}
/* Set the 3D drawing position */
static void hndl_move3(pgc_core_t *pgc)
{
int32_t x = 0, y = 0, z = 0;
if (!pgc_param_coord(pgc, &x)) return;
if (!pgc_param_coord(pgc, &y)) return;
if (!pgc_param_coord(pgc, &z)) return;
pgc->x = x;
pgc->y = y;
pgc->z = z;
}
/* Relative move (2D) */
static void hndl_mover(pgc_core_t *pgc)
{
int32_t x = 0, y = 0;
if (!pgc_param_coord(pgc, &x)) return;
if (!pgc_param_coord(pgc, &y)) return;
pgc->x += x;
pgc->y += y;
}
/* Relative move (3D) */
static void hndl_mover3(pgc_core_t *pgc)
{
int32_t x = 0, y = 0, z = 0;
if (!pgc_param_coord(pgc, &x)) return;
if (!pgc_param_coord(pgc, &y)) return;
if (!pgc_param_coord(pgc, &z)) return;
pgc->x += x;
pgc->y += y;
pgc->z += z;
}
/* Draw a line (using PGC fixed-point coordinates) */
uint16_t pgc_draw_line(pgc_core_t *pgc, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint16_t linemask)
{
PGCLOG(("pgc_draw_line: (%d,%d) to (%d,%d)\n", x0 >> 16, y0 >> 16,
x1 >> 16, y1 >> 16));
/* Convert from PGC fixed-point to device coordinates */
x0 >>= 16;
x1 >>= 16;
y0 >>= 16;
y1 >>= 16;
pgc_ito_raster(pgc, &x0, &y0);
pgc_ito_raster(pgc, &x1, &y1);
return pgc_draw_line_r(pgc, x0, y0, x1, y1, linemask);
}
/* Draw a line (using raster coordinates)
Bresenham's Algorithm from <https://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#C>
*
* The line pattern mask to use is passed in. The return value is the line
* pattern mask rotated by the number of points drawn.
*/
uint16_t pgc_draw_line_r(pgc_core_t *pgc, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint16_t linemask)
{
int32_t dx, dy, sx, sy, err, e2;
dx = abs(x1 - x0);
dy = abs(y1 - y0);
sx = (x0 < x1) ? 1 : -1;
sy = (y0 < y1) ? 1 : -1;
err = (dx > dy ? dx : -dy) / 2;
for(;;)
{
if (linemask & 0x8000)
{
pgc_plot(pgc, x0, y0);
linemask = (linemask << 1) | 1;
}
else
{
linemask = (linemask << 1);
}
if (x0 == x1 && y0 == y1) break;
e2 = err;
if (e2 > -dx) { err -= dy; x0 += sx; }
if (e2 < dy) { err += dx; y0 += sy; }
}
return linemask;
}
/* Draw a horizontal line in the current fill pattern
* (using raster coordinates) */
void pgc_fill_line_r(pgc_core_t *pgc, int32_t x0, int32_t x1, int32_t y0)
{
int32_t x;
int32_t mask = 0x8000 >> (x0 & 0x0F);
if (x0 > x1) { x = x1; x1 = x0; x0 = x; }
for (x = x0; x <= x1; x++)
{
if (pgc->fill_pattern[y0 & 0x0F] & mask)
pgc_plot(pgc, x, y0);
mask = mask >> 1;
if (mask == 0) mask = 0x8000;
}
}
/* For sorting polygon nodes */
static int compare_double(const void *a, const void *b)
{
const double *da = (const double *)a;
const double *db = (const double *)b;
if (*da > *db) return 1;
if (*da < *db) return -1;
return 0;
}
/* Draw a filled polygon (using PGC fixed-point coordinates) */
void pgc_fill_polygon(pgc_core_t *pgc,
unsigned corners, int32_t *x, int32_t *y)
{
double *nodex;
double *dx;
double *dy;
unsigned n, nodes, i, j;
double ymin, ymax, ypos;
PGCLOG(("pgc_fill_polygon(%d corners)\n", corners));
if (corners < 2) return; /* Degenerate polygon */
nodex = malloc(corners * sizeof(double));
dx = malloc(corners * sizeof(double));
dy = malloc(corners * sizeof(double));
if (!nodex || !dx || !dy) return;
ymin = ymax = y[0] / 65536.0;
for (n = 0; n < corners; n++)
{
/* Convert from PGC fixed-point to native floating-point */
dx[n] = x[n] / 65536.0;
dy[n] = y[n] / 65536.0;
if (dy[n] < ymin) ymin = dy[n];
if (dy[n] > ymax) ymax = dy[n];
}
/* Polygon fill. Based on <http://alienryderflex.com/polygon_fill/> */
/* For each row, work out where the polygon lines intersect with
* that row. */
for (ypos = ymin; ypos <= ymax; ypos++)
{
nodes = 0;
j = corners - 1;
for (i = 0; i < corners; i++)
{
if ((dy[i] < ypos && dy[j] >= ypos)
|| (dy[j] < ypos && dy[i] >= ypos)) /* Line crosses */
{
nodex[nodes++] = dx[i] + (ypos-dy[i])/(dy[j]-dy[i]) * (dx[j] - dx[i]);
}
j = i;
}
/* Sort the intersections */
if (nodes) qsort(nodex, nodes, sizeof(double), compare_double);
/*
PGCLOG(("pgc_fill_polygon ypos=%f nodes=%d ", ypos, nodes));
for (i = 0; i < nodes; i++)
{
PGCLOG(("%f;", nodex[i]));
}
PGCLOG(("\n"));
*/
/* And fill between them */
for (i = 0; i < nodes; i += 2)
{
int16_t x1 = nodex[i], x2 = nodex[i + 1],
y1 = ypos, y2 = ypos;
pgc_sto_raster(pgc, &x1, &y1);
pgc_sto_raster(pgc, &x2, &y2);
/* PGCLOG(("pgc_fill_polygon raster %d,%d to %d,%d\n",
x1, y1, x2, y2)); */
pgc_fill_line_r(pgc, x1, x2, y1);
}
}
free(nodex);
free(dx);
free(dy);
}
/* Draw a filled ellipse (using PGC fixed-point coordinates) */
void pgc_draw_ellipse(pgc_core_t *pgc, int32_t x, int32_t y)
{
/* Convert from PGC fixed-point to native floating-point */
double h = y / 65536.0;
double w = x / 65536.0;
double y0 = pgc->y / 65536.0;
double x0 = pgc->x / 65536.0;
double ypos = 0.0, xpos = 0.0;
double x1;
double xlast = 0.0;
int16_t linemask = pgc->line_pattern;
pgc_dto_raster(pgc, &x0, &y0);
PGCLOG(("Ellipse: Colour=%d Drawmode=%d fill=%d\n", pgc->colour,
pgc->draw_mode, pgc->fill_mode));
for (ypos = 0; ypos <= h; ypos++)
{
if (ypos == 0)
{
if (pgc->fill_mode)
{
pgc_fill_line_r(pgc, x0 - w, x0 + w, y0);
}
if (linemask & 0x8000)
{
pgc_plot(pgc, x0 + w, y0);
pgc_plot(pgc, x0 - w, y0);
linemask = (linemask << 1) | 1;
}
else
{
linemask = linemask << 1;
}
xlast = w;
}
else
{
x1 = sqrt((h * h) - (ypos * ypos)) * w / h;
if (pgc->fill_mode)
{
pgc_fill_line_r(pgc, x0 - x1, x0 + x1, y0 + ypos);
pgc_fill_line_r(pgc, x0 - x1, x0 + x1, y0 - ypos);
}
/* Draw border */
for (xpos = xlast; xpos >= x1; xpos--)
{
if (linemask & 0x8000)
{
pgc_plot(pgc, x0 + xpos, y0 + ypos);
pgc_plot(pgc, x0 - xpos, y0 + ypos);
pgc_plot(pgc, x0 + xpos, y0 - ypos);
pgc_plot(pgc, x0 - xpos, y0 - ypos);
linemask = (linemask << 1) | 1;
}
else
{
linemask = linemask << 1;
}
}
xlast = x1;
}
}
}
/* Handle the ELIPSE (sic) command */
static void hndl_ellipse(pgc_core_t *pgc)
{
int32_t x = 0, y = 0;
if (!pgc_param_coord(pgc, &x)) return;
if (!pgc_param_coord(pgc, &y)) return;
pgc_draw_ellipse(pgc, x, y);
}
/* Handle the POLY command */
static void hndl_poly(pgc_core_t *pgc)
{
uint8_t count;
int32_t x[256];
int32_t y[256];
int32_t n;
if (!pgc_param_byte(pgc, &count)) return;
for (n = 0; n < count; n++)
{
if (!pgc_param_coord(pgc, &x[n])) return;
if (!pgc_param_coord(pgc, &y[n])) return;
}
PGCLOG(("POLY (%d)\n", count));
}
/* Parse but don't execute a POLY command (for adding to a command list) */
static int parse_poly(pgc_core_t *pgc, pgc_commandlist_t *cl, int c)
{
uint8_t count;
PGCLOG(("parse_poly\n"));
if (!pgc_param_byte(pgc, &count)) return 0;
PGCLOG(("parse_poly: count=%02x\n", count));
if (!pgc_commandlist_append(cl, count))
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
return 0;
}
PGCLOG(("parse_poly: parse %d coords\n", 2 * count));
return pgc_parse_coords(pgc, cl, 2 * count);
}
/* Parse but don't execute a command with a fixed number of byte parameters */
int pgc_parse_bytes(pgc_core_t *pgc, pgc_commandlist_t *cl, int count)
{
uint8_t *param = malloc(count);
int n;
if (!param)
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
return 0;
}
for (n = 0; n < count; n++)
{
if (!pgc_param_byte(pgc, &param[n]))
{
free(param);
return 0;
}
}
for (n = 0; n < count; n++)
{
if (!pgc_commandlist_append(cl, param[n]))
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
free(param);
return 0;
}
}
free(param);
return 1;
}
/* Parse but don't execute a command with a fixed number of word parameters */
int pgc_parse_words(pgc_core_t *pgc, pgc_commandlist_t *cl, int count)
{
int16_t *param = malloc(count * sizeof(int16_t));
int n;
if (!param)
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
return 0;
}
for (n = 0; n < count; n++)
{
if (!pgc_param_word(pgc, &param[n])) return 0;
}
for (n = 0; n < count; n++)
{
if (!pgc_commandlist_append(cl, param[n] & 0xFF) ||
!pgc_commandlist_append(cl, param[n] >> 8))
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
free(param);
return 0;
}
}
return 1;
}
/* Parse but don't execute a command with a fixed number of coord parameters */
int pgc_parse_coords(pgc_core_t *pgc, pgc_commandlist_t *cl, int count)
{
int32_t *param = malloc(count * sizeof(int32_t));
int n;
if (!param)
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
return 0;
}
for (n = 0; n < count; n++)
{
if (!pgc_param_coord(pgc, &param[n])) return 0;
}
/* Here's how the real PGC serialises coords:
*
* 100.5 -> 64 00 00 80 ie 0064.8000
* 100.3 -> 64 00 CD 4C ie 0064.4CCD
*
*/
for (n = 0; n < count; n++)
{
/* Serialise integer part */
if (!pgc_commandlist_append(cl, (param[n] >> 16) & 0xFF) ||
!pgc_commandlist_append(cl, (param[n] >> 24) & 0xFF) ||
/* Serialise fraction part */
!pgc_commandlist_append(cl, (param[n] ) & 0xFF) ||
!pgc_commandlist_append(cl, (param[n] >> 8) & 0xFF))
{
pgc_error(pgc, PGC_ERROR_OVERFLOW);
free(param);
return 0;
}
}
return 1;
}
/* Handle the DISPLAY command */
static void hndl_display(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc_param_byte(pgc, &param)) return;
PGCLOG(("DISPLAY(%d)\n", param));
if (param > 1)
{
pgc_error(pgc, PGC_ERROR_RANGE);
}
else
{
pgc_setdisplay(pgc, param);
}
}
/* Handle the IMAGEW command (memory to screen blit) */
static void hndl_imagew(pgc_core_t *pgc)
{
int16_t row, col1, col2;
uint8_t v1, v2;
if (!pgc_param_word(pgc, &row)) return;
if (!pgc_param_word(pgc, &col1)) return;
if (!pgc_param_word(pgc, &col2)) return;
if (row >= pgc->screenh || col1 >= pgc->maxw || col2 >= pgc->maxw)
{
pgc_error(pgc, PGC_ERROR_RANGE);
return;
}
/* In ASCII mode, what is written is a stream of bytes */
if (pgc->ascii_mode)
{
while (col1 <= col2)
{
if (!pgc_param_byte(pgc, &v1)) return;
pgc_write_pixel(pgc, col1, row, v1);
++col1;
}
return;
}
else /* In hex mode, it's RLE compressed */
{
while (col1 <= col2)
{
if (!pgc_param_byte(pgc, &v1)) return;
if (v1 & 0x80) /* Literal run */
{
v1 -= 0x7F;
while (col1 <= col2 && v1 != 0)
{
if (!pgc_param_byte(pgc, &v2)) return;
pgc_write_pixel(pgc, col1, row, v2);
++col1;
--v1;
}
}
else /* Repeated run */
{
if (!pgc_param_byte(pgc, &v2)) return;
++v1;
while (col1 <= col2 && v1 != 0)
{
pgc_write_pixel(pgc, col1, row, v2);
++col1;
--v1;
}
}
}
}
}
/* Select one of the built-in palettes */
static void pgc_init_lut(pgc_core_t *pgc, int param)
{
if (param >= 0 && param < 6)
{
memcpy(pgc->palette, init_palette[param], sizeof(pgc->palette));
}
else if (param == 0xFF)
{
memcpy(pgc->palette, pgc->userpal, sizeof(pgc->palette));
}
else
{
pgc_error(pgc, PGC_ERROR_RANGE);
}
}
/* Save the current palette */
static void hndl_lutsav(pgc_core_t *pgc)
{
memcpy(pgc->userpal, pgc->palette, sizeof(pgc->palette));
}
/* Handle LUTINT (select palette) */
static void hndl_lutint(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc_param_byte(pgc, &param)) return;
pgc_init_lut(pgc, param);
}
/* Handle LUTRD (read palette register) */
static void hndl_lutrd(pgc_core_t *pgc)
{
uint8_t param;
uint32_t col;
if (!pgc_param_byte(pgc, &param)) return;
col = pgc->palette[param];
pgc_result_byte(pgc, (col >> 20) & 0x0F);
pgc_result_byte(pgc, (col >> 12) & 0x0F);
pgc_result_byte(pgc, (col >> 4) & 0x0F);
}
/* Handle LUT (write palette register) */
static void hndl_lut(pgc_core_t *pgc)
{
uint8_t param[4];
int n;
for (n = 0; n < 4; n++)
{
if (!pgc_param_byte(pgc, &param[n])) return;
if (n > 0 && param[n] > 15)
{
pgc_error(pgc, PGC_ERROR_RANGE);
param[n] &= 0x0F;
}
}
pgc->palette[param[0]] = makecol((param[1] * 0x11),
(param[2] * 0x11),
(param[3] * 0x11));
}
/* LUT8RD and LUT8 are extensions implemented by several PGC clones, so
* here are functions that implement them even though they aren't
* used by the PGC */
void pgc_hndl_lut8rd(pgc_core_t *pgc)
{
uint8_t param;
uint32_t col;
if (!pgc_param_byte(pgc, &param)) return;
col = pgc->palette[param];
pgc_result_byte(pgc, (col >> 16) & 0xFF);
pgc_result_byte(pgc, (col >> 8) & 0xFF);
pgc_result_byte(pgc, col & 0xFF);
}
void pgc_hndl_lut8(pgc_core_t *pgc)
{
uint8_t param[4];
int n;
for (n = 0; n < 4; n++)
{
if (!pgc_param_byte(pgc, &param[n])) return;
}
pgc->palette[param[0]] = makecol((param[1]), (param[2]), (param[3]));
}
/* Handle AREAPT (set 16x16 fill pattern) */
static void hndl_areapt(pgc_core_t *pgc)
{
int16_t pattern[16];
int n;
for (n = 0; n < 16; n++)
{
if (!pgc_param_word(pgc, &pattern[n])) return;
}
memcpy(pgc->fill_pattern, pattern, sizeof(pgc->fill_pattern));
PGCLOG(("AREAPT(%04x %04x %04x %04x...)\n",
pattern[0] & 0xFFFF, pattern[1] & 0xFFFF,
pattern[2] & 0xFFFF, pattern[3] & 0xFFFF));
}
/* Handle CA (select ASCII mode) */
static void hndl_ca(pgc_core_t *pgc)
{
pgc->ascii_mode = 1;
}
/* Handle CX (select hex mode) */
static void hndl_cx(pgc_core_t *pgc)
{
pgc->ascii_mode = 0;
}
/* CA and CX remain valid in hex mode; they are handled as command 0x43 ('C')
* with a one-byte parameter */
static void hndl_c(pgc_core_t *pgc)
{
uint8_t param;
if (!pgc->inputbyte(pgc, &param)) return;
if (param == 'A') pgc->ascii_mode = 1;
if (param == 'X') pgc->ascii_mode = 0;
}
/* RESETF resets the PGC */
static void hndl_resetf(pgc_core_t *pgc)
{
pgc_reset(pgc);
}
/* TJUST sets text justify settings */
static void hndl_tjust(pgc_core_t *pgc)
{
uint8_t param[2];
if (!pgc->inputbyte(pgc, &param[0])) return;
if (!pgc->inputbyte(pgc, &param[1])) return;
if (param[0] >= 1 && param[0] <= 3 &&
param[1] >= 1 && param[1] <= 3)
{
pgc->tjust_h = param[0];
pgc->tjust_v = param[1];
}
else
{
pgc_error(pgc, PGC_ERROR_RANGE);
}
}
/* TSIZE controls text horizontal spacing */
static void hndl_tsize(pgc_core_t *pgc)
{
int32_t param = 0;
if (!pgc_param_coord(pgc, &param)) return;
pgc->tsize = param;
PGCLOG(("TSIZE %d\n", param));
}
/* VWPORT sets up the viewport (roughly, the clip rectangle) in raster
* coordinates, measured from the bottom left of the screen */
static void hndl_vwport(pgc_core_t *pgc)
{
int16_t x1, x2, y1, y2;
if (!pgc_param_word(pgc, &x1)) return;
if (!pgc_param_word(pgc, &x2)) return;
if (!pgc_param_word(pgc, &y1)) return;
if (!pgc_param_word(pgc, &y2)) return;
PGCLOG(("VWPORT %d,%d,%d,%d\n", x1,x2,y1,y2));
pgc->vp_x1 = x1;
pgc->vp_x2 = x2;
pgc->vp_y1 = y1;
pgc->vp_y2 = y2;
}
/* WINDOW defines the coordinate system in use */
static void hndl_window(pgc_core_t *pgc)
{
int16_t x1, x2, y1, y2;
if (!pgc_param_word(pgc, &x1)) return;
if (!pgc_param_word(pgc, &x2)) return;
if (!pgc_param_word(pgc, &y1)) return;
if (!pgc_param_word(pgc, &y2)) return;
PGCLOG(("WINDOW %d,%d,%d,%d\n", x1,x2,y1,y2));
pgc->win_x1 = x1;
pgc->win_x2 = x2;
pgc->win_y1 = y1;
pgc->win_y2 = y2;
}
/* The list of commands implemented by this mini-PGC. In order to support
* the original PGC and clones, we support two lists; core commands (listed
* below) and subclass commands (listed in the clone).
*
* Each row has five parameters:
* ASCII-mode command
* Hex-mode command
* Function that executes this command
* Function that parses this command when building a command list
* Parameter for the parse function
*
* TODO: This list omits numerous commands present in a genuine PGC
* (ARC, AREA, AREABC, BUFFER, CIRCLE etc etc).
* TODO: Some commands don't have a parse function (for example, IMAGEW)
*
* The following ASCII entries have special meaning:
* ~~~~~~ command is valid only in hex mode
* ****** end of subclass command list, now process core command list
* @@@@@@ end of core command list
*
*/
static const pgc_command_t pgc_core_commands[] =
{
{ "AREAPT", 0xE7, hndl_areapt, pgc_parse_words, 16 },
{ "AP", 0xE7, hndl_areapt, pgc_parse_words, 16 },
{ "~~~~~~", 0x43, hndl_c }, /* Handle CA / CX in hex mode */
{ "CA", 0xD2, hndl_ca },
{ "CLBEG", 0x70, hndl_clbeg },
{ "CB", 0x70, hndl_clbeg },
{ "CLDEL", 0x74, hndl_cldel, pgc_parse_bytes, 1 },
{ "CD", 0x74, hndl_cldel, pgc_parse_bytes, 1 },
{ "CLEND", 0x71, hndl_clend },
{ "CLRUN", 0x72, hndl_clrun, pgc_parse_bytes, 1 },
{ "CR", 0x72, hndl_clrun, pgc_parse_bytes, 1 },
{ "CLRD", 0x75, hndl_clread, pgc_parse_bytes, 1 },
{ "CRD", 0x75, hndl_clread, pgc_parse_bytes, 1 },
{ "CLOOP", 0x73, hndl_cloop },
{ "CL", 0x73, hndl_cloop },
{ "CLEARS", 0x0F, hndl_clears, pgc_parse_bytes, 1 },
{ "CLS", 0x0F, hndl_clears, pgc_parse_bytes, 1 },
{ "COLOR", 0x06, hndl_color, pgc_parse_bytes, 1 },
{ "C", 0x06, hndl_color, pgc_parse_bytes, 1 },
{ "CX", 0xD1, hndl_cx },
{ "DISPLA", 0xD0, hndl_display, pgc_parse_bytes, 1 },
{ "DI", 0xD0, hndl_display, pgc_parse_bytes, 1 },
{ "ELIPSE", 0x39, hndl_ellipse, pgc_parse_coords, 2 },
{ "EL", 0x39, hndl_ellipse, pgc_parse_coords, 2 },
{ "IMAGEW", 0xD9, hndl_imagew },
{ "IW", 0xD9, hndl_imagew },
{ "LINFUN", 0xEB, hndl_linfun, pgc_parse_bytes, 1 },
{ "LF", 0xEB, hndl_linfun, pgc_parse_bytes, 1 },
{ "LINPAT", 0xEA, hndl_linpat, pgc_parse_words, 1 },
{ "LP", 0xEA, hndl_linpat, pgc_parse_words, 1 },
{ "LUTINT", 0xEC, hndl_lutint, pgc_parse_bytes, 1 },
{ "LI", 0xEC, hndl_lutint, pgc_parse_bytes, 1 },
{ "LUTRD", 0x50, hndl_lutrd, pgc_parse_bytes, 1 },
{ "LUTSAV", 0xED, hndl_lutsav, NULL, 0 },
{ "LUT", 0xEE, hndl_lut, pgc_parse_bytes, 4 },
{ "MOVE", 0x10, hndl_move, pgc_parse_coords, 2 },
{ "M", 0x10, hndl_move, pgc_parse_coords, 2 },
{ "MOVE3", 0x12, hndl_move3, pgc_parse_coords, 3 },
{ "M3", 0x12, hndl_move3, pgc_parse_coords, 3 },
{ "MOVER", 0x11, hndl_mover, pgc_parse_coords, 2 },
{ "MR", 0x11, hndl_mover, pgc_parse_coords, 2 },
{ "MOVER3", 0x13, hndl_mover3, pgc_parse_coords, 3 },
{ "MR3", 0x13, hndl_mover3, pgc_parse_coords, 3 },
{ "PRMFIL", 0xE9, hndl_prmfil, pgc_parse_bytes, 1 },
{ "PF", 0xE9, hndl_prmfil, pgc_parse_bytes, 1 },
{ "POLY", 0x30, hndl_poly, parse_poly },
{ "P", 0x30, hndl_poly, parse_poly },
{ "RESETF", 0x04, hndl_resetf, NULL, 0 },
{ "RF", 0x04, hndl_resetf, NULL, 0 },
{ "TJUST", 0x85, hndl_tjust, pgc_parse_bytes, 2 },
{ "TJ", 0x85, hndl_tjust, pgc_parse_bytes, 2 },
{ "TSIZE", 0x81, hndl_tsize, pgc_parse_coords, 1 },
{ "TS", 0x81, hndl_tsize, pgc_parse_coords, 1 },
{ "VWPORT", 0xB2, hndl_vwport, pgc_parse_words, 4 },
{ "VWP", 0xB2, hndl_vwport, pgc_parse_words, 4 },
{ "WINDOW", 0xB3, hndl_window, pgc_parse_words, 4 },
{ "WI", 0xB3, hndl_window, pgc_parse_words, 4 },
{ "@@@@@@", 0x00, NULL }
};
/* Writes to CGA registers are copied into the transfer memory buffer */
void pgc_out(uint16_t addr, uint8_t val, void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
switch(addr)
{
case 0x3D0: case 0x3D2: case 0x3D4: case 0x3D6:
pgc->mapram[0x3D0] = val; break;
case 0x3D1: case 0x3D3: case 0x3D5: case 0x3D7:
if (pgc->mapram[0x3D0] < 18)
{
pgc->mapram[0x3E0 + pgc->mapram[0x3D0]] = val;
}
break;
case 0x3D8: pgc->mapram[0x3D8] = val; break;
case 0x3D9: pgc->mapram[0x3D9] = val; break;
}
}
/* Read back the CGA registers */
uint8_t pgc_in(uint16_t addr, void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
switch(addr)
{
case 0x3D0: case 0x3D2: case 0x3D4: case 0x3D6:
return pgc->mapram[0x3D0];
case 0x3D1: case 0x3D3: case 0x3D5: case 0x3D7:
if (pgc->mapram[0x3D0] < 18)
{
return pgc->mapram[0x3E0 + pgc->mapram[0x3D0]];
}
return 0xFF;
case 0x3D8: return pgc->mapram[0x3D8];
case 0x3D9: return pgc->mapram[0x3D9];
case 0x3DA: return pgc->mapram[0x3DA];
}
return 0xFF;
}
/* Memory write to the transfer buffer */
void pgc_write(uint32_t addr, uint8_t val, void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
/* It seems variable whether the PGC maps 1k or 2k at 0xC6000.
* Map 2k here in case a clone requires it */
if (addr >= 0xC6000 && addr < 0xC6800)
{
addr &= 0x7FF;
/* If one of the FIFOs has been updated, this may cause
* the drawing thread to be woken */
if (pgc->mapram[addr] != val)
{
pgc->mapram[addr] = val;
switch (addr)
{
case 0x300: /* Input write pointer */
if (pgc->waiting_input_fifo &&
pgc->mapram[0x300] != pgc->mapram[0x301])
{
pgc->waiting_input_fifo = 0;
pgc_wake(pgc);
}
break;
case 0x303: /* Output read pointer */
if (pgc->waiting_output_fifo &&
pgc->mapram[0x302] != (uint8_t)(pgc->mapram[0x303] - 1))
{
pgc->waiting_output_fifo = 0;
pgc_wake(pgc);
}
break;
case 0x305: /* Error read pointer */
if (pgc->waiting_error_fifo &&
pgc->mapram[0x304] != (uint8_t)(pgc->mapram[0x305] - 1))
{
pgc->waiting_error_fifo = 0;
pgc_wake(pgc);
}
break;
case 0x306: /* Cold start flag */
/* XXX This should be in IM-1024 specific code */
pgc->mapram[0x306] = 0;
break;
case 0x030C: /* Display type */
pgc_setdisplay(p, pgc->mapram[0x30C]);
pgc->mapram[0x30D] = pgc->mapram[0x30C];
break;
case 0x3FF: /* Reboot the PGC
(handled on core thread) */
pgc_wake(pgc);
break;
} // end switch (addr)
}
}
if (addr >= 0xB8000 && addr < 0xBC000 && pgc->cga_selected)
{
addr &= 0x3FFF;
pgc->cga_vram[addr] = val;
}
}
uint8_t pgc_read(uint32_t addr, void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
if (addr >= 0xC6000 && addr < 0xC6800)
{
addr &= 0x7FF;
return pgc->mapram[addr];
}
if (addr >= 0xB8000 && addr < 0xBC000 && pgc->cga_selected)
{
addr &= 0x3FFF;
return pgc->cga_vram[addr];
}
return 0xFF;
}
/* Called by the drawing thread to read the next byte from the input
* buffer. If no byte available will sleep until one is. Returns 0 if
* a PGC reset has been triggered by a write to 0xC63FF */
int pgc_input_byte(pgc_core_t *pgc, uint8_t *result)
{
/* If input buffer empty, wait for it to fill */
while (pgc->mapram[0x300] == pgc->mapram[0x301])
{
pgc->waiting_input_fifo = 1;
pgc_sleep(pgc);
}
if (pgc->mapram[0x3FF]) /* Reset triggered */
{
pgc_reset(pgc);
return 0;
}
*result = pgc->mapram[pgc->mapram[0x301]];
++pgc->mapram[0x301];
return 1;
}
/* Called by the drawing thread to write a byte to the output buffer.
* If buffer is full will sleep until it is not. Returns 0 if
* a PGC reset has been triggered by a write to 0xC63FF */
int pgc_output_byte(pgc_core_t *pgc, uint8_t val)
{
/* If output buffer full, wait for it to empty */
while (pgc->mapram[0x302] == (uint8_t)(pgc->mapram[0x303] - 1))
{
PGCLOG(("Output buffer state: %02x %02x Sleeping\n",
pgc->mapram[0x302], pgc->mapram[0x303]));
pgc->waiting_output_fifo = 1;
pgc_sleep(pgc);
}
if (pgc->mapram[0x3FF]) /* Reset triggered */
{
pgc_reset(pgc);
return 0;
}
pgc->mapram[0x100 + pgc->mapram[0x302]] = val;
++pgc->mapram[0x302];
/*
PGCLOG(("Output %02x: new state: %02x %02x\n", val,
pgc->mapram[0x302], pgc->mapram[0x303])); */
return 1;
}
/* Helper to write an entire string to the output buffer */
int pgc_output_string(pgc_core_t *pgc, const char *s)
{
while (*s)
{
if (!pgc_output_byte(pgc, *s)) return 0;
++s;
}
return 1;
}
/* As pgc_output_byte, for the error buffer */
int pgc_error_byte(pgc_core_t *pgc, uint8_t val)
{
/* If error buffer full, wait for it to empty */
while (pgc->mapram[0x304] == pgc->mapram[0x305] - 1)
{
pgc->waiting_error_fifo = 1;
pgc_sleep(pgc);
}
if (pgc->mapram[0x3FF]) /* Reset triggered */
{
pgc_reset(pgc);
return 0;
}
pgc->mapram[0x200 + pgc->mapram[0x304]] = val;
++pgc->mapram[0x304];
return 1;
}
/* As pgc_output_string, for the error buffer */
int pgc_error_string(pgc_core_t *pgc, const char *s)
{
while (*s)
{
if (!pgc_error_byte(pgc, *s)) return 0;
++s;
}
return 1;
}
/* Report an error, either in ASCII or in hex */
int pgc_error(pgc_core_t *pgc, int err)
{
if (pgc->mapram[0x307]) /* Errors enabled? */
{
if (pgc->ascii_mode)
{
if (err >= PGC_ERROR_RANGE && err <= PGC_ERROR_MISSING)
return pgc_error_string(pgc, pgc_err_msgs[err]);
return pgc_error_string(pgc, "Unknown error\r");
}
else
{
return pgc_error_byte(pgc, err);
}
}
return 1;
}
static inline int is_whitespace(char ch)
{
return (ch != 0 && strchr(" \r\n\t,;()+-", ch) != NULL);
}
/* Read a byte and interpret as ASCII: ignore control characters other than
* CR, LF or tab. */
int pgc_input_char(pgc_core_t *pgc, char *result)
{
uint8_t ch;
while (1)
{
if (!pgc->inputbyte(pgc, &ch)) return 0;
ch &= 0x7F;
if (ch == '\r' || ch == '\n' || ch == '\t' || ch >= ' ')
{
*result = toupper(ch);
return 1;
}
}
}
/* Parameter passed is not a number: abort */
static int err_digit(pgc_core_t *pgc)
{
uint8_t asc;
do /* Swallow everything until the next separator */
{
if (!pgc->inputbyte(pgc, &asc)) return 0;
}
while (!is_whitespace(asc));
pgc_error(pgc, PGC_ERROR_DIGIT);
return 0;
}
typedef enum parse_state_t
{
PS_MAIN,
PS_FRACTION,
PS_EXPONENT
} parse_state_t;
/* Read in a PGC coordinate, either as hex (4 bytes) or ASCII (xxxx.yyyyEeee)
* Returns 0 if PGC reset detected while the value is being read */
int pgc_param_coord(pgc_core_t *pgc, int32_t *value)
{
uint8_t asc;
int sign = 1;
int esign = 1;
int n;
uint16_t dp = 1;
uint16_t integer = 0;
uint16_t frac = 0;
uint16_t exponent = 0;
uint32_t res;
parse_state_t state = PS_MAIN;
uint8_t encoded[4];
/* If there is a command list running, pull the bytes out of that
* command list */
if (pgc->clcur)
{
for (n = 0; n < 4; n++)
{
if (!pgc_clist_byte(pgc, &encoded[n])) return 0;
}
integer = (((int16_t)encoded[1]) << 8) | encoded[0];
frac = (((int16_t)encoded[3]) << 8) | encoded[2];
*value = (((int32_t)integer) << 16) | frac;
return 1;
}
/* If in hex mode, read in the encoded integer and fraction parts
* from the hex stream */
if (!pgc->ascii_mode)
{
for (n = 0; n < 4; n++)
{
if (!pgc->inputbyte(pgc, &encoded[n])) return 0;
}
integer = (((int16_t)encoded[1]) << 8) | encoded[0];
frac = (((int16_t)encoded[3]) << 8) | encoded[2];
*value = (((int32_t)integer) << 16) | frac;
return 1;
}
/* Parsing an ASCII value */
/* Skip separators */
do
{
if (!pgc->inputbyte(pgc, &asc)) return 0;
if (asc == '-') sign = -1;
}
while (is_whitespace(asc));
/* There had better be a digit next */
if (!isdigit(asc))
{
pgc_error(pgc, PGC_ERROR_MISSING);
return 0;
}
do
{
switch (asc)
{
/* Decimal point is acceptable in 'main' state (start of fraction)
* not otherwise */
case '.':
if (state == PS_MAIN)
{
if (!pgc->inputbyte(pgc, &asc)) return 0;
state = PS_FRACTION;
continue;
}
else
{
pgc_error(pgc, PGC_ERROR_MISSING);
return err_digit(pgc);
}
break;
/* Scientific notation */
case 'd': case 'D': case 'e': case 'E':
esign = 1;
if (!pgc->inputbyte(pgc, &asc)) return 0;
if (asc == '-')
{
sign = -1;
if (!pgc->inputbyte(pgc, &asc)) return 0;
}
state = PS_EXPONENT;
continue;
/* Should be a number or a separator */
default:
if (is_whitespace(asc)) break;
if (!isdigit(asc))
{
pgc_error(pgc, PGC_ERROR_MISSING);
return err_digit(pgc);
}
asc -= '0'; /* asc is digit */
switch (state)
{
case PS_MAIN:
integer = (integer * 10)+asc;
if (integer & 0x8000) /* Overflow */
{
pgc_error(pgc, PGC_ERROR_RANGE);
integer = 0x7FFF;
}
break;
case PS_FRACTION:
frac = (frac * 10)+asc;
dp *= 10;
break;
case PS_EXPONENT:
exponent = (exponent * 10)+asc;
break;
}
}
if (!pgc->inputbyte(pgc, &asc)) return 0;
}
while (!is_whitespace(asc));
res = (frac << 16) / dp;
PGCLOG(("integer=%u frac=%u exponent=%u dp=%d res=0x%08x\n",
integer, frac, exponent, dp, res));
res = (res & 0xFFFF) | (integer << 16);
if (exponent)
{
for (n = 0; n < exponent; n++)
{
if (esign > 0) res *= 10;
else res /= 10;
}
}
*value = sign*res;
return 1;
}
/* Pull the next byte from the current command list */
int pgc_clist_byte(pgc_core_t *pgc, uint8_t *val)
{
if (pgc->clcur == NULL) return 0;
if (pgc->clcur->rdptr < pgc->clcur->wrptr)
{
*val = pgc->clcur->list[pgc->clcur->rdptr++];
}
else
{
*val = 0;
}
/* If we've reached the end, reset to the beginning and
* (if repeating) run the repeat */
if (pgc->clcur->rdptr >= pgc->clcur->wrptr)
{
pgc->clcur->rdptr = 0;
--pgc->clcur->repeat;
if (pgc->clcur->repeat == 0)
{
pgc->clcur = pgc->clcur->chain;
}
}
return 1;
}
/* Read in a byte, either as hex (1 byte) or ASCII (decimal).
* Returns 0 if PGC reset detected while the value is being read */
int pgc_param_byte(pgc_core_t *pgc, uint8_t *val)
{
int32_t c;
if (pgc->clcur) return pgc_clist_byte(pgc, val);
if (!pgc->ascii_mode) return pgc->inputbyte(pgc, val);
if (!pgc_param_coord(pgc, &c)) return 0;
c = (c >> 16); /* Drop fractional part */
if (c > 255)
{
pgc_error(pgc, PGC_ERROR_RANGE);
return 0;
}
*val = (uint8_t)c;
return 1;
}
/* Read in a word, either as hex (2 bytes) or ASCII (decimal).
* Returns 0 if PGC reset detected while the value is being read */
int pgc_param_word(pgc_core_t *pgc, int16_t *val)
{
int32_t c;
if (pgc->clcur)
{
uint8_t lo, hi;
if (!pgc_clist_byte(pgc, &lo)) return 0;
if (!pgc_clist_byte(pgc, &hi)) return 0;
*val = (((int16_t)hi) << 8) | lo;
return 1;
}
if (!pgc->ascii_mode)
{
uint8_t lo, hi;
if (!pgc->inputbyte(pgc, &lo)) return 0;
if (!pgc->inputbyte(pgc, &hi)) return 0;
*val = (((int16_t)hi) << 8) | lo;
return 1;
}
if (!pgc_param_coord(pgc, &c)) return 0;
c = (c >> 16);
if (c > 0x7FFF || c < -0x7FFF)
{
pgc_error(pgc, PGC_ERROR_RANGE);
return 0;
}
*val = (int16_t)c;
return 1;
}
/* Output a byte, either as hex or ASCII depending on the mode */
int pgc_result_byte(pgc_core_t *pgc, uint8_t val)
{
char buf[20];
if (!pgc->ascii_mode) return pgc_output_byte(pgc, val);
if (pgc->result_count)
{
if (!pgc_output_byte(pgc, ',')) return 0;
}
sprintf(buf, "%d", val);
++pgc->result_count;
return pgc_output_string(pgc, buf);
}
/* Output a word, either as hex or ASCII depending on the mode */
int pgc_result_word(pgc_core_t *pgc, int16_t val)
{
char buf[20];
if (!pgc->ascii_mode)
{
if (!pgc_output_byte(pgc, val & 0xFF)) return 0;
return pgc_output_byte(pgc, val >> 8);
}
if (pgc->result_count)
{
if (!pgc_output_byte(pgc, ',')) return 0;
}
sprintf(buf, "%d", val);
++pgc->result_count;
return pgc_output_string(pgc, buf);
}
/* Write a screen pixel (x and y are raster coordinates, ink is the
* value to write) */
void pgc_write_pixel(pgc_core_t *pgc, uint16_t x, uint16_t y, uint8_t ink)
{
uint8_t *vram;
/* Suppress out-of-range writes; clip to viewport */
if (x < pgc->vp_x1 || x > pgc->vp_x2 || x >= pgc->maxw ||
y < pgc->vp_y1 || y > pgc->vp_y2 || y >= pgc->maxh)
{
PGCLOG(("pgc_write_pixel clipped: (%d,%d) "
"vp_x1=%d vp_y1=%d vp_x2=%d vp_y2=%d "
"ink=0x%02x\n", x, y,
pgc->vp_x1, pgc->vp_y1,
pgc->vp_x2, pgc->vp_y2, ink));
return;
}
vram = pgc_vram_addr(pgc, x, y);
if (vram) *vram = ink;
}
/* Read a screen pixel (x and y are raster coordinates) */
uint8_t pgc_read_pixel(pgc_core_t *pgc, uint16_t x, uint16_t y)
{
uint8_t *vram;
/* Suppress out-of-range reads */
if (x >= pgc->maxw || y >= pgc->maxh)
{
return 0;
}
vram = pgc_vram_addr(pgc, x, y);
if (vram) return *vram;
return 0;
}
/* Plot a point in the current colour and draw mode. Raster coordinates. */
void pgc_plot(pgc_core_t *pgc, uint16_t x, uint16_t y)
{
uint8_t *vram;
/* Only allow plotting within the current viewport. */
if (x < pgc->vp_x1 || x > pgc->vp_x2 || x >= pgc->maxw ||
y < pgc->vp_y1 || y > pgc->vp_y2 || y >= pgc->maxh)
{
PGCLOG(("pgc_plot clipped: (%d,%d) %d <= x <= %d; %d <= y <= %d; "
"mode=%d ink=0x%02x\n", x, y,
pgc->vp_x1, pgc->vp_x2, pgc->vp_y1, pgc->vp_y2,
pgc->draw_mode, pgc->colour));
return;
}
vram = pgc_vram_addr(pgc, x, y);
if (!vram) return;
/* TODO: Does not implement the PGC plane mask (set by MASK) */
switch (pgc->draw_mode)
{
default:
case 0: *vram = pgc->colour; break; /* Write */
case 1: *vram ^= 0xFF; break; /* Invert */
case 2: *vram ^= pgc->colour; break; /* XOR colour */
case 3: *vram &= pgc->colour; break; /* AND */
}
}
/* Given raster coordinates, find the matching address in PGC video RAM */
uint8_t *pgc_vram_addr(pgc_core_t *pgc, int16_t x, int16_t y)
{
int offset;
/* We work from the bottom left-hand corner */
if (y < 0 || y >= pgc->maxh || x < 0 || x >= pgc->maxw) return NULL;
offset = (pgc->maxh - 1 -y) * (pgc->maxw) + x;
// PGCLOG(("pgc_vram_addr x=%d y=%d offset=%d\n", x, y, offset);
if (offset < 0 || offset >= (pgc->maxw * pgc->maxh))
{
return NULL;
}
return &pgc->vram[offset];
}
/* Read in the next command, either as hex (1 byte) or ASCII (up to 6
* characters) */
int pgc_read_command(pgc_core_t *pgc)
{
if (pgc->clcur)
{
return pgc_clist_byte(pgc, &pgc->hex_command);
}
else if (pgc->ascii_mode)
{
char ch;
int count = 0;
while (count < 7)
{
if (!pgc_input_char(pgc, &ch)) return 0;
if (is_whitespace(ch))
{
/* Pad to 6 characters */
while (count < 6)
pgc->asc_command[count++] = ' ';
pgc->asc_command[6] = 0;
return 1;
}
pgc->asc_command[count++] = toupper(ch);
}
return 1;
}
else
{
return pgc->inputbyte(pgc, &pgc->hex_command);
}
}
/* Read in the next command and parse it */
static int pgc_parse_command(pgc_core_t *pgc, const pgc_command_t **pcmd)
{
const pgc_command_t *cmd;
char match[7];
*pcmd = NULL;
pgc->hex_command = 0;
memset(pgc->asc_command, ' ', 6);
pgc->asc_command[6] = 0;
if (!pgc_read_command(pgc))
{
/* PGC has been reset */
return 0;
}
/* Scan the list of valid commands. pgc->pgc_commands may be a subclass
* list (terminated with '*') or the core list (terminated with '@') */
for (cmd = pgc->pgc_commands; cmd->ascii[0] != '@'; cmd++)
{
/* End of subclass command list, chain to core */
if (cmd->ascii[0] == '*') cmd = pgc_core_commands;
/* If in ASCII mode match on the ASCII command */
if (pgc->ascii_mode && !pgc->clcur)
{
sprintf(match, "%-6.6s", cmd->ascii);
if (!strncmp(match, pgc->asc_command, 6))
{
*pcmd = cmd;
pgc->hex_command = cmd->hex;
break;
}
}
else /* Otherwise match on the hex command */
{
if (cmd->hex == pgc->hex_command)
{
sprintf(pgc->asc_command, "%-6.6s",
cmd->ascii);
*pcmd = cmd;
break;
}
}
}
return 1;
}
/* The PGC drawing thread main loop. Read in commands and execute them ad
* infinitum */
void pgc_core_thread(void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
const pgc_command_t *cmd;
PGCLOG(("pgc_core_thread begins"));
while (1)
{
if (!pgc_parse_command(pgc, &cmd))
{
/* PGC has been reset */
continue;
}
PGCLOG(("PGC command: [%02x] '%s' found=%d\n",
pgc->hex_command, pgc->asc_command, (cmd != NULL)));
if (cmd)
{
pgc->result_count = 0;
(*cmd->handler)(pgc);
}
else
{
pgc_error(pgc, PGC_ERROR_OPCODE);
}
}
}
void pgc_recalctimings(pgc_core_t *pgc)
{
double disptime, _dispontime, _dispofftime;
double pixel_clock = (cpuclock * (double)(1ull << 32)) / (pgc->cga_selected ? 25175000.0 : pgc->native_pixel_clock);
/* Use a fixed 640 columns, like the T3100e */
disptime = pgc->screenw + 11;
_dispontime = pgc->screenw * pixel_clock;
_dispofftime = (disptime - pgc->screenw) * pixel_clock;
pgc->dispontime = (uint64_t)_dispontime;
pgc->dispofftime = (uint64_t)_dispofftime;
}
/* Draw the display in CGA (640x400) text mode */
void pgc_cga_text(pgc_core_t *pgc, int w)
{
int x, c;
uint8_t chr, attr;
int drawcursor = 0;
uint32_t cols[2];
int pitch = (pgc->mapram[0x3E9] + 1) * 2;
uint16_t sc = (pgc->displine & 0x0F) % pitch;
uint16_t ma = (pgc->mapram[0x3ED] | (pgc->mapram[0x3EC] << 8)) & 0x3fff;
uint16_t ca = (pgc->mapram[0x3EF] | (pgc->mapram[0x3EE] << 8)) & 0x3fff;
uint8_t *addr;
int cw = (w == 80) ? 8 : 16;
addr = &pgc->cga_vram[((ma << 1) + (((pgc->displine / pitch)*w)) * 2) & 0x3ffe];
ma += (pgc->displine / pitch) * w;
for (x = 0; x < w; x++)
{
chr = addr[0];
attr = addr[1];
addr += 2;
/* Cursor enabled? */
if (ma == ca && (pgc->cgablink & 8) &&
(pgc->mapram[0x3EA] & 0x60) != 0x20)
{
drawcursor = ((pgc->mapram[0x3EA] & 0x1F) <= (sc >> 1))
&& ((pgc->mapram[0x3EB] & 0x1F) >= (sc >> 1));
}
else drawcursor = 0;
if (pgc->mapram[0x3D8] & 0x20)
{
cols[1] = attr & 15;
cols[0] = (attr >> 4) & 7;
if ((pgc->cgablink & 8) && (attr & 0x80) && !drawcursor)
cols[1] = cols[0];
}
else
{
cols[1] = attr & 15;
cols[0] = attr >> 4;
}
if (drawcursor)
{
for (c = 0; c < cw; c++)
{
if (w == 80)
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 3) + c] = cols[(fontdatm[chr + pgc->fontbase][sc] & (1 << (c ^ 7))) ? 1 : 0] ^ 0xffffff;
else
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 4) + c] = cols[(fontdatm[chr + pgc->fontbase][sc] & (1 << (c ^ 7))) ? 1 : 0] ^ 0xffffff;
}
}
else
{
for (c = 0; c < cw; c++)
{
if (w == 80)
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 3) + c] = cols[(fontdatm[chr + pgc->fontbase][sc] & (1 << (c ^ 7))) ? 1 : 0];
else
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 4) + c] = cols[(fontdatm[chr + pgc->fontbase][sc] & (1 << ((c >> 1) ^ 7))) ? 1 : 0];
}
}
ma++;
}
}
/* Draw the display in CGA (320x200) graphics mode */
void pgc_cga_gfx40(pgc_core_t *pgc)
{
int x, c;
uint32_t cols[4];
int col;
uint16_t ma = (pgc->mapram[0x3ED] | (pgc->mapram[0x3EC] << 8)) & 0x3fff;
uint8_t *addr;
uint16_t dat;
cols[0] = pgc->mapram[0x3D9] & 15;
col = (pgc->mapram[0x3D9] & 16) ? 8 : 0;
if (pgc->mapram[0x3D8] & 4)
{
cols[1] = col | 3;
cols[2] = col | 4;
cols[3] = col | 7;
}
else if (pgc->mapram[0x3D9] & 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 < 40; x++)
{
addr = &pgc->cga_vram[(ma + 2 * x + 80 * (pgc->displine >> 2) + 0x2000 * ((pgc->displine >> 1) & 1)) & 0x3FFF];
dat = (addr[0] << 8) | addr[1];
pgc->ma++;
for (c = 0; c < 8; c++)
{
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 4) + (c << 1)] =
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 4) + (c << 1) + 1] = cols[dat >> 14];
dat <<= 2;
}
}
}
/* Draw the display in CGA (640x200) graphics mode */
void pgc_cga_gfx80(pgc_core_t *pgc)
{
int x, c;
uint32_t cols[2];
uint16_t ma = (pgc->mapram[0x3ED] | (pgc->mapram[0x3EC] << 8)) & 0x3fff;
uint8_t *addr;
uint16_t dat;
cols[0] = 0;
cols[1] = pgc->mapram[0x3D9] & 15;
for (x = 0; x < 40; x++)
{
addr = &pgc->cga_vram[(ma + 2 * x + 80 * (pgc->displine >> 2) + 0x2000 * ((pgc->displine >> 1) & 1)) & 0x3FFF];
dat = (addr[0] << 8) | addr[1];
pgc->ma++;
for (c = 0; c < 16; c++)
{
((uint32_t *)buffer32->line[pgc->displine & 2047])[(x << 4) + c] = cols[dat >> 15];
dat <<= 1;
}
}
}
/* Draw the screen in CGA mode. Based on the simplified WY700 renderer
* rather than the original CGA, since the PGC doesn't have a real 6845 */
void pgc_cga_poll(pgc_core_t *pgc)
{
int c;
uint32_t cols[2];
if (!pgc->linepos)
{
timer_advance_u64(&pgc->timer, pgc->dispofftime);
pgc->mapram[0x3DA] |= 1;
pgc->linepos = 1;
if (pgc->cgadispon)
{
if (pgc->displine == 0)
{
video_wait_for_buffer();
}
if ((pgc->mapram[0x3D8] & 0x12) == 0x12)
{
pgc_cga_gfx80(pgc);
}
else if (pgc->mapram[0x3D8] & 0x02)
{
pgc_cga_gfx40(pgc);
}
else if (pgc->mapram[0x3D8] & 0x01)
{
pgc_cga_text(pgc, 80);
}
else
{
pgc_cga_text(pgc, 40);
}
}
else
{
cols[0] = ((pgc->mapram[0x3D8] & 0x12) == 0x12) ? 0 : (pgc->mapram[0x3D9] & 15);
hline(buffer32, 0, pgc->displine & 2047, PGC_CGA_WIDTH, cols[0]);
}
for (c = 0; c < PGC_CGA_WIDTH; c++)
((uint32_t *)buffer32->line[pgc->displine & 2047])[c] = cgapal[((uint32_t *)buffer32->line[pgc->displine & 2047])[c] & 0xf];
pgc->displine++;
if (pgc->displine == PGC_CGA_HEIGHT)
{
pgc->mapram[0x3DA] |= 8;
pgc->cgadispon = 0;
}
if (pgc->displine == PGC_CGA_HEIGHT + 32)
{
pgc->mapram[0x3DA] &= ~8;
pgc->cgadispon = 1;
pgc->displine = 0;
}
}
else
{
if (pgc->cgadispon)
{
pgc->mapram[0x3DA] &= ~1;
}
timer_advance_u64(&pgc->timer, pgc->dispontime);
pgc->linepos = 0;
if (pgc->displine == PGC_CGA_HEIGHT)
{
if (PGC_CGA_WIDTH != xsize || PGC_CGA_HEIGHT != ysize)
{
xsize = PGC_CGA_WIDTH;
ysize = PGC_CGA_HEIGHT;
updatewindowsize(xsize, ysize);
}
video_blit_memtoscreen(0, 0, 0, ysize, xsize, ysize);
frames++;
/* We have a fixed 640x400 screen for
* CGA modes */
video_res_x = PGC_CGA_WIDTH;
video_res_y = PGC_CGA_HEIGHT;
switch (pgc->mapram[0x3D8] & 0x12)
{
case 0x12: video_bpp = 1; break;
case 0x02: video_bpp = 2; break;
default: video_bpp = 0; break;
}
pgc->cgablink++;
}
}
}
/* Draw the screen in CGA or native mode. */
void pgc_poll(void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
int x, y;
if (pgc->cga_selected)
{
pgc_cga_poll(pgc);
return;
}
/* Not CGA, so must be native mode */
if (!pgc->linepos)
{
timer_advance_u64(&pgc->timer, pgc->dispofftime);
pgc->mapram[0x3DA] |= 1;
pgc->linepos = 1;
if (pgc->cgadispon && pgc->displine < pgc->maxh)
{
if (pgc->displine == 0)
{
video_wait_for_buffer();
}
/* Don't know why pan needs to be multiplied by -2, but
* the IM1024 driver uses PAN -112 for an offset of
* 224. */
y = pgc->displine - 2 * pgc->pan_y;
for (x = 0; x < pgc->screenw; x++)
{
if (x + pgc->pan_x < pgc->maxw)
{
((uint32_t *)buffer32->line[pgc->displine & 2047])[x] = pgc->palette[pgc->vram[y * pgc->maxw + x]];
}
else
{
((uint32_t *)buffer32->line[pgc->displine & 2047])[x] = pgc->palette[0];
}
}
}
else
{
hline(buffer32, 0, pgc->displine & 2047, pgc->screenw, pgc->palette[0]);
}
pgc->displine++;
if (pgc->displine == pgc->screenh)
{
pgc->mapram[0x3DA] |= 8;
pgc->cgadispon = 0;
}
if (pgc->displine == pgc->screenh + 32)
{
pgc->mapram[0x3DA] &= ~8;
pgc->cgadispon = 1;
pgc->displine = 0;
}
}
else
{
if (pgc->cgadispon)
{
pgc->mapram[0x3DA] &= ~1;
}
timer_advance_u64(&pgc->timer, pgc->dispontime);
pgc->linepos = 0;
if (pgc->displine == pgc->screenh)
{
if (pgc->screenw != xsize || pgc->screenh != ysize)
{
xsize = pgc->screenw;
ysize = pgc->screenh;
updatewindowsize(xsize, ysize);
}
video_blit_memtoscreen(0, 0, 0, ysize, xsize, ysize);
frames++;
video_res_x = pgc->screenw;
video_res_y = pgc->screenh;
video_bpp = 8;
pgc->cgablink++;
}
}
}
/* Initialise RAM and registers to default values */
void pgc_reset(pgc_core_t *pgc)
{
int n;
memset(pgc->mapram, 0, sizeof(pgc->mapram));
/* There is no point in emulating the 'CGA disable' jumper as this is only
* appropriate for a dual-head system, not emulated by PCEM */
pgc->mapram[0x30B] = pgc->cga_enabled = 1;
pgc->mapram[0x3F8] = 0x03; /* Minor version */
pgc->mapram[0x3F9] = 0x01; /* Minor version */
pgc->mapram[0x3FB] = 0xA5; /* } */
pgc->mapram[0x3FC] = 0x5A; /* PGC self-test passed */
pgc->mapram[0x3FD] = 0x55; /* } */
pgc->mapram[0x3FE] = 0x5A; /* } */
pgc->ascii_mode = 1; /* Start off in ASCII mode */
pgc->line_pattern = 0xFFFF;
memset(pgc->fill_pattern, 0xFF, sizeof(pgc->fill_pattern));
pgc->colour = 0xFF;
pgc->tjust_h = 1;
pgc->tjust_v = 1;
/* Reset panning */
pgc->pan_x = 0;
pgc->pan_y = 0;
/* Reset clipping */
pgc->vp_x1 = 0;
pgc->vp_y1 = 0;
pgc->vp_x2 = pgc->visw - 1;
pgc->vp_y2 = pgc->vish - 1;
/* Empty command lists */
for (n = 0; n < 256; n++)
{
pgc->clist[n].wrptr = 0;
pgc->clist[n].rdptr = 0;
pgc->clist[n].repeat = 0;
pgc->clist[n].chain = 0;
}
pgc->clcur = NULL;
/* Select CGA display */
pgc->cga_selected = -1;
pgc_setdisplay(pgc, pgc->cga_enabled);
pgc->mapram[0x30C] = pgc->cga_enabled;
pgc->mapram[0x30D] = pgc->cga_enabled;
/* Default palette is 0 */
pgc_init_lut(pgc, 0);
hndl_lutsav(pgc);
}
/* Initialisation code common to the PGC and its subclasses.
*
* Pass the 'input byte' function in since this is overridden in
* the IM-1024, and needs to be set before the drawing thread is
* launched */
void pgc_core_init(pgc_core_t *pgc, int maxw, int maxh, int visw, int vish,
int (*inpbyte)(struct pgc_core_t *pgc, uint8_t *result), double native_pixel_clock)
{
int n;
mem_mapping_add(&pgc->mapping, 0xC6000, 0x800,
pgc_read, NULL, NULL,
pgc_write, NULL, NULL, NULL, MEM_MAPPING_EXTERNAL, pgc);
mem_mapping_add(&pgc->cga_mapping, 0xB8000, 0x8000,
pgc_read, NULL, NULL,
pgc_write, NULL, NULL, NULL, MEM_MAPPING_EXTERNAL, pgc);
io_sethandler(0x3D0, 0x0010, pgc_in, NULL, NULL, pgc_out, NULL, NULL,
pgc);
pgc->maxw = maxw;
pgc->maxh = maxh;
pgc->visw = visw;
pgc->vish = vish;
pgc->vram = malloc(maxw * maxh);
pgc->cga_vram = malloc(0x4000);
pgc->clist = calloc(256, sizeof(pgc_commandlist_t));
pgc->clcur = NULL;
pgc->native_pixel_clock = native_pixel_clock;
memset(pgc->vram, 0, maxw * maxh);
memset(pgc->cga_vram, 0, 0x4000);
/* Empty command lists */
for (n = 0; n < 256; n++)
{
pgc->clist[n].list = NULL;
pgc->clist[n].listmax = 0;
pgc->clist[n].wrptr = 0;
pgc->clist[n].rdptr = 0;
pgc->clist[n].repeat = 0;
pgc->clist[n].chain = NULL;
}
pgc_reset(pgc);
pgc->inputbyte = inpbyte;
pgc->pgc_commands = pgc_core_commands;
pgc->pgc_wake_thread = thread_create_event();
pgc->pgc_thread = thread_create(pgc_core_thread, pgc);
timer_add(&pgc->timer, pgc_poll, (void *)pgc, 1);
timer_add(&pgc->wake_timer, pgc_wake_timer, (void *)pgc, 0);
}
/* Initialisation code specific to the PGC */
void *pgc_standalone_init()
{
pgc_core_t *pgc = malloc(sizeof(pgc_core_t));
memset(pgc, 0, sizeof(pgc_core_t));
/* Framebuffer and screen are both 640x480 */
pgc_core_init(pgc, 640, 480, 640, 480, pgc_input_byte, 25175000.0);
return pgc;
}
void pgc_close(void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
thread_kill(pgc->pgc_thread);
thread_destroy_event(pgc->pgc_wake_thread);
if (pgc->cga_vram)
{
free(pgc->cga_vram);
}
if (pgc->vram)
{
free(pgc->vram);
}
free(pgc);
}
void pgc_speed_changed(void *p)
{
pgc_core_t *pgc = (pgc_core_t *)p;
pgc_recalctimings(pgc);
}
device_config_t pgc_config[] =
{
{
.type = -1
}
};
device_t pgc_device =
{
"PGC",
0,
pgc_standalone_init,
pgc_close,
NULL,
pgc_speed_changed,
NULL,
NULL,
pgc_config
};
Reference in a new issue View git blame Copy permalink