int SVGA_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
int keyboard;
int i, j;
int mode, total_modes;
/* Initialize all variables that we clean on shutdown */
for ( i=0; i<NUM_MODELISTS; ++i ) {
SDL_nummodes[i] = 0;
SDL_modelist[i] = NULL;
SDL_vgamode[i] = NULL;
}
/* Initialize the library */
vga_disabledriverreport();
if ( vga_init() < 0 ) {
SDL_SetError("Unable to initialize SVGAlib");
return(-1);
}
vga_setmode(TEXT);
/* Enable mouse and keyboard support */
vga_setmousesupport(1);
keyboard = keyboard_init_return_fd();
if ( keyboard < 0 ) {
SDL_SetError("Unable to initialize keyboard");
return(-1);
}
if ( SVGA_initkeymaps(keyboard) < 0 ) {
return(-1);
}
keyboard_seteventhandler(SVGA_keyboardcallback);
/* Determine the screen depth (use default 8-bit depth) */
vformat->BitsPerPixel = 8;
/* Enumerate the available fullscreen modes */
total_modes = 0;
for ( mode=vga_lastmodenumber(); mode; --mode ) {
if ( vga_hasmode(mode) ) {
if ( SVGA_AddMode(this, mode, 0, 0) ) {
++total_modes;
}
}
}
if ( SVGA_AddMode(this, G320x200x256, 0, 1) ) ++total_modes;
if ( total_modes == 0 ) {
SDL_SetError("No linear video modes available");
return(-1);
}
for ( i=0; i<NUM_MODELISTS; ++i ) {
SDL_vgamode[i] = (int *)malloc(SDL_nummodes[i]*sizeof(int));
if ( SDL_vgamode[i] == NULL ) {
SDL_OutOfMemory();
return(-1);
}
SDL_modelist[i] = (SDL_Rect **)
malloc((SDL_nummodes[i]+1)*sizeof(SDL_Rect *));
if ( SDL_modelist[i] == NULL ) {
SDL_OutOfMemory();
return(-1);
}
for ( j=0; j<SDL_nummodes[i]; ++j ) {
SDL_modelist[i][j]=(SDL_Rect *)malloc(sizeof(SDL_Rect));
if ( SDL_modelist[i][j] == NULL ) {
SDL_OutOfMemory();
return(-1);
}
memset(SDL_modelist[i][j], 0, sizeof(SDL_Rect));
}
SDL_modelist[i][j] = NULL;
}
for ( mode=vga_lastmodenumber(); mode; --mode ) {
if ( vga_hasmode(mode) ) {
SVGA_AddMode(this, mode, 1, 0);
}
}
SVGA_AddMode(this, G320x200x256, 1, 1);
/* Free extra (duplicated) modes */
for ( i=0; i<NUM_MODELISTS; ++i ) {
j = 0;
while ( SDL_modelist[i][j] && SDL_modelist[i][j]->w ) {
j++;
}
while ( SDL_modelist[i][j] ) {
free(SDL_modelist[i][j]);
SDL_modelist[i][j] = NULL;
j++;
}
}
/* Fill in our hardware acceleration capabilities */
SVGA_UpdateVideoInfo(this);
/* We're done! */
return(0);
}
int os_inner_init(const char* title)
{
const char* display;
struct utsname uts;
struct sigaction term_action;
struct sigaction quit_action;
struct sigaction hup_action;
struct sigaction pipe_action;
#ifdef USE_SDL
SDL_version compiled;
#endif
unsigned char endian[4] = { 0x1, 0x2, 0x3, 0x4 };
uint32 endian_little = 0x04030201;
uint32 endian_big = 0x01020304;
log_std(("os: os_inner_init\n"));
if (uname(&uts) != 0) {
log_std(("ERROR:os: uname failed\n"));
} else {
log_std(("os: sys %s\n", uts.sysname));
log_std(("os: release %s\n", uts.release));
log_std(("os: version %s\n", uts.version));
log_std(("os: machine %s\n", uts.machine));
}
#if HAVE_SYSCONF
#ifdef _SC_CLK_TCK
log_std(("os: sysconf(_SC_CLK_TCK) %ld\n", sysconf(_SC_CLK_TCK)));
#endif
#ifdef _SC_NPROCESSORS_CONF
log_std(("os: sysconf(_SC_NPROCESSORS_CONF) %ld\n", sysconf(_SC_NPROCESSORS_CONF)));
#endif
#ifdef _SC_NPROCESSORS_ONLN
log_std(("os: sysconf(_SC_NPROCESSORS_ONLN) %ld\n", sysconf(_SC_NPROCESSORS_ONLN)));
#endif
#ifdef _SC_PHYS_PAGES
log_std(("os: sysconf(_SC_PHYS_PAGES) %ld\n", sysconf(_SC_PHYS_PAGES)));
#endif
#ifdef _SC_AVPHYS_PAGES
log_std(("os: sysconf(_SC_AVPHYS_PAGES) %ld\n", sysconf(_SC_AVPHYS_PAGES)));
#endif
#ifdef _SC_CHAR_BIT
log_std(("os: sysconf(_SC_CHAR_BIT) %ld\n", sysconf(_SC_CHAR_BIT)));
#endif
#ifdef _SC_LONG_BIT
log_std(("os: sysconf(_SC_LONG_BIT) %ld\n", sysconf(_SC_LONG_BIT)));
#endif
#ifdef _SC_WORD_BIT
log_std(("os: sysconf(_SC_WORD_BIT) %ld\n", sysconf(_SC_WORD_BIT)));
#endif
#endif
#ifdef _POSIX_PRIORITY_SCHEDULING /* OSDEF Check for POSIX scheduling */
log_std(("os: scheduling available\n"));
#else
log_std(("os: scheduling NOT available\n"));
#endif
/* print the compiler version */
#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) /* OSDEF Detect compiler version */
#define COMPILER_RESOLVE(a) #a
#define COMPILER(a, b, c) COMPILER_RESOLVE(a) "." COMPILER_RESOLVE(b) "." COMPILER_RESOLVE(c)
log_std(("os: compiler GNU %s\n", COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)));
#else
log_std(("os: compiler unknown\n"));
#endif
/* check for int size */
if (sizeof(uint8) != 1) {
target_err("The program is compiled with invalid uint8 type.\n");
return -1;
}
if (sizeof(uint16) != 2) {
target_err("The program is compiled with invalid uint16 type.\n");
return -1;
}
if (sizeof(uint32) != 4) {
target_err("The program is compiled with invalid uint32 type.\n");
return -1;
}
if (sizeof(uint64) != 8) {
target_err("The program is compiled with invalid uint64 type.\n");
return -1;
}
/* check for the endianess */
#ifdef USE_MSB
log_std(("os: compiled big endian system\n"));
if (memcmp(endian, &endian_big, 4) != 0) {
target_err("The program is compiled as bigendian but system doesn't appear to be bigendian.\n");
return -1;
}
#endif
#ifdef USE_LSB
log_std(("os: compiled little endian system\n"));
if (memcmp(endian, &endian_little, 4) != 0) {
target_err("The program is compiled as littleendian but system doesn't appear to be littleendian.\n");
return -1;
}
#endif
#ifdef USE_SMP
/* check the thread support */
if (os_thread() != 0) {
target_err("Error on the threading support.\n");
return -1;
}
#endif
/* get DISPLAY environment variable */
display = getenv("DISPLAY");
if (display)
log_std(("os: DISPLAY=%s\n", display));
else
log_std(("os: DISPLAY undef\n"));
/* probe the delay system */
os_delay();
if (!os_internal_wm_active()) {
log_std(("os: save term\n"));
if (tcgetattr(fileno(stdin), &OS.term) != 0) {
log_std(("ERROR:os: error getting the tty state.\n"));
OS.term_active = 0;
} else {
OS.term_active = 1;
}
}
#if defined(USE_X)
OS.x_active = 0;
{
int event_base, error_base;
int major_version, minor_version;
log_std(("os: XOpenDisplay()\n"));
OS.dga_display = XOpenDisplay(0);
if (OS.dga_display) {
OS.x_active = 1;
} else {
log_std(("WARNING:os: XOpenDisplay() failed. All the X drivers will be disabled.\n"));
}
}
#endif
#if defined(USE_SVGALIB)
OS.svgalib_active = 0;
if (!os_internal_wm_active()) {
int h;
log_std(("os: open /dev/svga\n"));
/* try opening the device, otherwise vga_init() will abort the program. */
h = open("/dev/svga", O_RDWR);
if (h >= 0) {
int res;
close(h);
vga_disabledriverreport();
/* check the version of the SVGALIB */
res = vga_setmode(-1);
if (res < 0 || res < 0x1911) { /* 1.9.11 */
log_std(("WARNING:os: invalid SVGALIB version %x. All the SVGALIB drivers will be disabled.\n", (int)res));
/* don't print the message. It may be a normal condition. */
/* target_nfo("Invalid SVGALIB version, you need SVGALIB version 1.9.x or 2.0.x.\nPlease upgrade or recompile without SVGALIB support.\n"); */
} else {
log_std(("os: vga_init()\n"));
if (vga_init() != 0) {
log_std(("os: vga_init() failed\n"));
target_err("Error initializing the SVGALIB video support.\n");
return -1;
}
OS.svgalib_active = 1;
}
} else {
log_std(("WARNING:os: open /dev/svga failed. All the SVGALIB drivers will be disabled.\n"));
/* don't print the message. It may be a normal condition. */
/* target_nfo("Error opening the SVGALIB device /dev/svga.\n"); */
}
} else {
log_std(("WARNING:os: vga_init() skipped because X is active. All the SVGALIB drivers will be disabled.\n"));
/* don't print the message. It may be a normal condition. */
/* target_nfo("SVGALIB not initialized because it's unusable in X.\n"); */
}
#endif
#if defined(USE_SDL)
log_std(("os: SDL_Init(SDL_INIT_NOPARACHUTE)\n"));
if (SDL_Init(SDL_INIT_NOPARACHUTE) != 0) {
log_std(("os: SDL_Init() failed, %s\n", SDL_GetError()));
target_err("Error initializing the SDL video support.\n");
return -1;
}
OS.sdl_active = 1;
SDL_VERSION(&compiled);
log_std(("os: compiled with sdl %d.%d.%d\n", compiled.major, compiled.minor, compiled.patch));
log_std(("os: linked with sdl %d.%d.%d\n", SDL_Linked_Version()->major, SDL_Linked_Version()->minor, SDL_Linked_Version()->patch));
#ifdef USE_MSB
if (SDL_BYTEORDER != SDL_BIG_ENDIAN) {
target_err("Invalid SDL endianess.\n");
return -1;
}
#endif
#ifdef USE_LSB
if (SDL_BYTEORDER != SDL_LIL_ENDIAN) {
target_err("Invalid SDL endianess.\n");
return -1;
}
#endif
#endif
#if defined(USE_SLANG)
OS.slang_active = 0;
if (!os_internal_wm_active()) {
log_std(("os: SLtt_get_terminfo()\n"));
SLtt_get_terminfo();
log_std(("os: SLsmg_init_smg()\n"));
SLsmg_init_smg();
OS.slang_active = 1;
} else {
log_std(("WARNING:os: SLang_init_tty() skipped because X is active. All the SLang drivers will be disabled.\n"));
}
#endif
#if defined(USE_CURSES)
OS.curses_active = 0;
if (!os_internal_wm_active()) {
log_std(("os: initscr()\n"));
initscr();
start_color();
cbreak();
noecho();
nonl();
OS.curses_active = 1;
} else {
log_std(("WARNING:os: curses initscr() skipped because X is active. All the curses drivers will be disabled.\n"));
}
#endif
/* set the titlebar */
sncpy(OS.title_buffer, sizeof(OS.title_buffer), title);
/* set some signal handlers */
/* STANDARD signals */
term_action.sa_handler = (void (*)(int))os_signal;
/* block external generated signals in the signal handler */
sigemptyset(&term_action.sa_mask);
sigaddset(&term_action.sa_mask, SIGALRM);
sigaddset(&term_action.sa_mask, SIGINT);
sigaddset(&term_action.sa_mask, SIGTERM);
sigaddset(&term_action.sa_mask, SIGHUP);
sigaddset(&term_action.sa_mask, SIGQUIT);
term_action.sa_flags = SA_RESTART | SA_SIGINFO;
/* external generated */
sigaction(SIGALRM, &term_action, 0);
sigaction(SIGINT, &term_action, 0);
sigaction(SIGTERM, &term_action, 0);
/* internal generated */
sigaction(SIGABRT, &term_action, 0);
sigaction(SIGFPE, &term_action, 0);
sigaction(SIGILL, &term_action, 0);
sigaction(SIGSEGV, &term_action, 0);
sigaction(SIGBUS, &term_action, 0);
/* HUP signal */
hup_action.sa_handler = os_hup_signal;
sigemptyset(&hup_action.sa_mask);
hup_action.sa_flags = SA_RESTART;
sigaction(SIGHUP, &hup_action, 0);
/* QUIT signal */
quit_action.sa_handler = os_quit_signal;
sigemptyset(&quit_action.sa_mask);
quit_action.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &quit_action, 0);
/* PIPE signal, ignoring it force some functions to */
/* return with error. It happen for example on the LCD sockets. */
pipe_action.sa_handler = SIG_IGN;
sigemptyset(&pipe_action.sa_mask);
pipe_action.sa_flags = SA_RESTART;
sigaction(SIGPIPE, &pipe_action, 0);
return 0;
}
