void DGA_PumpEvents(_THIS)
{
/* Keep processing pending events */
LOCK_DISPLAY();
while ( X11_Pending(DGA_Display) ) {
DGA_DispatchEvent(this);
}
UNLOCK_DISPLAY();
}
bool vogleditor_traceReplayer::process_x_events()
{
while (X11_Pending(m_window.get_display()))
{
XEvent newEvent;
// Watch for new X events
XNextEvent(m_window.get_display(), &newEvent);
switch (newEvent.type)
{
case MapNotify:
{
m_pTraceReplayer->update_window_dimensions();
break;
}
case ConfigureNotify:
{
m_pTraceReplayer->update_window_dimensions();
break;
}
case DestroyNotify:
{
vogl_message_printf("Exiting\n");
return false;
break;
}
case ClientMessage:
{
if(newEvent.xclient.data.l[0] == (int)m_wmDeleteMessage)
{
vogl_message_printf("Exiting\n");
return false;
}
break;
}
default: break;
}
}
return true;
}
void X11_PumpEvents(_THIS)
{
int pending;
/* Keep processing pending events */
pending = 0;
while ( X11_Pending(SDL_Display) ) {
X11_DispatchEvent(this);
++pending;
}
if ( switch_waiting ) {
Uint32 now;
now = SDL_GetTicks();
if ( pending || !SDL_VideoSurface ) {
/* Try again later... */
if ( switch_waiting & SDL_FULLSCREEN ) {
switch_time = now + 1500;
} else {
switch_time = now + 200;
}
} else if ( now >= switch_time ) {
Uint32 go_fullscreen;
go_fullscreen = switch_waiting & SDL_FULLSCREEN;
switch_waiting = 0;
if ( SDL_VideoSurface->flags & SDL_FULLSCREEN ) {
if ( go_fullscreen ) {
X11_EnterFullScreen(this);
} else {
X11_LeaveFullScreen(this, 0);
}
}
/* Handle focus in/out when grabbed */
if ( go_fullscreen ) {
X11_GrabInputNoLock(this, this->input_grab);
} else {
X11_GrabInputNoLock(this, SDL_GRAB_OFF);
}
X11_CheckMouseModeNoLock(this);
}
}
}
void
X11_PumpEvents(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
/* Update activity every 30 seconds to prevent screensaver */
if (_this->suspend_screensaver) {
Uint32 now = SDL_GetTicks();
if (!data->screensaver_activity ||
(int) (now - data->screensaver_activity) >= 30000) {
XResetScreenSaver(data->display);
data->screensaver_activity = now;
}
}
/* Keep processing pending events */
while (X11_Pending(data->display)) {
X11_DispatchEvent(_this);
}
}
void DGA_PumpEvents(_THIS)
{
/* Keep processing pending events */
LOCK_DISPLAY();
/* Update activity every five seconds to prevent screensaver. --ryan. */
if (!allow_screensaver) {
static Uint32 screensaverTicks;
Uint32 nowTicks = SDL_GetTicks();
if ((nowTicks - screensaverTicks) > 5000) {
XResetScreenSaver(DGA_Display);
screensaverTicks = nowTicks;
}
}
while ( X11_Pending(DGA_Display) ) {
DGA_DispatchEvent(this);
}
UNLOCK_DISPLAY();
}
/*
* handle X11 events
* here we handle key, mouse, repaint and window sizing events
*/
static void X11_HandleEvents(GF_VideoOutput *vout)
{
GF_Event evt;
Window the_window;
XComposeStatus state;
X11VID();
unsigned char keybuf[32];
XEvent xevent;
the_window = xWindow->fullscreen ? xWindow->full_wnd : xWindow->wnd;
XSync(xWindow->display, False);
while (X11_Pending(xWindow->display)) {
XNextEvent(xWindow->display, &xevent);
if (xevent.xany.window!=the_window) continue;
switch (xevent.type) {
/*
* X11 window resized event
* must inform GPAC
*/
case ConfigureNotify:
if ((unsigned int) xevent.xconfigure.width != xWindow->w_width
|| (unsigned int) xevent.xconfigure.height != xWindow->w_height)
{
evt.type = GF_EVENT_SIZE;
xWindow->w_width = evt.size.width = xevent.xconfigure.width;
xWindow->w_height = evt.size.height = xevent.xconfigure.height;
vout->on_event(vout->evt_cbk_hdl, &evt);
} else {
evt.type = GF_EVENT_MOVE;
evt.move.x = xevent.xconfigure.x;
evt.move.y = xevent.xconfigure.y;
vout->on_event(vout->evt_cbk_hdl, &evt);
}
break;
/*
* Windows need repaint
*/
case Expose:
if (xevent.xexpose.count > 0) break;
evt.type = GF_EVENT_REFRESH;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage:
if ( (xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == xWindow->WM_DELETE_WINDOW) ) {
evt.type = GF_EVENT_QUIT;
vout->on_event(vout->evt_cbk_hdl, &evt);
}
break;
case KeyPress:
case KeyRelease:
x11_translate_key(XKeycodeToKeysym (xWindow->display, xevent.xkey.keycode, 0), &evt.key);
evt.type = (xevent.type ==KeyPress) ? GF_EVENT_KEYDOWN : GF_EVENT_KEYUP;
vout->on_event (vout->evt_cbk_hdl, &evt);
if (xevent.type ==KeyPress) {
s32 len;
len = XLookupString (&xevent.xkey, (char *) keybuf, sizeof(keybuf), NULL, &state);
if ((len>0) && (len<5)) {
utf8_to_ucs4 (& evt.character.unicode_char, len, keybuf);
evt.type = GF_EVENT_TEXTINPUT;
vout->on_event (vout->evt_cbk_hdl, &evt);
}
}
break;
case ButtonPress:
if (!xWindow->fullscreen && !xWindow->has_focus) {
xWindow->has_focus = 1;
XSetInputFocus(xWindow->display, xWindow->wnd, RevertToParent, CurrentTime);
}
case ButtonRelease:
// last_mouse_move = xevent.xbutton.time;
evt.mouse.x = xevent.xbutton.x;
evt.mouse.y = xevent.xbutton.y;
evt.type = (xevent.type == ButtonRelease) ? GF_EVENT_MOUSEUP : GF_EVENT_MOUSEDOWN;
switch (xevent.xbutton.button) {
case Button1:
evt.mouse.button = GF_MOUSE_LEFT;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case Button2:
evt.mouse.button = GF_MOUSE_MIDDLE;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case Button3:
evt.mouse.button = GF_MOUSE_RIGHT;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case Button4:
evt.type = GF_EVENT_MOUSEWHEEL;
evt.mouse.wheel_pos = FIX_ONE;
vout->on_event(vout->evt_cbk_hdl, &evt);
break;
case Button5:
evt.type = GF_EVENT_MOUSEWHEEL;
evt.mouse.wheel_pos = -FIX_ONE;
vout->on_event(vout->evt_cbk_hdl, &evt);
break;
}
if (!xWindow->fullscreen && (xevent.type==ButtonPress) )
XSetInputFocus(xWindow->display, xWindow->wnd, RevertToNone, CurrentTime);
break;
case MotionNotify:
evt.type = GF_EVENT_MOUSEMOVE;
evt.mouse.x = xevent.xmotion.x;
evt.mouse.y = xevent.xmotion.y;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case PropertyNotify:
break;
case MapNotify:
break;
case CirculateNotify:
break;
case UnmapNotify:
break;
case ReparentNotify:
break;
case FocusOut:
if (!xWindow->fullscreen) xWindow->has_focus = 0;
break;
case FocusIn:
if (!xWindow->fullscreen) xWindow->has_focus = 1;
break;
case DestroyNotify:
evt.type = GF_EVENT_QUIT;
vout->on_event(vout->evt_cbk_hdl, &evt);
break;
default:
break;
}
}
}
void
X11_PumpEvents(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
/* Update activity every 30 seconds to prevent screensaver */
if (_this->suspend_screensaver) {
Uint32 now = SDL_GetTicks();
if (!data->screensaver_activity ||
(int) (now - data->screensaver_activity) >= 30000) {
XResetScreenSaver(data->display);
data->screensaver_activity = now;
}
}
/* Keep processing pending events */
while (X11_Pending(data->display)) {
X11_DispatchEvent(_this);
}
#ifdef SDL_INPUT_LINUXEV
/* Process Touch events - TODO When X gets touch support, use that instead*/
int i = 0,rd;
char name[256];
struct input_event ev[64];
int size = sizeof (struct input_event);
for(i = 0;i < SDL_GetNumTouch();++i) {
SDL_Touch* touch = SDL_GetTouchIndex(i);
if(!touch) printf("Touch %i/%i DNE\n",i,SDL_GetNumTouch());
EventTouchData* data;
data = (EventTouchData*)(touch->driverdata);
if(data == NULL) {
printf("No driver data\n");
continue;
}
if(data->eventStream <= 0)
printf("Error: Couldn't open stream\n");
rd = read(data->eventStream, ev, size * 64);
//printf("Got %i/%i bytes\n",rd,size);
if(rd >= size) {
for (i = 0; i < rd / sizeof(struct input_event); i++) {
switch (ev[i].type) {
case EV_ABS:
//printf("Got position x: %i!\n",data->x);
switch (ev[i].code) {
case ABS_X:
data->x = ev[i].value;
break;
case ABS_Y:
data->y = ev[i].value;
break;
case ABS_PRESSURE:
data->pressure = ev[i].value;
if(data->pressure < 0) data->pressure = 0;
break;
case ABS_MISC:
if(ev[i].value == 0)
data->up = SDL_TRUE;
break;
}
break;
case EV_MSC:
if(ev[i].code == MSC_SERIAL)
data->finger = ev[i].value;
break;
case EV_SYN:
//printf("Id: %i\n",touch->id);
if(data->up) {
SDL_SendFingerDown(touch->id,data->finger,
SDL_FALSE,data->x,data->y,
data->pressure);
}
else if(data->x >= 0 || data->y >= 0)
SDL_SendTouchMotion(touch->id,data->finger,
SDL_FALSE,data->x,data->y,
data->pressure);
//printf("Synched: %i tx: %i, ty: %i\n",
// data->finger,data->x,data->y);
data->x = -1;
data->y = -1;
data->pressure = -1;
data->finger = 0;
data->up = SDL_FALSE;
break;
}
}
}
}
#endif
}
void
X11_PumpEvents(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
/* Update activity every 30 seconds to prevent screensaver */
if (_this->suspend_screensaver) {
Uint32 now = SDL_GetTicks();
if (!data->screensaver_activity ||
(int) (now - data->screensaver_activity) >= 30000) {
XResetScreenSaver(data->display);
#if SDL_USE_LIBDBUS
SDL_dbus_screensaver_tickle(_this);
#endif
data->screensaver_activity = now;
}
}
/* Keep processing pending events */
while (X11_Pending(data->display)) {
X11_DispatchEvent(_this);
}
/* FIXME: Only need to do this when there are pending focus changes */
X11_HandleFocusChanges(_this);
/*Dont process evtouch events if XInput2 multitouch is supported*/
if(X11_Xinput2IsMultitouchSupported()) {
return;
}
#ifdef SDL_INPUT_LINUXEV
/* Process Touch events*/
int i = 0,rd;
struct input_event ev[64];
int size = sizeof (struct input_event);
/* !!! FIXME: clean the tabstops out of here. */
for(i = 0;i < SDL_GetNumTouch();++i) {
SDL_Touch* touch = SDL_GetTouchIndex(i);
if(!touch) printf("Touch %i/%i DNE\n",i,SDL_GetNumTouch());
EventTouchData* data;
data = (EventTouchData*)(touch->driverdata);
if(data == NULL) {
printf("No driver data\n");
continue;
}
if(data->eventStream <= 0)
printf("Error: Couldn't open stream\n");
rd = read(data->eventStream, ev, size * 64);
if(rd >= size) {
for (i = 0; i < rd / sizeof(struct input_event); i++) {
switch (ev[i].type) {
case EV_ABS:
switch (ev[i].code) {
case ABS_X:
data->x = ev[i].value;
break;
case ABS_Y:
data->y = ev[i].value;
break;
case ABS_PRESSURE:
data->pressure = ev[i].value;
if(data->pressure < 0) data->pressure = 0;
break;
case ABS_MISC:
if(ev[i].value == 0)
data->up = SDL_TRUE;
break;
}
break;
case EV_MSC:
if(ev[i].code == MSC_SERIAL)
data->finger = ev[i].value;
break;
case EV_KEY:
if(ev[i].code == BTN_TOUCH)
if(ev[i].value == 0)
data->up = SDL_TRUE;
break;
case EV_SYN:
if(!data->down) {
data->down = SDL_TRUE;
SDL_SendFingerDown(touch->id,data->finger,
data->down, data->x, data->y,
data->pressure);
}
else if(!data->up)
SDL_SendTouchMotion(touch->id,data->finger,
SDL_FALSE, data->x,data->y,
data->pressure);
else
{
data->down = SDL_FALSE;
SDL_SendFingerDown(touch->id,data->finger,
data->down, data->x,data->y,
data->pressure);
data->x = -1;
data->y = -1;
data->pressure = -1;
data->finger = 0;
data->up = SDL_FALSE;
}
break;
}
}
}
}
#endif
}
//----------------------------------------------------------------------------------------------------------------------
// tool_replay_mode
//----------------------------------------------------------------------------------------------------------------------
static bool tool_replay_mode()
{
VOGL_FUNC_TRACER
dynamic_string trace_filename(g_command_line_params().get_value_as_string_or_empty("", 1));
if (trace_filename.is_empty())
{
vogl_error_printf("%s: No trace file specified!\n", VOGL_FUNCTION_INFO_CSTR);
return false;
}
dynamic_string actual_trace_filename;
vogl_unique_ptr<vogl_trace_file_reader> pTrace_reader(vogl_open_trace_file(
trace_filename,
actual_trace_filename,
g_command_line_params().get_value_as_string_or_empty("loose_file_path").get_ptr()));
if (!pTrace_reader.get())
{
vogl_error_printf("%s: File not found, or unable to determine file type of trace file \"%s\"\n", VOGL_FUNCTION_INFO_CSTR, trace_filename.get_ptr());
return false;
}
vogl_printf("Reading trace file %s\n", actual_trace_filename.get_ptr());
vogl_gl_replayer replayer;
vogl_replay_window window;
uint replayer_flags = get_replayer_flags_from_command_line_params();
// TODO: This will create a window with default attributes, which seems fine for the majority of traces.
// Unfortunately, some GL call streams *don't* want an alpha channel, or depth, or stencil etc. in the default framebuffer so this may become a problem.
// Also, this design only supports a single window, which is going to be a problem with multiple window traces.
if (!window.open(g_command_line_params().get_value_as_int("width", 0, 1024, 1, 65535), g_command_line_params().get_value_as_int("height", 0, 768, 1, 65535), g_command_line_params().get_value_as_int("msaa", 0, 0, 0, 65535)))
{
vogl_error_printf("%s: Failed initializing replay window\n", VOGL_FUNCTION_INFO_CSTR);
return false;
}
if (!replayer.init(replayer_flags, &window, pTrace_reader->get_sof_packet(), pTrace_reader->get_multi_blob_manager()))
{
vogl_error_printf("%s: Failed initializing GL replayer\n", VOGL_FUNCTION_INFO_CSTR);
return false;
}
// Disable all glGetError() calls in vogl_utils.cpp.
vogl_disable_gl_get_error();
XSelectInput(window.get_display(), window.get_xwindow(),
EnterWindowMask | LeaveWindowMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | ExposureMask | FocusChangeMask | KeyPressMask | KeyReleaseMask | PropertyChangeMask | StructureNotifyMask | KeymapStateMask);
Atom wmDeleteMessage = XInternAtom(window.get_display(), "WM_DELETE_WINDOW", False);
XSetWMProtocols(window.get_display(), window.get_xwindow(), &wmDeleteMessage, 1);
// Bool win_mapped = false;
vogl_gl_state_snapshot *pSnapshot = NULL;
int64_t snapshot_loop_start_frame = -1;
int64_t snapshot_loop_end_frame = -1;
vogl::hash_map<uint64_t> keys_pressed, keys_down;
int loop_frame = g_command_line_params().get_value_as_int("loop_frame", 0, -1);
int loop_len = math::maximum<int>(g_command_line_params().get_value_as_int("loop_len", 0, 1), 1);
int loop_count = math::maximum<int>(g_command_line_params().get_value_as_int("loop_count", 0, cINT32_MAX), 1);
bool endless_mode = g_command_line_params().get_value_as_bool("endless");
timer tm;
tm.start();
for (;;)
{
tmZone(TELEMETRY_LEVEL0, TMZF_NONE, "Main Loop");
while (X11_Pending(window.get_display()))
{
XEvent newEvent;
// Watch for new X eventsn
XNextEvent(window.get_display(), &newEvent);
switch (newEvent.type)
{
case KeyPress:
{
KeySym xsym = XLookupKeysym(&newEvent.xkey, 0);
//printf("KeyPress 0%04llX %" PRIu64 "\n", (uint64_t)xsym, (uint64_t)xsym);
keys_down.insert(xsym);
keys_pressed.insert(xsym);
break;
}
case KeyRelease:
{
KeySym xsym = XLookupKeysym(&newEvent.xkey, 0);
//printf("KeyRelease 0x%04llX %" PRIu64 "\n", (uint64_t)xsym, (uint64_t)xsym);
keys_down.erase(xsym);
break;
}
case FocusIn:
case FocusOut:
{
//printf("FocusIn/FocusOut\n");
keys_down.reset();
break;
}
case MappingNotify:
{
//XRefreshKeyboardMapping(&newEvent);
break;
}
case UnmapNotify:
{
// printf("UnmapNotify\n");
// win_mapped = false;
keys_down.reset();
break;
}
case MapNotify:
{
// printf("MapNotify\n");
// win_mapped = true;
keys_down.reset();
if (!replayer.update_window_dimensions())
goto error_exit;
break;
}
case ConfigureNotify:
{
if (!replayer.update_window_dimensions())
goto error_exit;
break;
}
case DestroyNotify:
{
vogl_message_printf("Exiting\n");
goto normal_exit;
}
case ClientMessage:
{
if (newEvent.xclient.data.l[0] == (int)wmDeleteMessage)
{
vogl_message_printf("Exiting\n");
goto normal_exit;
}
break;
}
default:
break;
}
}
if (replayer.get_at_frame_boundary())
{
if ((!pSnapshot) && (loop_frame != -1) && (static_cast<int64_t>(replayer.get_frame_index()) == loop_frame))
{
vogl_debug_printf("%s: Capturing replayer state at start of frame %u\n", VOGL_FUNCTION_INFO_CSTR, replayer.get_frame_index());
pSnapshot = replayer.snapshot_state();
if (pSnapshot)
{
vogl_printf("Snapshot succeeded\n");
snapshot_loop_start_frame = pTrace_reader->get_cur_frame();
snapshot_loop_end_frame = pTrace_reader->get_cur_frame() + loop_len;
vogl_debug_printf("%s: Loop start: %" PRIi64 " Loop end: %" PRIi64 "\n", VOGL_FUNCTION_INFO_CSTR, snapshot_loop_start_frame, snapshot_loop_end_frame);
}
else
{
vogl_error_printf("Snapshot failed!\n");
loop_frame = -1;
}
}
}
vogl_gl_replayer::status_t status = replayer.process_pending_window_resize();
if (status == vogl_gl_replayer::cStatusOK)
{
for (;;)
{
status = replayer.process_next_packet(*pTrace_reader);
if ((status == vogl_gl_replayer::cStatusNextFrame) ||
(status == vogl_gl_replayer::cStatusResizeWindow) ||
(status == vogl_gl_replayer::cStatusAtEOF) ||
(status == vogl_gl_replayer::cStatusHardFailure))
{
break;
}
}
}
if (status == vogl_gl_replayer::cStatusHardFailure)
break;
if (status == vogl_gl_replayer::cStatusAtEOF)
{
vogl_message_printf("%s: At trace EOF, frame index %u\n", VOGL_FUNCTION_INFO_CSTR, replayer.get_frame_index());
}
if (replayer.get_at_frame_boundary() &&
pSnapshot &&
(loop_count > 0) &&
((pTrace_reader->get_cur_frame() == snapshot_loop_end_frame) || (status == vogl_gl_replayer::cStatusAtEOF)))
{
status = replayer.begin_applying_snapshot(pSnapshot, false);
if ((status != vogl_gl_replayer::cStatusOK) && (status != vogl_gl_replayer::cStatusResizeWindow))
goto error_exit;
pTrace_reader->seek_to_frame(static_cast<uint>(snapshot_loop_start_frame));
vogl_debug_printf("%s: Applying snapshot and seeking back to frame %" PRIi64 "\n", VOGL_FUNCTION_INFO_CSTR, snapshot_loop_start_frame);
loop_count--;
}
else
{
bool print_progress = (status == vogl_gl_replayer::cStatusAtEOF) ||
((replayer.get_at_frame_boundary()) && ((replayer.get_frame_index() % 100) == 0));
if (print_progress)
{
if (pTrace_reader->get_type() == cBINARY_TRACE_FILE_READER)
{
vogl_binary_trace_file_reader &binary_trace_reader = *static_cast<vogl_binary_trace_file_reader *>(pTrace_reader.get());
vogl_printf("Replay now at frame index %u, trace file offet %" PRIu64 ", GL call counter %" PRIu64 ", %3.2f%% percent complete\n",
replayer.get_frame_index(),
binary_trace_reader.get_cur_file_ofs(),
replayer.get_last_parsed_call_counter(),
binary_trace_reader.get_trace_file_size() ? (binary_trace_reader.get_cur_file_ofs() * 100.0f) / binary_trace_reader.get_trace_file_size() : 0);
}
}
if (status == vogl_gl_replayer::cStatusAtEOF)
{
if (!endless_mode)
{
double time_since_start = tm.get_elapsed_secs();
vogl_printf("%u total swaps, %.3f secs, %3.3f avg fps\n", replayer.get_total_swaps(), time_since_start, replayer.get_frame_index() / time_since_start);
break;
}
vogl_printf("Resetting state and rewinding back to frame 0\n");
replayer.reset_state();
if (!pTrace_reader->seek_to_frame(0))
{
vogl_error_printf("%s: Failed rewinding trace reader!\n", VOGL_FUNCTION_INFO_CSTR);
goto error_exit;
}
}
}
telemetry_tick();
}
normal_exit:
return true;
error_exit:
return false;
}
