[pcsx_rearmed.git] / frontend / plugin_lib.c

/*
 * (C) notaz, 2010-2011
 *
 * This work is licensed under the terms of the GNU GPLv2 or later.
 * See the COPYING file in the top-level directory.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdint.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>

#include "plugin_lib.h"
#include "linux/fbdev.h"
#include "common/fonts.h"
#include "common/input.h"
#include "omap.h"
#include "menu.h"
#include "main.h"
#include "pcnt.h"
#include "../libpcsxcore/new_dynarec/new_dynarec.h"
#include "../libpcsxcore/psemu_plugin_defs.h"

void *pl_fbdev_buf;
int pl_frame_interval;
int in_type, in_keystate, in_a1[2] = { 127, 127 }, in_a2[2] = { 127, 127 };
static int pl_fbdev_w, pl_fbdev_h, pl_fbdev_bpp;
static int flip_cnt, vsync_cnt, flips_per_sec, tick_per_sec;
static float vsps_cur;
static int vsync_usec_time;

static int get_cpu_ticks(void)
{
	static unsigned long last_utime;
	static int fd;
	unsigned long utime, ret;
	char buf[128];

	if (fd == 0)
		fd = open("/proc/self/stat", O_RDONLY);
	lseek(fd, 0, SEEK_SET);
	buf[0] = 0;
	read(fd, buf, sizeof(buf));
	buf[sizeof(buf) - 1] = 0;

	sscanf(buf, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu", &utime);
	ret = utime - last_utime;
	last_utime = utime;
	return ret;
}

static void print_hud(void)
{
	if (pl_fbdev_bpp == 16)
		pl_text_out16(2, pl_fbdev_h - 10, "%s", hud_msg);
}

static void print_fps(void)
{
	if (pl_fbdev_bpp == 16)
		pl_text_out16(2, pl_fbdev_h - 10, "%2d %4.1f", flips_per_sec, vsps_cur);
}

static void print_cpu_usage(void)
{
	if (pl_fbdev_bpp == 16)
		pl_text_out16(pl_fbdev_w - 28, pl_fbdev_h - 10, "%3d", tick_per_sec);
}

// draw 192x8 status of 24 sound channels
static __attribute__((noinline)) void draw_active_chans(void)
{
	extern void spu_get_debug_info(int *chans_out, int *fmod_chans_out, int *noise_chans_out); // hack
	int live_chans, fmod_chans, noise_chans;

	static const unsigned short colors[2] = { 0x1fe3, 0x0700 };
	unsigned short *dest = (unsigned short *)pl_fbdev_buf +
		pl_fbdev_w * (pl_fbdev_h - 10) + pl_fbdev_w / 2 - 192/2;
	unsigned short *d, p;
	int c, x, y;

	if (pl_fbdev_bpp != 16)
		return;

	spu_get_debug_info(&live_chans, &fmod_chans, &noise_chans);

	for (c = 0; c < 24; c++) {
		d = dest + c * 8;
		p = !(live_chans & (1<<c)) ? 0 :
		     (fmod_chans & (1<<c)) ? 0xf000 :
		     (noise_chans & (1<<c)) ? 0x001f :
		     colors[c & 1];
		for (y = 0; y < 8; y++, d += pl_fbdev_w)
			for (x = 0; x < 8; x++)
				d[x] = p;
	}
}

void *pl_fbdev_set_mode(int w, int h, int bpp)
{
	void *ret;

	if (w == pl_fbdev_w && h == pl_fbdev_h && bpp == pl_fbdev_bpp)
		return pl_fbdev_buf;

	pl_fbdev_w = w;
	pl_fbdev_h = h;
	pl_fbdev_bpp = bpp;

	vout_fbdev_clear(layer_fb);
	ret = vout_fbdev_resize(layer_fb, w, h, bpp, 0, 0, 0, 0, 3);
	if (ret == NULL)
		fprintf(stderr, "failed to set mode\n");
	else
		pl_fbdev_buf = ret;

	menu_notify_mode_change(w, h, bpp);

	return pl_fbdev_buf;
}

void *pl_fbdev_flip(void)
{
	flip_cnt++;

	if (pl_fbdev_buf != NULL) {
		if (g_opts & OPT_SHOWSPU)
			draw_active_chans();

		if (hud_msg[0] != 0)
			print_hud();
		else if (g_opts & OPT_SHOWFPS)
			print_fps();

		if (g_opts & OPT_SHOWCPU)
			print_cpu_usage();
	}

	// let's flip now
	pl_fbdev_buf = vout_fbdev_flip(layer_fb);
	return pl_fbdev_buf;
}

int pl_fbdev_open(void)
{
	struct timeval now;

	pl_fbdev_buf = vout_fbdev_flip(layer_fb);
	omap_enable_layer(1);

	// try to align redraws to vsync
	vout_fbdev_wait_vsync(layer_fb);
	gettimeofday(&now, 0);
	vsync_usec_time = now.tv_usec;
	while (vsync_usec_time >= pl_frame_interval)
		vsync_usec_time -= pl_frame_interval;

	return 0;
}

void pl_fbdev_close(void)
{
	omap_enable_layer(0);
}

void *pl_prepare_screenshot(int *w, int *h, int *bpp)
{
	*w = pl_fbdev_w;
	*h = pl_fbdev_h;
	*bpp = pl_fbdev_bpp;

	return pl_fbdev_buf;
}

static void update_input(void)
{
	int actions[IN_BINDTYPE_COUNT] = { 0, };
	unsigned int emu_act;

	in_update(actions);
	if (in_type == PSE_PAD_TYPE_ANALOGPAD)
		in_update_analogs();
	emu_act = actions[IN_BINDTYPE_EMU];
	if (emu_act) {
		int which = 0;
		for (; !(emu_act & 1); emu_act >>= 1, which++)
			;
		emu_act = which;
	}
	emu_set_action(emu_act);

	in_keystate = actions[IN_BINDTYPE_PLAYER12];

#ifdef X11
	extern int x11_update_keys(unsigned int *action);
	in_keystate |= x11_update_keys(&emu_act);
	emu_set_action(emu_act);
#endif
}

#define MAX_LAG_FRAMES 3

#define tvdiff(tv, tv_old) \
	((tv.tv_sec - tv_old.tv_sec) * 1000000 + tv.tv_usec - tv_old.tv_usec)
// assumes us < 1000000
#define tvadd(tv, us) { \
	tv.tv_usec += us; \
	if (tv.tv_usec >= 1000000) { \
		tv.tv_usec -= 1000000; \
		tv.tv_sec++; \
	} \
}

/* called on every vsync */
void pl_frame_limit(void)
{
	static struct timeval tv_old, tv_expect;
	static int vsync_cnt_prev;
	struct timeval now;
	int diff, usadj;

	vsync_cnt++;

	/* doing input here because the pad is polled
	 * thousands of times per frame for some reason */
	update_input();

	pcnt_end(PCNT_ALL);
	gettimeofday(&now, 0);

	if (now.tv_sec != tv_old.tv_sec) {
		diff = tvdiff(now, tv_old);
		vsps_cur = 0.0f;
		if (0 < diff && diff < 2000000)
			vsps_cur = 1000000.0f * (vsync_cnt - vsync_cnt_prev) / diff;
		vsync_cnt_prev = vsync_cnt;
		flips_per_sec = flip_cnt;
		flip_cnt = 0;
		tv_old = now;
		if (g_opts & OPT_SHOWCPU)
			tick_per_sec = get_cpu_ticks();

		if (hud_new_msg > 0) {
			hud_new_msg--;
			if (hud_new_msg == 0)
				hud_msg[0] = 0;
		}
	}
#ifdef PCNT
	static int ya_vsync_count;
	if (++ya_vsync_count == PCNT_FRAMES) {
		pcnt_print(vsps_cur);
		ya_vsync_count = 0;
	}
#endif

	tvadd(tv_expect, pl_frame_interval);
	diff = tvdiff(tv_expect, now);
	if (diff > MAX_LAG_FRAMES * pl_frame_interval || diff < -MAX_LAG_FRAMES * pl_frame_interval) {
		//printf("pl_frame_limit reset, diff=%d, iv %d\n", diff, pl_frame_interval);
		tv_expect = now;
		diff = 0;
		// try to align with vsync
		usadj = vsync_usec_time;
		while (usadj < tv_expect.tv_usec - pl_frame_interval)
			usadj += pl_frame_interval;
		tv_expect.tv_usec = usadj;
	}

	if (!(g_opts & OPT_NO_FRAMELIM) && diff > pl_frame_interval) {
		// yay for working usleep on pandora!
		//printf("usleep %d\n", diff - pl_frame_interval / 2);
		usleep(diff - pl_frame_interval / 2);
	}

	if (pl_rearmed_cbs.frameskip) {
		if (diff < -pl_frame_interval)
			pl_rearmed_cbs.fskip_advice = 1;
		else if (diff >= 0)
			pl_rearmed_cbs.fskip_advice = 0;
	}

	pcnt_start(PCNT_ALL);
}

