static void
leak_closure(void)
{
struct wl_callback *cb;
struct pollfd pfd;
struct client *c = client_connect();
cb = wl_display_sync(c->wl_display);
assert(cb);
assert(wl_display_flush(c->wl_display) > 0);
/* we don't need it, it is referenced */
wl_callback_destroy(cb);
pfd.fd = wl_display_get_fd(c->wl_display);
pfd.events = POLLIN;
test_set_timeout(2);
assert(poll(&pfd, 1, -1) == 1);
/* read events, but do not dispatch them */
assert(wl_display_prepare_read(c->wl_display) == 0);
assert(wl_display_read_events(c->wl_display) == 0);
/*
* now we have wl_callback.done and wl_display.delete_id queued;
* if we now release the queue (in wl_display_disconnect())
* we should not leak memory
*/
client_disconnect(c);
}
/** Background thread for Wayland shell events handling */
static void *Thread(void *data)
{
vout_window_t *wnd = data;
struct wl_display *display = wnd->display.wl;
struct pollfd ufd[1];
int canc = vlc_savecancel();
vlc_cleanup_push(cleanup_wl_display_read, display);
ufd[0].fd = wl_display_get_fd(display);
ufd[0].events = POLLIN;
for (;;)
{
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
vlc_restorecancel(canc);
while (poll(ufd, 1, -1) < 0);
canc = vlc_savecancel();
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
vlc_assert_unreachable();
vlc_cleanup_pop();
//vlc_restorecancel(canc);
//return NULL;
}
static gpointer
gst_wl_display_thread_run (gpointer data)
{
GstWlDisplay *self = data;
GstPollFD pollfd = GST_POLL_FD_INIT;
pollfd.fd = wl_display_get_fd (self->display);
gst_poll_add_fd (self->wl_fd_poll, &pollfd);
gst_poll_fd_ctl_read (self->wl_fd_poll, &pollfd, TRUE);
/* main loop */
while (1) {
while (wl_display_prepare_read_queue (self->display, self->queue) != 0)
wl_display_dispatch_queue_pending (self->display, self->queue);
wl_display_flush (self->display);
if (gst_poll_wait (self->wl_fd_poll, GST_CLOCK_TIME_NONE) < 0) {
gboolean normal = (errno == EBUSY);
wl_display_cancel_read (self->display);
if (normal)
break;
else
goto error;
} else {
wl_display_read_events (self->display);
wl_display_dispatch_queue_pending (self->display, self->queue);
}
}
return NULL;
error:
GST_ERROR ("Error communicating with the wayland server");
return NULL;
}
xdl_int XdevLWindowEventServerWayland::update() {
while(wl_display_prepare_read(display) < 0) {
wl_display_dispatch_pending(display);
}
wl_display_flush(display);
wl_display_read_events(display);
return ERR_OK;
}
static gboolean
gst_vaapi_window_wayland_sync (GstVaapiWindow * window)
{
GstVaapiWindowWaylandPrivate *const priv =
GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window);
struct wl_display *const wl_display =
GST_VAAPI_OBJECT_NATIVE_DISPLAY (window);
if (priv->sync_failed)
return FALSE;
if (priv->pollfd.fd < 0) {
priv->pollfd.fd = wl_display_get_fd (wl_display);
gst_poll_add_fd (priv->poll, &priv->pollfd);
gst_poll_fd_ctl_read (priv->poll, &priv->pollfd, TRUE);
}
while (g_atomic_int_get (&priv->num_frames_pending) > 0) {
while (wl_display_prepare_read_queue (wl_display, priv->event_queue) < 0) {
if (wl_display_dispatch_queue_pending (wl_display, priv->event_queue) < 0)
goto error;
}
if (wl_display_flush (wl_display) < 0)
goto error;
again:
if (gst_poll_wait (priv->poll, GST_CLOCK_TIME_NONE) < 0) {
int saved_errno = errno;
if (saved_errno == EAGAIN || saved_errno == EINTR)
goto again;
if (saved_errno == EBUSY) { /* closing */
wl_display_cancel_read (wl_display);
return FALSE;
}
goto error;
}
if (wl_display_read_events (wl_display) < 0)
goto error;
if (wl_display_dispatch_queue_pending (wl_display, priv->event_queue) < 0)
goto error;
}
return TRUE;
/* ERRORS */
error:
{
priv->sync_failed = TRUE;
GST_ERROR ("Error on dispatching events: %s", g_strerror (errno));
return FALSE;
}
}
static gpointer
gst_mfx_window_wayland_thread_run (gpointer window)
{
GstMfxWindowWaylandPrivate *const priv =
GST_MFX_WINDOW_WAYLAND_GET_PRIVATE (window);
struct wl_display *const wl_display =
GST_MFX_DISPLAY_HANDLE (GST_MFX_WINDOW_DISPLAY (window));
if (priv->sync_failed)
return NULL;
if (priv->pollfd.fd < 0) {
priv->pollfd.fd = wl_display_get_fd (wl_display);
gst_poll_add_fd (priv->poll, &priv->pollfd);
gst_poll_fd_ctl_read (priv->poll, &priv->pollfd, TRUE);
}
while (1) {
while (wl_display_prepare_read_queue (wl_display, priv->event_queue) < 0) {
if (wl_display_dispatch_queue_pending (wl_display, priv->event_queue) < 0)
goto error;
}
if (wl_display_flush (wl_display) < 0)
goto error;
again:
if (gst_poll_wait (priv->poll, GST_CLOCK_TIME_NONE) < 0) {
int saved_errno = errno;
if (saved_errno == EAGAIN || saved_errno == EINTR)
goto again;
wl_display_cancel_read (wl_display);
if (saved_errno == EBUSY) /* flushing */
return NULL;
else
goto error;
}
if (wl_display_read_events (wl_display) < 0)
goto error;
if (wl_display_dispatch_queue_pending (wl_display, priv->event_queue) < 0)
goto error;
}
return NULL;
error:
priv->sync_failed = TRUE;
GST_ERROR ("Error on dispatching events: %s", g_strerror (errno));
return NULL;
}
static void *Thread(void *data)
{
demux_t *demux = data;
demux_sys_t *sys = demux->p_sys;
struct wl_display *display = sys->display;
struct pollfd ufd[1];
unsigned interval = lroundf(CLOCK_FREQ / (sys->rate * 1000.f));
int canc = vlc_savecancel();
vlc_cleanup_push(cleanup_wl_display_read, display);
ufd[0].fd = wl_display_get_fd(display);
ufd[0].events = POLLIN;
for (;;)
{
if (DisplayError(demux, display))
break;
if (sys->es != NULL)
{
block_t *block = Shoot(demux);
block->i_pts = block->i_dts = vlc_tick_now();
es_out_SetPCR(demux->out, block->i_pts);
es_out_Send(demux->out, sys->es, block);
}
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
vlc_restorecancel(canc);
while (poll(ufd, 1, interval) < 0);
canc = vlc_savecancel();
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
vlc_cleanup_pop();
vlc_restorecancel(canc);
return NULL;
}
void _glfwPlatformWaitEvents(void)
{
struct wl_display* display = _glfw.wl.display;
struct pollfd fds[] = {
{ wl_display_get_fd(display), POLLIN },
};
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
if (poll(fds, 1, -1) > 0)
{
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
else
{
wl_display_cancel_read(display);
}
}
void WaylandCore::pollEvents() {
if( mDisplay == NULL || mRegistry == NULL ) {
mShouldClose = true;
return;
}
pollfd fds[] = {
{ wl_display_get_fd(mDisplay), POLLIN },
};
while( wl_display_prepare_read(mDisplay) != 0 )
{
wl_display_dispatch_pending(mDisplay);
}
wl_display_flush(mDisplay);
if( poll(fds,1,0) > 0 )
{
wl_display_read_events(mDisplay);
wl_display_dispatch_pending(mDisplay);
} else {
wl_display_cancel_read(mDisplay);
}
}
static void
handleEvents(int timeout)
{
struct wl_display* display = _glfw.wl.display;
struct pollfd fds[] = {
{ wl_display_get_fd(display), POLLIN },
};
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
// If an error different from EAGAIN happens, we have likely been
// disconnected from the Wayland session, try to handle that the best we
// can.
if (wl_display_flush(display) < 0 && errno != EAGAIN)
{
_GLFWwindow* window = _glfw.windowListHead;
while (window)
{
_glfwInputWindowCloseRequest(window);
window = window->next;
}
wl_display_cancel_read(display);
return;
}
if (poll(fds, 1, timeout) > 0)
{
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
else
{
wl_display_cancel_read(display);
}
}
int ReadEvents(){
return wl_display_read_events(cobj);
}
