333 lines
6.8 KiB
C
333 lines
6.8 KiB
C
#define _GNU_SOURCE
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <math.h>
|
|
#include <signal.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/select.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
|
|
#define WIDTH 512
|
|
#define HEIGHT 320
|
|
|
|
#define str(x) stra(x)
|
|
#define stra(x) #x
|
|
|
|
#define die(fnname) \
|
|
do { \
|
|
perror(fnname); \
|
|
exit(EXIT_FAILURE); \
|
|
} while(0)
|
|
|
|
#define x(fn, ...) \
|
|
do { \
|
|
if(fn(__VA_ARGS__) < 0) { \
|
|
perror(#fn); \
|
|
exit(EXIT_FAILURE); \
|
|
} \
|
|
} while(0)
|
|
|
|
int fix_fft(short *fr, short *fi, short m, short inverse);
|
|
|
|
static pid_t
|
|
launch_xvfb(void)
|
|
{
|
|
char displayfd[16];
|
|
int r;
|
|
pid_t pid;
|
|
int fds[2];
|
|
x(pipe2, &fds[0], 0);
|
|
pid = fork();
|
|
if(pid < 0) {
|
|
die("fork");
|
|
} else if(!pid) {
|
|
x(snprintf, displayfd, sizeof(displayfd), "%d", fds[1]);
|
|
x(close, fds[0]);
|
|
execlp("Xvfb", "Xvfb", "-screen", "0", str(WIDTH) "x" str(HEIGHT) "x24", "-fbdir", ".", "-displayfd", displayfd, "-nolisten", "tcp", NULL);
|
|
die("execl");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
x(close, fds[1]);
|
|
r = read(fds[0], &displayfd[1], sizeof(displayfd) - 1);
|
|
if(r < 0) die("read");
|
|
x(close, fds[0]);
|
|
displayfd[r] = '\0';
|
|
displayfd[0] = ':';
|
|
x(setenv, "DISPLAY", displayfd, 1);
|
|
x(setenv, "ALSA_CONFIG_PATH", "asoundrc", 1);
|
|
return pid;
|
|
}
|
|
|
|
static pid_t
|
|
launch_uxnemu(int *write_fd, int *read_fd, int *sound_fd)
|
|
{
|
|
pid_t pid;
|
|
int fds[6];
|
|
x(pipe2, &fds[0], O_CLOEXEC);
|
|
x(pipe2, &fds[2], O_CLOEXEC);
|
|
x(pipe2, &fds[4], O_CLOEXEC);
|
|
pid = fork();
|
|
if(pid < 0) {
|
|
die("fork");
|
|
} else if(!pid) {
|
|
x(dup2, fds[0], 0);
|
|
x(dup2, fds[3], 1);
|
|
x(dup2, fds[5], 3);
|
|
execl("../../bin/uxnemu", "uxnemu", "autotest.rom", NULL);
|
|
die("execl");
|
|
}
|
|
x(close, fds[0]);
|
|
x(close, fds[3]);
|
|
x(close, fds[5]);
|
|
*write_fd = fds[1];
|
|
*read_fd = fds[2];
|
|
*sound_fd = fds[4];
|
|
return pid;
|
|
}
|
|
|
|
static void
|
|
terminate(pid_t pid)
|
|
{
|
|
int signals[] = {SIGINT, SIGTERM, SIGKILL};
|
|
int status;
|
|
size_t i;
|
|
for(i = 0; i < sizeof(signals) / sizeof(int) * 10; ++i) {
|
|
if(kill(pid, signals[i / 10])) {
|
|
break;
|
|
}
|
|
usleep(100000);
|
|
if(pid == waitpid(pid, &status, WNOHANG)) {
|
|
return;
|
|
}
|
|
}
|
|
waitpid(pid, &status, 0);
|
|
}
|
|
|
|
static int
|
|
open_framebuffer(void)
|
|
{
|
|
for(;;) {
|
|
int fd = open("Xvfb_screen0", O_RDONLY | O_CLOEXEC);
|
|
if(fd >= 0) {
|
|
return fd;
|
|
}
|
|
if(errno != ENOENT) {
|
|
perror("open");
|
|
return fd;
|
|
}
|
|
usleep(100000);
|
|
}
|
|
}
|
|
|
|
#define PPM_HEADER "P6\n" str(WIDTH) " " str(HEIGHT) "\n255\n"
|
|
|
|
static void
|
|
save_screenshot(int fb_fd, const char *filename)
|
|
{
|
|
unsigned char screen[WIDTH * HEIGHT * 4 + 4];
|
|
int fd = open(filename, O_WRONLY | O_CREAT, 0666);
|
|
int i;
|
|
if(fd < 0) {
|
|
die("screenshot open");
|
|
}
|
|
x(write, fd, PPM_HEADER, strlen(PPM_HEADER));
|
|
x(lseek, fb_fd, 0xca0, SEEK_SET);
|
|
x(read, fb_fd, &screen[4], WIDTH * HEIGHT * 4);
|
|
for(i = 0; i < WIDTH * HEIGHT; ++i) {
|
|
screen[i * 3 + 2] = screen[i * 4 + 4];
|
|
screen[i * 3 + 1] = screen[i * 4 + 5];
|
|
screen[i * 3 + 0] = screen[i * 4 + 6];
|
|
}
|
|
x(write, fd, screen, WIDTH * HEIGHT * 3);
|
|
x(close, fd);
|
|
}
|
|
|
|
static void
|
|
systemf(char *format, ...)
|
|
{
|
|
char *command;
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
x(vasprintf, &command, format, ap);
|
|
system(command);
|
|
free(command);
|
|
}
|
|
|
|
int uxn_read_fd, sound_fd;
|
|
|
|
static int
|
|
byte(void)
|
|
{
|
|
char c;
|
|
if(read(uxn_read_fd, &c, 1) != 1) {
|
|
return 0;
|
|
}
|
|
return (unsigned char)c;
|
|
}
|
|
|
|
#define NEW_FFT_SIZE_POW2 10
|
|
#define NEW_FFT_SIZE (1 << NEW_FFT_SIZE_POW2)
|
|
#define NEW_FFT_USEC (5000 * NEW_FFT_SIZE / 441)
|
|
|
|
unsigned char left_peak, right_peak;
|
|
|
|
static int
|
|
detect_peak(short *real, short *imag)
|
|
{
|
|
int i, peak = 0, peak_i;
|
|
for(i = 0; i < NEW_FFT_SIZE; ++i) {
|
|
int v = real[i] * real[i] + imag[i] * imag[i];
|
|
if(peak < v) {
|
|
peak = v;
|
|
peak_i = i;
|
|
} else if(peak > v * 10) {
|
|
return peak_i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
analyse_sound(short *samples)
|
|
{
|
|
short real[NEW_FFT_SIZE], imag[NEW_FFT_SIZE];
|
|
int i;
|
|
for(i = 0; i < NEW_FFT_SIZE * 2; ++i) {
|
|
if(samples[i * 2]) break;
|
|
}
|
|
if(i == NEW_FFT_SIZE * 2) return 0;
|
|
for(i = 0; i < NEW_FFT_SIZE; ++i) {
|
|
real[i] = samples[i * 4];
|
|
imag[i] = samples[i * 4 + 2];
|
|
}
|
|
fix_fft(real, imag, NEW_FFT_SIZE_POW2, 0);
|
|
return detect_peak(real, imag);
|
|
}
|
|
|
|
static int
|
|
read_sound(void)
|
|
{
|
|
static short samples[NEW_FFT_SIZE * 4];
|
|
static size_t len = 0;
|
|
int r = read(sound_fd, ((char *)samples) + len, sizeof(samples) - len);
|
|
if(r > 0) {
|
|
len += r;
|
|
if(len == sizeof(samples)) {
|
|
left_peak = analyse_sound(&samples[0]);
|
|
right_peak = analyse_sound(&samples[1]);
|
|
len = 0;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
main_loop(int uxn_write_fd, int fb_fd)
|
|
{
|
|
struct timeval next_sound = {0, 0};
|
|
for(;;) {
|
|
struct timeval now;
|
|
struct timeval *timeout;
|
|
fd_set fds;
|
|
FD_ZERO(&fds);
|
|
FD_SET(uxn_read_fd, &fds);
|
|
x(gettimeofday, &now, NULL);
|
|
if(now.tv_sec > next_sound.tv_sec || (now.tv_sec == next_sound.tv_sec && now.tv_usec > next_sound.tv_usec)) {
|
|
FD_SET(sound_fd, &fds);
|
|
timeout = NULL;
|
|
} else {
|
|
now.tv_sec = 0;
|
|
now.tv_usec = NEW_FFT_USEC;
|
|
timeout = &now;
|
|
}
|
|
x(select, uxn_read_fd > sound_fd ? uxn_read_fd + 1 : sound_fd + 1, &fds, NULL, NULL, timeout);
|
|
if(FD_ISSET(uxn_read_fd, &fds)) {
|
|
int c, x, y;
|
|
unsigned char blue;
|
|
switch(c = byte()) {
|
|
case 0x00: /* also used for EOF */
|
|
printf("exiting\n");
|
|
return;
|
|
/* 01-06 mouse */
|
|
case 0x01 ... 0x05:
|
|
systemf("xdotool click %d", c);
|
|
break;
|
|
case 0x06:
|
|
x = (byte() << 8) | byte();
|
|
y = (byte() << 8) | byte();
|
|
systemf("xdotool mousemove %d %d", x, y);
|
|
break;
|
|
/* 07-08 Screen */
|
|
case 0x07:
|
|
x = (byte() << 8) | byte();
|
|
y = (byte() << 8) | byte();
|
|
lseek(fb_fd, 0xca0 + (x + y * WIDTH) * 4, SEEK_SET);
|
|
read(fb_fd, &blue, 1);
|
|
blue = blue / 0x11;
|
|
write(uxn_write_fd, &blue, 1);
|
|
break;
|
|
case 0x08:
|
|
save_screenshot(fb_fd, "test.ppm");
|
|
break;
|
|
/* 09-0a Audio */
|
|
case 0x09:
|
|
write(uxn_write_fd, &left_peak, 1);
|
|
break;
|
|
case 0x0a:
|
|
write(uxn_write_fd, &right_peak, 1);
|
|
break;
|
|
/* 11-7e Controller/key */
|
|
case 0x11 ... 0x1c:
|
|
systemf("xdotool key F%d", c - 0x10);
|
|
break;
|
|
case '0' ... '9':
|
|
case 'A' ... 'Z':
|
|
case 'a' ... 'z':
|
|
systemf("xdotool key %c", c);
|
|
break;
|
|
default:
|
|
printf("unhandled command 0x%02x\n", c);
|
|
break;
|
|
}
|
|
}
|
|
if(FD_ISSET(sound_fd, &fds)) {
|
|
if(!next_sound.tv_sec) {
|
|
x(gettimeofday, &next_sound, NULL);
|
|
}
|
|
next_sound.tv_usec += NEW_FFT_USEC * read_sound();
|
|
if(next_sound.tv_usec > 1000000) {
|
|
next_sound.tv_usec -= 1000000;
|
|
++next_sound.tv_sec;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
pid_t xvfb_pid = launch_xvfb();
|
|
int fb_fd = open_framebuffer();
|
|
if(fb_fd >= 0) {
|
|
int uxn_write_fd;
|
|
pid_t uxnemu_pid = launch_uxnemu(&uxn_write_fd, &uxn_read_fd, &sound_fd);
|
|
main_loop(uxn_write_fd, fb_fd);
|
|
terminate(uxnemu_pid);
|
|
x(close, uxn_write_fd);
|
|
x(close, uxn_read_fd);
|
|
x(close, sound_fd);
|
|
x(close, fb_fd);
|
|
}
|
|
terminate(xvfb_pid);
|
|
return 0;
|
|
}
|