static void pl_text_out16_(int x, int y, const char *text)
{
	int i, l, len = strlen(text), w = pl_fbdev_w;
	unsigned short *screen = (unsigned short *)pl_fbdev_buf + x + y * w;
	unsigned short val = 0xffff;

	for (i = 0; i < len; i++, screen += 8)
	{
		for (l = 0; l < 8; l++)
		{
			unsigned char fd = fontdata8x8[text[i] * 8 + l];
			unsigned short *s = screen + l * w;
			if (fd&0x80) s[0] = val;
			if (fd&0x40) s[1] = val;
			if (fd&0x20) s[2] = val;
			if (fd&0x10) s[3] = val;
			if (fd&0x08) s[4] = val;
			if (fd&0x04) s[5] = val;
			if (fd&0x02) s[6] = val;
			if (fd&0x01) s[7] = val;
		}
	}
}

void pl_text_out16(int x, int y, const char *texto, ...)
{
	va_list args;
	char    buffer[256];

	va_start(args, texto);
	vsnprintf(buffer, sizeof(buffer), texto, args);
	va_end(args);

	pl_text_out16_(x, y, buffer);
}

static void pl_get_layer_pos(int *x, int *y, int *w, int *h)
{
	*x = g_layer_x;
	*y = g_layer_y;
	*w = g_layer_w;
	*h = g_layer_h;
}

