211 lines
5.2 KiB
C
211 lines
5.2 KiB
C
#include <SDL.h>
|
|
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
|
|
|
|
#define RBUF_SIZE 256
|
|
|
|
#define DEF_SCREEN_W 640
|
|
#define DEF_SCREEN_H 480
|
|
|
|
unsigned int pixel_x;
|
|
unsigned int pixel_y;
|
|
unsigned int screen_w;
|
|
unsigned int screen_h;
|
|
SDL_Window* sdl_window;
|
|
SDL_Renderer* sdl_renderer;
|
|
SDL_Texture* sdl_texture;
|
|
|
|
Uint32* screen;
|
|
|
|
#define VGASIM_CMD_INIT 0x01
|
|
#define VGASIM_CMD_RESET 0x02
|
|
#define VGASIM_CMD_TICK 0x03
|
|
|
|
void vgasim_init(int new_screen_h, int new_screen_w, int bpp) {
|
|
printf("vgasim_init: %d x %d x %d\n", new_screen_w, new_screen_h, bpp);
|
|
pixel_x = 0;
|
|
pixel_y = 0;
|
|
|
|
if (screen_h != new_screen_h || screen_w != new_screen_w) {
|
|
printf("Need to resize\n");
|
|
}
|
|
|
|
screen_h = new_screen_h;
|
|
screen_w = new_screen_w;
|
|
}
|
|
|
|
void vgasim_reset() {
|
|
printf("vgasim_reset\n");
|
|
pixel_x = 0;
|
|
pixel_y = 0;
|
|
SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(sdl_renderer);
|
|
SDL_RenderPresent(sdl_renderer);
|
|
}
|
|
|
|
void vgasim_tick(int r, int g, int b, int hsync, int vsync) {
|
|
//printf("vgasim_tick: %X, %X, %X (%s%s)\n", r, g, b, hsync ? "h" : "", vsync ? "v" : "");
|
|
|
|
screen[screen_w * pixel_y + pixel_x] = ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | ((b & 0xFF) << 0);
|
|
pixel_x++;
|
|
if (hsync || pixel_x > screen_w) {
|
|
pixel_x = 0;
|
|
pixel_y++;
|
|
//printf("vgasim_tick: vsync\n");
|
|
SDL_UpdateTexture(sdl_texture, NULL, screen, screen_w * sizeof (Uint32));
|
|
SDL_RenderClear(sdl_renderer);
|
|
SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, NULL);
|
|
SDL_RenderPresent(sdl_renderer);
|
|
}
|
|
if (vsync || pixel_y > screen_h) {
|
|
pixel_y = 0;
|
|
// printf("vgasim_tick: hsync\n");
|
|
}
|
|
}
|
|
|
|
ssize_t cmd_parse(char *buf, ssize_t bufsize) {
|
|
uint8_t *p8;
|
|
uint16_t *p16;
|
|
uint16_t cmd;
|
|
uint8_t r, g, b, hvsync;
|
|
uint16_t h, w, bpp;
|
|
|
|
if (bufsize < sizeof(uint16_t))
|
|
return 0;
|
|
|
|
p16 = (uint16_t*)buf;
|
|
cmd = *p16++;
|
|
p8 = (uint8_t*)p16;
|
|
switch (cmd) {
|
|
case VGASIM_CMD_INIT:
|
|
if (bufsize < 4 * sizeof(uint16_t))
|
|
return 0;
|
|
h = *p16++;
|
|
w = *p16++;
|
|
bpp = *p16++;
|
|
vgasim_init(h, w, bpp);
|
|
return 4 * sizeof(uint16_t);
|
|
|
|
case VGASIM_CMD_RESET:
|
|
vgasim_reset();
|
|
return sizeof(uint16_t);
|
|
|
|
case VGASIM_CMD_TICK:
|
|
if (bufsize < sizeof(uint16_t) + 4 * sizeof(uint8_t))
|
|
return 0;
|
|
r = *p8++;
|
|
g = *p8++;
|
|
b = *p8++;
|
|
hvsync = *p8++;
|
|
vgasim_tick(r, g, b, (hvsync & 0x01), ((hvsync & 0x02) >> 1));
|
|
|
|
return sizeof(uint16_t) + 4 * sizeof(uint8_t);
|
|
|
|
default:
|
|
printf("Unsupported command packet received: %X\n", cmd);
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int main (int argc, char **argv) {
|
|
int fifo_fd;
|
|
char rbuf[RBUF_SIZE];
|
|
ssize_t bytes_read, bytes_read_total;
|
|
ssize_t bytes_parsed, bytes_parsed_total;
|
|
int ret = mkfifo("/tmp/vgasim", S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
|
|
|
|
if (ret == -1 && errno != EEXIST) {
|
|
perror(argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
ret = SDL_Init(SDL_INIT_VIDEO);
|
|
if (ret < 0) {
|
|
printf("SDL_Init failed: %d\n", ret);
|
|
return 2;
|
|
}
|
|
|
|
sdl_window = SDL_CreateWindow("vgasim", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, DEF_SCREEN_W, DEF_SCREEN_H, 0);
|
|
if (sdl_window == NULL) {
|
|
printf("SDL_CreateWindow failed\n");
|
|
return 3;
|
|
}
|
|
sdl_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
|
|
if (sdl_renderer == NULL) {
|
|
printf("SDL_CreateRenderer failed\n");
|
|
return 4;
|
|
}
|
|
sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, DEF_SCREEN_W, DEF_SCREEN_H);
|
|
if (sdl_texture == NULL) {
|
|
printf("SDL_CreateTexture failed\n");
|
|
return 5;
|
|
}
|
|
SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(sdl_renderer);
|
|
SDL_RenderPresent(sdl_renderer);
|
|
|
|
screen = malloc(DEF_SCREEN_H * DEF_SCREEN_W * sizeof(Uint32));
|
|
if (screen == NULL) {
|
|
return 6;
|
|
}
|
|
|
|
printf("Listening for incoming connections...\n");
|
|
ret = open("/tmp/vgasim", O_RDONLY);
|
|
if (ret == -1) {
|
|
perror(argv[0]);
|
|
return 2;
|
|
}
|
|
|
|
fifo_fd = ret;
|
|
|
|
bytes_read_total = 0;
|
|
do {
|
|
|
|
// Read as much bytes as we can into our buffer
|
|
bytes_read = read(fifo_fd, rbuf + bytes_read_total, RBUF_SIZE - bytes_read_total);
|
|
bytes_read_total += bytes_read;
|
|
|
|
bytes_parsed_total = 0;
|
|
if (bytes_read > 0) {
|
|
do {
|
|
|
|
// Parse as many bytes as we can
|
|
bytes_parsed = cmd_parse(rbuf + bytes_parsed_total, bytes_read_total - bytes_parsed_total);
|
|
bytes_parsed_total += bytes_parsed;
|
|
} while (bytes_parsed > 0);
|
|
}
|
|
|
|
// If there's any data left unparsed, it's the start of a new incomplete packet.
|
|
// Copy it to the front of the buffer and restart from there.
|
|
// Otherwise we cleared our entire buffer and can start again from the beginning.
|
|
if (bytes_read_total > bytes_parsed_total) {
|
|
memcpy(rbuf, rbuf + bytes_parsed_total, (bytes_read_total - bytes_parsed_total));
|
|
bytes_read_total = bytes_read_total - bytes_parsed_total;
|
|
} else {
|
|
bytes_read_total = 0;
|
|
}
|
|
} while (bytes_read > 0);
|
|
|
|
if (bytes_read < 0) {
|
|
perror(argv[0]);
|
|
return 3;
|
|
}
|
|
|
|
free(screen);
|
|
SDL_DestroyTexture(sdl_texture);
|
|
SDL_DestroyRenderer(sdl_renderer);
|
|
SDL_DestroyWindow(sdl_window);
|
|
SDL_Quit();
|
|
|
|
return 0;
|
|
}
|