themusicgod1
/
evacuated-infinity-plugin
1
0
Fork 0
Code Issues 14 Pull Requests Projects Releases Wiki Activity

Initial port to SDL2 - WIP

This commit is contained in:
Duilio Protti 2016-07-01 00:25:36 -03:00
parent 02e2936efd
commit 5e81912125
5 changed files with 234 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure.ac
View File

@ -38,7 +38,7 @@ PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.28,,)
AC_SUBST(GLIB_LIBS) AC_SUBST(GLIB_LIBS)
AC_SUBST(GLIB_CFLAGS) AC_SUBST(GLIB_CFLAGS)
PKG_CHECK_MODULES(SDL, sdl >= 1.2,,) PKG_CHECK_MODULES(SDL, sdl2 >= 2,,)
AC_SUBST(SDL_LIBS) AC_SUBST(SDL_LIBS)
AC_SUBST(SDL_CFLAGS) AC_SUBST(SDL_CFLAGS)

141
src/display.c
View File

@ -17,6 +17,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <glib.h> #include <glib.h>
#include <SDL.h>
#include "config.h" #include "config.h"
#include "display.h" #include "display.h"
@ -25,7 +26,7 @@
#define wrap(a) (a < 0 ? 0 : (a > 255 ? 255 : a)) #define wrap(a) (a < 0 ? 0 : (a > 255 ? 255 : a))
#define assign_max(p, a) (*p <= a ? *p = a : 0) #define assign_max(p, a) (*p <= a ? *p = a : 0)
#define VIDEO_FLAGS ((Uint32)(SDL_HWSURFACE | SDL_HWPALETTE | SDL_DOUBLEBUF | SDL_RESIZABLE)) #define VIDEO_FLAGS ((Uint32)(SDL_WINDOW_SHOWN|SDL_WINDOW_RESIZABLE))
typedef struct sincos { typedef struct sincos {
gint32 i; gint32 i;
@ -33,7 +34,7 @@ typedef struct sincos {
} sincos_t; } sincos_t;
static gint16 pcm_data[2][512]; static gint16 pcm_data[2][512];
static SDL_mutex *pcm_data_mutex; G_LOCK_DEFINE_STATIC(pcm_data);
static gint32 width, height, scale; static gint32 width, height, scale;
@ -43,7 +44,10 @@ static sincos_t sinw = { 0, NULL };
static vector_field_t *vector_field; static vector_field_t *vector_field;
static SDL_Surface *screen = NULL; static SDL_Window *window;
static SDL_Renderer *sdl_renderer;
static SDL_Surface *screen;
static SDL_Texture *texture;
static SDL_Color color_table[NB_PALETTES][256]; static SDL_Color color_table[NB_PALETTES][256];
static gint16 current_colors[256]; static gint16 current_colors[256];
@ -52,25 +56,48 @@ static byte *surface1;
static Player *player; static Player *player;
static gchar error_msg[256]; static gchar error_msg[256];
static gboolean initialized;
static gboolean sdl_init(gint32 _width, gint32 _height, gint32 _scale) static gboolean allocate_screen_and_texture() {
{ if (screen != NULL) {
if (SDL_Init((Uint32)(SDL_INIT_VIDEO | SDL_INIT_TIMER)) < 0) { SDL_FreeSurface(screen);
g_snprintf(error_msg, 256, "Infinity cannot initialize SDL: %s", SDL_GetError());
player->notify_critical_error(error_msg);
return FALSE;
} }
screen = SDL_SetVideoMode(_width * _scale, _height * _scale, 16, VIDEO_FLAGS); screen = SDL_CreateRGBSurface(0, width, height, 16, 0, 0, 0, 0);
if (screen == NULL) { if (screen == NULL) {
g_snprintf(error_msg, 256, "Infinity cannot create display: %s", SDL_GetError()); g_snprintf(error_msg, 256, "Infinity cannot create display: %s", SDL_GetError());
player->notify_critical_error(error_msg); player->notify_critical_error(error_msg);
return FALSE; return FALSE;
} }
(void)SDL_ShowCursor(0); SDL_SetSurfaceBlendMode(screen, SDL_BLENDMODE_NONE);
(void)SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); if (texture != NULL) {
SDL_DestroyTexture(texture);
}
texture = SDL_CreateTexture(sdl_renderer,
SDL_PIXELFORMAT_RGB565,
SDL_TEXTUREACCESS_STREAMING,
width, height);
if (texture == NULL) {
g_snprintf(error_msg, 256, "Infinity cannot create SDL texture: %s", SDL_GetError());
player->notify_critical_error(error_msg);
return FALSE;
}
return TRUE; return TRUE;
} }
static gboolean sdl_init()
{
SDL_InitSubSystem(SDL_INIT_EVENTS);
int res = SDL_CreateWindowAndRenderer(width, height, VIDEO_FLAGS, &window, &sdl_renderer);
if (res < 0) {
g_snprintf(error_msg, 256, "Infinity cannot initialize SDL: %s", SDL_GetError());
player->notify_critical_error(error_msg);
return FALSE;
}
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); // make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(sdl_renderer, width, height);
return allocate_screen_and_texture();
}
static void generate_colors() static void generate_colors()
{ {
gint32 i, k; gint32 i, k;
@ -97,53 +124,31 @@ static void display_surface()
gint32 i, j; gint32 i, j;
gint16 *pdest; gint16 *pdest;
byte *psrc; byte *psrc;
gboolean screen_locked; gboolean screen_locked = FALSE;
if (SDL_MUSTLOCK(screen)) { if (SDL_MUSTLOCK(screen)) {
if (SDL_LockSurface(screen) < 0) { if (SDL_LockSurface(screen) < 0) {
g_error("Infinity: Cannot lock screen: %s", SDL_GetError()); g_critical("Infinity cannot lock SDL surface: %s", SDL_GetError());
return; return;
} }
screen_locked = TRUE; screen_locked = TRUE;
} else {
screen_locked = FALSE;
} }
if (scale > 1) {
for (i = 0; i < height; i++) {
pdest = (gint16 *)(screen->pixels + i * screen->pitch * scale);
psrc = surface1 + i * width;
if (scale == 2) {
for (j = 1; j < width; j++) {
*(pdest++) = current_colors[*psrc++];
*(pdest) = *(pdest - 1);
pdest++;
}
memcpy(screen->pixels + i * screen->pitch * 2 + screen->pitch,
screen->pixels + i * screen->pitch * 2, screen->pitch);
} /* else {
* for (j=1;j<width;j++) {
*(pdest++)=current_colors[*psrc++];
*(pdest++)=*(pdest-1);
*(pdest++)=*(pdest-1);
* }
* memcpy(screen->pixels+i*screen->pitch*3+screen->pitch,
* screen->pixels+i*screen->pitch*3,screen->pitch);
* memcpy(screen->pixels+i*screen->pitch*3+screen->pitch*2,
* screen->pixels+i*screen->pitch*3,screen->pitch);
* } */
} /* for */
} else {
psrc = surface1; psrc = surface1;
for (i = 0; i < height; i++) { for (i = 0; i < height; i++) {
pdest = (gint16 *)(screen->pixels + i * screen->pitch); pdest = (gint16 *)(screen->pixels + i * screen->pitch);
for (j = 0; j < width; j++) for (j = 0; j < width; j++)
*pdest++ = current_colors[*psrc++]; *pdest++ = current_colors[*psrc++];
} }
} SDL_UpdateTexture(texture, NULL, screen->pixels, screen->pitch);
if (screen_locked) if (screen_locked)
SDL_UnlockSurface(screen); SDL_UnlockSurface(screen);
else else {
(void)SDL_Flip(screen); SDL_RenderClear(sdl_renderer);
SDL_RenderCopy(sdl_renderer, texture, NULL, NULL);
SDL_RenderPresent(sdl_renderer);
}
} }
#define plot1(x, y, c) \ #define plot1(x, y, c) \
@ -226,9 +231,8 @@ gboolean display_init(gint32 _width, gint32 _height, gint32 _scale, Player *_pla
scale = _scale; scale = _scale;
player = _player; player = _player;
pcm_data_mutex = SDL_CreateMutex();
compute_init(width, height, scale); compute_init(width, height, scale);
sdl_ok = sdl_init(width, height, scale); sdl_ok = sdl_init();
generate_colors(); generate_colors();
effects_load_effects(); effects_load_effects();
vector_field = compute_vector_field_new(width, height); vector_field = compute_vector_field_new(width, height);
@ -236,36 +240,39 @@ gboolean display_init(gint32 _width, gint32 _height, gint32 _scale, Player *_pla
if (!sdl_ok) { if (!sdl_ok) {
display_quit(); display_quit();
} }
initialized = TRUE;
return sdl_ok; return sdl_ok;
} }
void display_quit(void) void display_quit(void)
{ {
if (! initialized)
return;
compute_vector_field_destroy(vector_field); compute_vector_field_destroy(vector_field);
compute_quit(); compute_quit();
SDL_DestroyMutex(pcm_data_mutex);
if (screen != NULL) if (screen != NULL)
SDL_FreeSurface(screen); SDL_FreeSurface(screen);
screen = NULL; screen = NULL;
SDL_Quit(); if (window != NULL)
SDL_DestroyWindow(window);
window = NULL;
// do not call SDL_Quit() since there is another plugin that use
// SDL inside Audacious
SDL_QuitSubSystem(SDL_INIT_EVENTS);
initialized = FALSE;
} }
gboolean display_resize(gint32 _width, gint32 _height) gboolean display_resize(gint32 _width, gint32 _height)
{ {
width = _width; width = _width;
height = _height; height = _height;
screen = SDL_SetVideoMode(width * scale, height * scale, 16, VIDEO_FLAGS);
if (screen == NULL) { gboolean screen_ok = allocate_screen_and_texture();
g_snprintf(error_msg, 256, "Infinity cannot resize display to %dx%d pixels: %s",
width * scale, height * scale, SDL_GetError());
player->notify_critical_error(error_msg);
return FALSE;
}
compute_vector_field_destroy(vector_field); compute_vector_field_destroy(vector_field);
vector_field = compute_vector_field_new(width, height); vector_field = compute_vector_field_new(width, height);
compute_resize(width, height); compute_resize(width, height);
compute_generate_vector_field(vector_field); compute_generate_vector_field(vector_field);
return TRUE; return screen_ok;
} }
inline void display_set_pcm_data(const float *data, int channels) inline void display_set_pcm_data(const float *data, int channels)
@ -274,12 +281,10 @@ inline void display_set_pcm_data(const float *data, int channels)
g_critical("Unsupported number of channels (%d)\n", channels); g_critical("Unsupported number of channels (%d)\n", channels);
return; return;
} }
/* begin CS */ G_LOCK(pcm_data);
g_return_if_fail(SDL_mutexP(pcm_data_mutex) >= 0);
// TODO check this out, different types here... // TODO check this out, different types here...
memcpy(pcm_data, data, 2 * 512 * sizeof(gint16)); memcpy(pcm_data, data, 2 * 512 * sizeof(gint16));
g_return_if_fail(SDL_mutexV(pcm_data_mutex) >= 0); G_UNLOCK(pcm_data);
/* end CS */
} }
void change_color(gint32 t2, gint32 t1, gint32 w) void change_color(gint32 t2, gint32 t1, gint32 w)
@ -320,8 +325,7 @@ void spectral(t_effect *current_effect)
const gint32 step = 4; const gint32 step = 4;
const gint32 shift = (current_effect->spectral_shift * height) >> 8; const gint32 shift = (current_effect->spectral_shift * height) >> 8;
/* begin CS */ G_LOCK(pcm_data);
g_return_if_fail(SDL_mutexP(pcm_data_mutex) >= 0);
y1 = (gfloat)((((pcm_data[0][0] + pcm_data[1][0]) >> 9) * current_effect->spectral_amplitude * height) >> 12); y1 = (gfloat)((((pcm_data[0][0] + pcm_data[1][0]) >> 9) * current_effect->spectral_amplitude * height) >> 12);
y2 = (gfloat)((((pcm_data[0][0] + pcm_data[1][0]) >> 9) * current_effect->spectral_amplitude * height) >> 12); y2 = (gfloat)((((pcm_data[0][0] + pcm_data[1][0]) >> 9) * current_effect->spectral_amplitude * height) >> 12);
if (cosw.i != width || sinw.i != width) { if (cosw.i != width || sinw.i != width) {
@ -411,7 +415,7 @@ void spectral(t_effect *current_effect)
break; break;
} }
} }
g_return_if_fail(SDL_mutexV(pcm_data_mutex) >= 0); G_UNLOCK(pcm_data);
if (current_effect->mode_spectre == 3 || current_effect->mode_spectre == 4) { if (current_effect->mode_spectre == 3 || current_effect->mode_spectre == 4) {
line(halfwidth + cosw.f[width - step] * (shift + y1), line(halfwidth + cosw.f[width - step] * (shift + y1),
halfheight + sinw.f[width - step] * (shift + y1), halfheight + sinw.f[width - step] * (shift + y1),
@ -450,8 +454,15 @@ void curve(t_effect *current_effect)
void display_toggle_fullscreen(void) void display_toggle_fullscreen(void)
{ {
if (SDL_WM_ToggleFullScreen(screen) < 0) Uint32 is_fullscreen = SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN;
g_warning("Cannot toggle to fullscreen mode: %s", SDL_GetError()); if (SDL_SetWindowFullscreen(window, is_fullscreen ? 0 : SDL_WINDOW_FULLSCREEN) < 0)
g_warning("Infinity cannot change fullscreen mode: %s", SDL_GetError());
SDL_ShowCursor(is_fullscreen);
}
void display_set_title(const gchar *title) {
g_return_if_fail(window != NULL);
SDL_SetWindowTitle(window, title);
} }
void display_save_screen(void) void display_save_screen(void)

2
src/display.h
View File

@ -16,7 +16,6 @@
#ifndef __INFINITY_DISPLAY__ #ifndef __INFINITY_DISPLAY__
#define __INFINITY_DISPLAY__ #define __INFINITY_DISPLAY__
#include <SDL/SDL.h>
#include <glib.h> #include <glib.h>
#include "compute.h" #include "compute.h"
@ -84,6 +83,7 @@ void curve(t_effect *current_effect);
*/ */
void display_toggle_fullscreen(void); void display_toggle_fullscreen(void);
void display_set_title(const gchar *title);
void display_save_screen(void); void display_save_screen(void);
void display_save_effect(t_effect *effect); void display_save_effect(t_effect *effect);
void display_load_random_effect(t_effect *effect); void display_load_random_effect(t_effect *effect);

219
src/infinity.c
View File

@ -18,9 +18,8 @@
#include <unistd.h> #include <unistd.h>
#include <glib.h> #include <glib.h>
#include <SDL/SDL.h> #include <SDL.h>
#include <SDL/SDL_thread.h> #include <SDL_thread.h>
/*#include <SDL/SDL_syswm.h>*/
#include "config.h" #include "config.h"
#include "display.h" #include "display.h"
@ -50,7 +49,7 @@ static t_num_effect t_last_effect;
static gboolean must_resize; static gboolean must_resize;
static gboolean finished; static gboolean finished;
static gboolean resizing; static gboolean resizing;
static SDL_mutex *resizing_mutex; G_LOCK_DEFINE_STATIC(resizing);
static gboolean initializing = FALSE; static gboolean initializing = FALSE;
static gboolean visible; static gboolean visible;
static gboolean quiting; static gboolean quiting;
@ -61,7 +60,7 @@ static GTimer *title_timer;
static SDL_Thread *thread; static SDL_Thread *thread;
static gint32 event_filter(const SDL_Event *event); static int event_filter(void*, SDL_Event *event);
static void check_events(); static void check_events();
static int renderer(void *); static int renderer(void *);
static void set_title(void); static void set_title(void);
@ -101,7 +100,6 @@ void infinity_init(InfParameters * _params, Player * _player)
finished = FALSE; finished = FALSE;
must_resize = FALSE; must_resize = FALSE;
resizing = FALSE; resizing = FALSE;
resizing_mutex = SDL_CreateMutex();
mode_interactif = FALSE; mode_interactif = FALSE;
visible = TRUE; visible = TRUE;
quiting = FALSE; quiting = FALSE;
@ -113,15 +111,9 @@ void infinity_init(InfParameters * _params, Player * _player)
g_timer_start(title_timer); g_timer_start(title_timer);
display_load_random_effect(&current_effect); display_load_random_effect(&current_effect);
(void)SDL_EventState((Uint8)SDL_ALLEVENTS, SDL_IGNORE); SDL_SetEventFilter(event_filter, NULL);
(void)SDL_EventState((Uint8)SDL_VIDEORESIZE, SDL_ENABLE);
(void)SDL_EventState((Uint8)SDL_ACTIVEEVENT, SDL_ENABLE);
(void)SDL_EventState((Uint8)SDL_KEYDOWN, SDL_ENABLE);
(void)SDL_EventState((Uint8)SDL_QUIT, SDL_ENABLE);
SDL_SetEventFilter(event_filter); thread = SDL_CreateThread(renderer, "infinity_renderer", NULL);
thread = SDL_CreateThread(renderer, NULL);
} }
void infinity_finish(void) void infinity_finish(void)
@ -142,7 +134,6 @@ void infinity_finish(void)
quiting = TRUE; quiting = TRUE;
finished = TRUE; finished = TRUE;
SDL_WaitThread(thread, NULL); SDL_WaitThread(thread, NULL);
SDL_DestroyMutex(resizing_mutex);
/* /*
* Take some time to let it know infinity_render_multi_pcm() * Take some time to let it know infinity_render_multi_pcm()
* that must not call display_set_pcm_data(). * that must not call display_set_pcm_data().
@ -153,13 +144,13 @@ void infinity_finish(void)
* *
* See display.h::display_set_pcm_data() * See display.h::display_set_pcm_data()
*/ */
g_usleep(10000 * SDL_TIMESLICE); g_usleep(1000000);
display_quit(); display_quit();
g_timer_destroy(title_timer); g_timer_destroy(title_timer);
player->disable_plugin(); player->disable_plugin();
g_message("Infinity: Closing..."); g_message("Infinity is shut down");
} }
void infinity_render_multi_pcm(const float *data, int channels) void infinity_render_multi_pcm(const float *data, int channels)
@ -168,27 +159,85 @@ void infinity_render_multi_pcm(const float *data, int channels)
display_set_pcm_data(data, channels); display_set_pcm_data(data, channels);
} }
/* // TODO really needed?
* Private functions static int event_filter(void *user_data, SDL_Event *event)
*/
static gint32 event_filter(const SDL_Event *event)
{ {
if (!event) { if (!event) {
g_warning("Infinity: SDL_Event is NULL"); g_warning("Infinity: SDL_Event is NULL");
return 0; return 0;
} }
switch (event->type) { if (event->type == SDL_WINDOWEVENT) {
switch (event->window.event) {
case SDL_WINDOWEVENT_SHOWN:
SDL_Log("Window %d shown", event->window.windowID);
break;
case SDL_WINDOWEVENT_HIDDEN:
SDL_Log("Window %d hidden", event->window.windowID);
break;
case SDL_WINDOWEVENT_EXPOSED:
SDL_Log("Window %d exposed", event->window.windowID);
break;
case SDL_WINDOWEVENT_MOVED:
SDL_Log("Window %d moved to %d,%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_RESIZED:
SDL_Log("Window %d resized to %dx%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
SDL_Log("Window %d size changed to %dx%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_MINIMIZED:
SDL_Log("Window %d minimized", event->window.windowID);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
SDL_Log("Window %d maximized", event->window.windowID);
break;
case SDL_WINDOWEVENT_RESTORED:
SDL_Log("Window %d restored", event->window.windowID);
break;
case SDL_WINDOWEVENT_ENTER:
SDL_Log("Mouse entered window %d",
event->window.windowID);
break;
case SDL_WINDOWEVENT_LEAVE:
SDL_Log("Mouse left window %d", event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
SDL_Log("Window %d gained keyboard focus",
event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
SDL_Log("Window %d lost keyboard focus",
event->window.windowID);
break;
case SDL_WINDOWEVENT_CLOSE:
SDL_Log("event_filter Window %d closed", event->window.windowID);
break;
default:
SDL_Log("Window %d got unknown event %d",
event->window.windowID, event->window.event);
break;
}
}
/*switch (event->type) {
case SDL_VIDEORESIZE: case SDL_VIDEORESIZE:
g_return_val_if_fail(SDL_LockMutex(resizing_mutex) >= 0, 0); G_LOCK(resizing);
if (resizing) { if (resizing) {
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, 0); G_UNLOCK(resizing);
/* /*
* VIDEORESIZE event dropped from event queue * VIDEORESIZE event dropped from event queue
*/ *
return 0; return 0;
} else { } else {
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, 0); G_UNLOCK(resizing);
return 1; return 1;
} }
g_assert_not_reached(); g_assert_not_reached();
@ -209,20 +258,84 @@ static gint32 event_filter(const SDL_Event *event)
break; break;
default: default:
break; break;
} }*/
return 1; return 1;
} }
static void handle_window_event(SDL_Event *event) {
switch (event->window.event) {
case SDL_WINDOWEVENT_SHOWN:
SDL_Log("Window %d shown", event->window.windowID);
break;
case SDL_WINDOWEVENT_HIDDEN:
SDL_Log("Window %d hidden", event->window.windowID);
break;
case SDL_WINDOWEVENT_EXPOSED:
SDL_Log("Window %d exposed", event->window.windowID);
break;
case SDL_WINDOWEVENT_MOVED:
SDL_Log("Window %d moved to %d,%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_RESIZED:
SDL_Log("Window %d resized to %dx%d",
event->window.windowID, event->window.data1,
event->window.data2);
G_LOCK(resizing);
resizing = TRUE;
G_UNLOCK(resizing);
width = event->window.data1;
height = event->window.data2;
g_message("Infinity: Screen resized to %dx%d pixels^2", width, height);
must_resize = TRUE;
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
SDL_Log("Window %d size changed to %dx%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_MINIMIZED:
SDL_Log("Window %d minimized", event->window.windowID);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
SDL_Log("Window %d maximized", event->window.windowID);
break;
case SDL_WINDOWEVENT_RESTORED:
SDL_Log("Window %d restored", event->window.windowID);
break;
case SDL_WINDOWEVENT_ENTER:
SDL_Log("Mouse entered window %d",
event->window.windowID);
break;
case SDL_WINDOWEVENT_LEAVE:
SDL_Log("Mouse left window %d", event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
SDL_Log("Window %d gained keyboard focus",
event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
SDL_Log("Window %d lost keyboard focus",
event->window.windowID);
break;
case SDL_WINDOWEVENT_CLOSE:
SDL_Log("Window %d closed", event->window.windowID);
//infinity_finish();
player->disable_plugin();
break;
default:
SDL_Log("Window %d got unknown event %d",
event->window.windowID, event->window.event);
break;
}
}
static void check_events() static void check_events()
{ {
SDL_Event event; SDL_Event event;
/*XEvent *xevent;
* XWindowChanges changes;
* XWindowAttributes attr;
* XSetWindowAttributes s_attr;*/
if (params->must_show_title()) { if (params->must_show_title()) {
if (g_timer_elapsed(title_timer, NULL) > 1.0) { if (g_timer_elapsed(title_timer, NULL) > 1.0) {
if (player->is_playing()) { if (player->is_playing()) {
@ -241,43 +354,11 @@ static void check_events()
while (SDL_PollEvent(&event)) { while (SDL_PollEvent(&event)) {
switch (event.type) { switch (event.type) {
/*case SDL_SYSWMEVENT:
* g_message ("Infinity: SDL_SYSWMEVENT");
* if (event.syswm.msg != NULL) {
* if (event.syswm.msg->subsystem == SDL_SYSWM_X11) {
* xevent = &(event.syswm.msg->event.xevent);
* if (xevent == NULL)
* continue;
* if (first_xevent) {
* changes.x = config_get_x();
* changes.y = config_get_y();
* XConfigureWindow (xevent->xany.display,
* xevent->xany.window,
* CWX | CWY, &changes);
* first_xevent = FALSE;
* g_message ("Infinity: window moved to (%d,%d)",
* changes.x, changes.y);
* } else {
* XGetWindowAttributes (xevent->xany.display,
* xevent->xany.window,
* &attr);
* g_message ("Infinity: GetWindowAttributes (%d,%d)",
* attr.x, attr.y);
* }
* }
* }
* break;*/
case SDL_QUIT: case SDL_QUIT:
player->disable_plugin(); player->disable_plugin();
break; break;
case SDL_VIDEORESIZE: case SDL_WINDOWEVENT:
g_return_if_fail(SDL_LockMutex(resizing_mutex) >= 0); handle_window_event(&event);
resizing = TRUE;
g_return_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0);
width = event.resize.w;
height = event.resize.h;
g_message("Infinity: Screen resized to %dx%d pixels^2", width, height);
must_resize = TRUE;
break; break;
case SDL_KEYDOWN: case SDL_KEYDOWN:
switch (event.key.keysym.sym) { switch (event.key.keysym.sym) {
@ -418,9 +499,9 @@ static int renderer(void *arg)
params->set_width(width); params->set_width(width);
params->set_height(height); params->set_height(height);
must_resize = FALSE; must_resize = FALSE;
g_return_val_if_fail(SDL_LockMutex(resizing_mutex) >= 0, -1); G_LOCK(resizing);
resizing = FALSE; resizing = FALSE;
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, -1); G_UNLOCK(resizing);
} }
t_begin = g_get_monotonic_time(); t_begin = g_get_monotonic_time();
if (has_mmx) if (has_mmx)
@ -480,5 +561,5 @@ static int renderer(void *arg)
static void set_title(void) static void set_title(void)
{ {
SDL_WM_SetCaption(current_title, "Infinity"); display_set_title(current_title);
} }

2
src/types.h
View File

@ -16,7 +16,7 @@
#ifndef __INFINITY_TYPES__ #ifndef __INFINITY_TYPES__
#define __INFINITY_TYPES__ #define __INFINITY_TYPES__
#include <SDL/SDL.h> #include <SDL.h>
typedef Uint8 byte; typedef Uint8 byte;