struct rearmed_cbs pl_rearmed_cbs = {
	pl_get_layer_pos,
	pl_fbdev_open,
	pl_fbdev_set_mode,
	pl_fbdev_flip,
	pl_fbdev_close,
};

/* watchdog */
static void *watchdog_thread(void *unused)
{
	int vsync_cnt_old = 0;
	int seen_dead = 0;
	int sleep_time = 5;

#ifndef NDEBUG
	// don't interfere with debug
	return NULL;
#endif
	while (1)
	{
		sleep(sleep_time);

		if (stop) {
			seen_dead = 0;
			sleep_time = 5;
			continue;
		}
		if (vsync_cnt != vsync_cnt_old) {
			vsync_cnt_old = vsync_cnt;
			seen_dead = 0;
			sleep_time = 2;
			continue;
		}

		seen_dead++;
		sleep_time = 1;
		if (seen_dead > 1)
			fprintf(stderr, "watchdog: seen_dead %d\n", seen_dead);
		if (seen_dead > 4) {
			fprintf(stderr, "watchdog: lockup detected, aborting\n");
			// we can't do any cleanup here really, the main thread is
			// likely touching resources and would crash anyway
			abort();
		}
	}
}

void pl_start_watchdog(void)
{
	pthread_attr_t attr;
	pthread_t tid;
	int ret;
	
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

	ret = pthread_create(&tid, &attr, watchdog_thread, NULL);
	if (ret != 0)
		fprintf(stderr, "could not start watchdog: %d\n", ret);
}
Commit	Line	Data
b60f2812	1	/*
8f892648	2	* (C) notaz, 2010-2011
b60f2812	3	*
	4	* This work is licensed under the terms of the GNU GPLv2 or later.
	5	* See the COPYING file in the top-level directory.
	6	*/
	7
	8	#include <stdio.h>
	9	#include <stdlib.h>
69af03a2	10	#include <string.h>
69af03a2	11	#include <stdarg.h>
799b0b87	12	#include <stdint.h>
72228559	13	#include <sys/time.h>
	14	#include <sys/types.h>
	15	#include <sys/stat.h>
	16	#include <fcntl.h>
	17	#include <unistd.h>
7c0f51de	18	#include <pthread.h>
b60f2812	19
72228559	20	#include "plugin_lib.h"
b60f2812	21	#include "linux/fbdev.h"
69af03a2	22	#include "common/fonts.h"
	23	#include "common/input.h"
	24	#include "omap.h"
3c70c47b	25	#include "menu.h"
8f892648	26	#include "main.h"
72228559	27	#include "pcnt.h"
69af03a2	28	#include "../libpcsxcore/new_dynarec/new_dynarec.h"
799b0b87	29	#include "../libpcsxcore/psemu_plugin_defs.h"
b60f2812	30
b60f2812	31	void *pl_fbdev_buf;
bce6b056	32	int pl_frame_interval;
3e215238	33	int in_type, in_keystate, in_a1[2] = { 127, 127 }, in_a2[2] = { 127, 127 };
72228559	34	static int pl_fbdev_w, pl_fbdev_h, pl_fbdev_bpp;
bce6b056	35	static int flip_cnt, vsync_cnt, flips_per_sec, tick_per_sec;
bce6b056	36	static float vsps_cur;
cefe86b7	37	static int vsync_usec_time;
72228559	38
	39	static int get_cpu_ticks(void)
	40	{
	41	static unsigned long last_utime;
	42	static int fd;
	43	unsigned long utime, ret;
	44	char buf[128];
	45
	46	if (fd == 0)
	47	fd = open("/proc/self/stat", O_RDONLY);
	48	lseek(fd, 0, SEEK_SET);
	49	buf[0] = 0;
	50	read(fd, buf, sizeof(buf));
	51	buf[sizeof(buf) - 1] = 0;
	52
	53	sscanf(buf, "%d %s %c %d %d %d %d %d %u %u %u %u %*u %lu", &utime);
	54	ret = utime - last_utime;
	55	last_utime = utime;
	56	return ret;
	57	}
	58
8f892648	59	static void print_hud(void)
	60	{
	61	if (pl_fbdev_bpp == 16)
	62	pl_text_out16(2, pl_fbdev_h - 10, "%s", hud_msg);
	63	}
	64
72228559	65	static void print_fps(void)
	66	{
	67	if (pl_fbdev_bpp == 16)
bce6b056	68	pl_text_out16(2, pl_fbdev_h - 10, "%2d %4.1f", flips_per_sec, vsps_cur);
72228559	69	}
	70
	71	static void print_cpu_usage(void)
	72	{
	73	if (pl_fbdev_bpp == 16)
	74	pl_text_out16(pl_fbdev_w - 28, pl_fbdev_h - 10, "%3d", tick_per_sec);
	75	}
b60f2812	76
90f1d26c	77	// draw 192x8 status of 24 sound channels
	78	static __attribute__((noinline)) void draw_active_chans(void)
	79	{
	80	extern void spu_get_debug_info(int chans_out, int fmod_chans_out, int *noise_chans_out); // hack
	81	int live_chans, fmod_chans, noise_chans;
	82
	83	static const unsigned short colors[2] = { 0x1fe3, 0x0700 };
	84	unsigned short dest = (unsigned short )pl_fbdev_buf +
	85	pl_fbdev_w * (pl_fbdev_h - 10) + pl_fbdev_w / 2 - 192/2;
	86	unsigned short *d, p;
	87	int c, x, y;
	88
	89	if (pl_fbdev_bpp != 16)
	90	return;
	91
	92	spu_get_debug_info(&live_chans, &fmod_chans, &noise_chans);
	93
	94	for (c = 0; c < 24; c++) {
	95	d = dest + c * 8;
	96	p = !(live_chans & (1<<c)) ? 0 :
	97	(fmod_chans & (1<<c)) ? 0xf000 :
	98	(noise_chans & (1<<c)) ? 0x001f :
	99	colors[c & 1];
	100	for (y = 0; y < 8; y++, d += pl_fbdev_w)
	101	for (x = 0; x < 8; x++)
	102	d[x] = p;
	103	}
	104	}
	105
297b3d63	106	void *pl_fbdev_set_mode(int w, int h, int bpp)
69af03a2	107	{
d352cde2	108	void *ret;
b60f2812	109
72228559	110	if (w == pl_fbdev_w && h == pl_fbdev_h && bpp == pl_fbdev_bpp)
7947ab55	111	return pl_fbdev_buf;
72228559	112
69af03a2	113	pl_fbdev_w = w;
72228559	114	pl_fbdev_h = h;
72228559	115	pl_fbdev_bpp = bpp;
d352cde2	116
d352cde2	117	vout_fbdev_clear(layer_fb);
69af03a2	118	ret = vout_fbdev_resize(layer_fb, w, h, bpp, 0, 0, 0, 0, 3);
d352cde2	119	if (ret == NULL)
69af03a2	120	fprintf(stderr, "failed to set mode\n");
d352cde2	121	else
	122	pl_fbdev_buf = ret;
	123
bd6267e6	124	menu_notify_mode_change(w, h, bpp);
3c70c47b	125
297b3d63	126	return pl_fbdev_buf;
69af03a2	127	}
69af03a2	128
ffd0d743	129	void *pl_fbdev_flip(void)
69af03a2	130	{
72228559	131	flip_cnt++;
297b3d63	132
297b3d63	133	if (pl_fbdev_buf != NULL) {
90f1d26c	134	if (g_opts & OPT_SHOWSPU)
	135	draw_active_chans();
	136
8f892648	137	if (hud_msg[0] != 0)
	138	print_hud();
	139	else if (g_opts & OPT_SHOWFPS)
297b3d63	140	print_fps();
8f892648	141
297b3d63	142	if (g_opts & OPT_SHOWCPU)
	143	print_cpu_usage();
	144	}
72228559	145
69af03a2	146	// let's flip now
69af03a2	147	pl_fbdev_buf = vout_fbdev_flip(layer_fb);
ffd0d743	148	return pl_fbdev_buf;
b60f2812	149	}
b60f2812	150
6d1a1ac2	151	int pl_fbdev_open(void)
6d1a1ac2	152	{
cefe86b7	153	struct timeval now;
cefe86b7	154
6d1a1ac2	155	pl_fbdev_buf = vout_fbdev_flip(layer_fb);
6d1a1ac2	156	omap_enable_layer(1);
cefe86b7	157
	158	// try to align redraws to vsync
	159	vout_fbdev_wait_vsync(layer_fb);
	160	gettimeofday(&now, 0);
	161	vsync_usec_time = now.tv_usec;
	162	while (vsync_usec_time >= pl_frame_interval)
	163	vsync_usec_time -= pl_frame_interval;
	164
6d1a1ac2	165	return 0;
	166	}
	167
	168	void pl_fbdev_close(void)
b60f2812	169	{
6d1a1ac2	170	omap_enable_layer(0);
b60f2812	171	}
b60f2812	172
29a8c4f3	173	void pl_prepare_screenshot(int w, int h, int bpp)
	174	{
	175	*w = pl_fbdev_w;
	176	*h = pl_fbdev_h;
	177	*bpp = pl_fbdev_bpp;
	178
	179	return pl_fbdev_buf;
	180	}
	181
15d46930	182	static void update_input(void)
	183	{
	184	int actions[IN_BINDTYPE_COUNT] = { 0, };
8f892648	185	unsigned int emu_act;
15d46930	186
15d46930	187	in_update(actions);
799b0b87	188	if (in_type == PSE_PAD_TYPE_ANALOGPAD)
799b0b87	189	in_update_analogs();
8f892648	190	emu_act = actions[IN_BINDTYPE_EMU];
	191	if (emu_act) {
	192	int which = 0;
	193	for (; !(emu_act & 1); emu_act >>= 1, which++)
	194	;
	195	emu_act = which;
	196	}
	197	emu_set_action(emu_act);
	198
799b0b87	199	in_keystate = actions[IN_BINDTYPE_PLAYER12];
447783f8	200
447783f8	201	#ifdef X11
4218954f	202	extern int x11_update_keys(unsigned int *action);
	203	in_keystate \|= x11_update_keys(&emu_act);
	204	emu_set_action(emu_act);
447783f8	205	#endif
15d46930	206	}
15d46930	207
bce6b056	208	#define MAX_LAG_FRAMES 3
	209
	210	#define tvdiff(tv, tv_old) \
	211	((tv.tv_sec - tv_old.tv_sec) * 1000000 + tv.tv_usec - tv_old.tv_usec)
	212	// assumes us < 1000000
	213	#define tvadd(tv, us) { \
	214	tv.tv_usec += us; \
	215	if (tv.tv_usec >= 1000000) { \
	216	tv.tv_usec -= 1000000; \
	217	tv.tv_sec++; \
	218	} \
	219	}
	220
72228559	221	/* called on every vsync */
	222	void pl_frame_limit(void)
	223	{
bce6b056	224	static struct timeval tv_old, tv_expect;
7c0f51de	225	static int vsync_cnt_prev;
bce6b056	226	struct timeval now;
cefe86b7	227	int diff, usadj;
bce6b056	228
bce6b056	229	vsync_cnt++;
72228559	230
15d46930	231	/* doing input here because the pad is polled
	232	* thousands of times per frame for some reason */
	233	update_input();
	234
72228559	235	pcnt_end(PCNT_ALL);
bce6b056	236	gettimeofday(&now, 0);
72228559	237
bce6b056	238	if (now.tv_sec != tv_old.tv_sec) {
	239	diff = tvdiff(now, tv_old);
	240	vsps_cur = 0.0f;
	241	if (0 < diff && diff < 2000000)
7c0f51de	242	vsps_cur = 1000000.0f * (vsync_cnt - vsync_cnt_prev) / diff;
7c0f51de	243	vsync_cnt_prev = vsync_cnt;
72228559	244	flips_per_sec = flip_cnt;
7c0f51de	245	flip_cnt = 0;
bce6b056	246	tv_old = now;
bd6267e6	247	if (g_opts & OPT_SHOWCPU)
bd6267e6	248	tick_per_sec = get_cpu_ticks();
8f892648	249
	250	if (hud_new_msg > 0) {
	251	hud_new_msg--;
	252	if (hud_new_msg == 0)
	253	hud_msg[0] = 0;
	254	}
72228559	255	}
	256	#ifdef PCNT
	257	static int ya_vsync_count;
	258	if (++ya_vsync_count == PCNT_FRAMES) {
bce6b056	259	pcnt_print(vsps_cur);
72228559	260	ya_vsync_count = 0;
	261	}
	262	#endif
	263
c89cd762	264	tvadd(tv_expect, pl_frame_interval);
	265	diff = tvdiff(tv_expect, now);
	266	if (diff > MAX_LAG_FRAMES * pl_frame_interval \|\| diff < -MAX_LAG_FRAMES * pl_frame_interval) {
	267	//printf("pl_frame_limit reset, diff=%d, iv %d\n", diff, pl_frame_interval);
	268	tv_expect = now;
	269	diff = 0;
cefe86b7	270	// try to align with vsync
	271	usadj = vsync_usec_time;
	272	while (usadj < tv_expect.tv_usec - pl_frame_interval)
	273	usadj += pl_frame_interval;
	274	tv_expect.tv_usec = usadj;
c89cd762	275	}
	276
	277	if (!(g_opts & OPT_NO_FRAMELIM) && diff > pl_frame_interval) {
	278	// yay for working usleep on pandora!
	279	//printf("usleep %d\n", diff - pl_frame_interval / 2);
	280	usleep(diff - pl_frame_interval / 2);
	281	}
	282
e64dc4c5	283	if (pl_rearmed_cbs.frameskip) {
	284	if (diff < -pl_frame_interval)
	285	pl_rearmed_cbs.fskip_advice = 1;
	286	else if (diff >= 0)
	287	pl_rearmed_cbs.fskip_advice = 0;
bce6b056	288	}
72228559	289
	290	pcnt_start(PCNT_ALL);
	291	}
	292
69af03a2	293	static void pl_text_out16_(int x, int y, const char *text)
b60f2812	294	{
69af03a2	295	int i, l, len = strlen(text), w = pl_fbdev_w;
	296	unsigned short screen = (unsigned short )pl_fbdev_buf + x + y * w;
	297	unsigned short val = 0xffff;
	298
	299	for (i = 0; i < len; i++, screen += 8)
	300	{
	301	for (l = 0; l < 8; l++)
	302	{
	303	unsigned char fd = fontdata8x8[text[i] * 8 + l];
	304	unsigned short s = screen + l w;
	305	if (fd&0x80) s[0] = val;
	306	if (fd&0x40) s[1] = val;
	307	if (fd&0x20) s[2] = val;
	308	if (fd&0x10) s[3] = val;
	309	if (fd&0x08) s[4] = val;
	310	if (fd&0x04) s[5] = val;
	311	if (fd&0x02) s[6] = val;
	312	if (fd&0x01) s[7] = val;
	313	}
	314	}
b60f2812	315	}
b60f2812	316
69af03a2	317	void pl_text_out16(int x, int y, const char *texto, ...)
b60f2812	318	{
69af03a2	319	va_list args;
	320	char buffer[256];
	321
	322	va_start(args, texto);
	323	vsnprintf(buffer, sizeof(buffer), texto, args);
	324	va_end(args);
	325
	326	pl_text_out16_(x, y, buffer);
b60f2812	327	}
b60f2812	328
201c21e2	329	static void pl_get_layer_pos(int x, int y, int w, int h)
	330	{
	331	*x = g_layer_x;
	332	*y = g_layer_y;
	333	*w = g_layer_w;
	334	*h = g_layer_h;
	335	}
	336
e64dc4c5	337	struct rearmed_cbs pl_rearmed_cbs = {
201c21e2	338	pl_get_layer_pos,
ffd0d743	339	pl_fbdev_open,
	340	pl_fbdev_set_mode,
	341	pl_fbdev_flip,
	342	pl_fbdev_close,
201c21e2	343	};
201c21e2	344
7c0f51de	345	/* watchdog */
	346	static void watchdog_thread(void unused)
	347	{
	348	int vsync_cnt_old = 0;
	349	int seen_dead = 0;
	350	int sleep_time = 5;
	351
799b0b87	352	#ifndef NDEBUG
	353	// don't interfere with debug
	354	return NULL;
	355	#endif
7c0f51de	356	while (1)
	357	{
	358	sleep(sleep_time);
	359
	360	if (stop) {
	361	seen_dead = 0;
	362	sleep_time = 5;
	363	continue;
	364	}
	365	if (vsync_cnt != vsync_cnt_old) {
	366	vsync_cnt_old = vsync_cnt;
	367	seen_dead = 0;
	368	sleep_time = 2;
	369	continue;
	370	}
	371
	372	seen_dead++;
	373	sleep_time = 1;
	374	if (seen_dead > 1)
	375	fprintf(stderr, "watchdog: seen_dead %d\n", seen_dead);
	376	if (seen_dead > 4) {
	377	fprintf(stderr, "watchdog: lockup detected, aborting\n");
	378	// we can't do any cleanup here really, the main thread is
	379	// likely touching resources and would crash anyway
	380	abort();
	381	}
	382	}
	383	}
	384
	385	void pl_start_watchdog(void)
	386	{
	387	pthread_attr_t attr;
	388	pthread_t tid;
	389	int ret;
	390
	391	pthread_attr_init(&attr);
	392	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	393
	394	ret = pthread_create(&tid, &attr, watchdog_thread, NULL);
	395	if (ret != 0)
	396	fprintf(stderr, "could not start watchdog: %d\n", ret);
	397	}
	398