static void
_cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
const int *rectangles,
int n_rectangles)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
FrameCallbackData *frame_callback_data = g_slice_new (FrameCallbackData);
flush_pending_resize (onscreen);
/* Before calling the winsys function,
* cogl_onscreen_swap_buffers_with_damage() will have pushed the
* frame info object onto the end of the pending frames. We can grab
* it out of the queue now because we don't care about the order and
* we will just directly queue the event corresponding to the exact
* frame that Wayland reports as completed. This will steal the
* reference */
frame_callback_data->frame_info =
g_queue_pop_tail (&onscreen->pending_frame_infos);
frame_callback_data->onscreen = onscreen;
frame_callback_data->callback =
wl_surface_frame (wayland_onscreen->wayland_surface);
wl_callback_add_listener (frame_callback_data->callback,
&frame_listener,
frame_callback_data);
_cogl_list_insert (&wayland_onscreen->frame_callbacks,
&frame_callback_data->link);
parent_vtable->onscreen_swap_buffers_with_damage (onscreen,
rectangles,
n_rectangles);
}
static void
locked_pointer_frame_callback(void *data,
struct wl_callback *callback,
uint32_t time)
{
struct resizor *resizor = data;
struct wl_surface *surface;
struct rectangle allocation;
float x, y;
if (resizor->pointer_locked) {
widget_get_allocation(resizor->widget, &allocation);
x = resizor->pointer_x + (allocation.width - allocation.x);
y = resizor->pointer_y + (allocation.height - allocation.y);
widget_set_locked_pointer_cursor_hint(resizor->widget, x, y);
}
wl_callback_destroy(callback);
surface = window_get_wl_surface(resizor->window);
callback = wl_surface_frame(surface);
wl_callback_add_listener(callback,
&locked_pointer_frame_listener,
resizor);
}
static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
struct window *window = data;
struct buffer *buffer;
buffer = window_next_buffer(window);
if (!buffer) {
fprintf(stderr,
!callback ? "Failed to create the first buffer.\n" :
"Both buffers busy at redraw(). Server bug?\n");
abort();
}
paint_pixels(buffer->shm_data, 20, window->width, window->height, time);
wl_surface_attach(window->surface, buffer->buffer, 0, 0);
wl_surface_damage(window->surface,
20, 20, window->width - 40, window->height - 40);
if (callback)
wl_callback_destroy(callback);
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &frame_listener, window);
wl_surface_commit(window->surface);
buffer->busy = 1;
}
static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
struct window *window = data;
struct buffer *buffer;
buffer = window_next_buffer(window);
if (!buffer) {
fprintf(stderr,
!callback ? "Failed to create the first buffer.\n" :
"Both buffers busy at redraw(). Server bug?\n");
abort();
}
/* XXX: would be nice to draw something that changes here... */
wl_surface_attach(window->surface, buffer->buffer, 0, 0);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
if (callback)
wl_callback_destroy(callback);
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &frame_listener, window);
wl_surface_commit(window->surface);
buffer->busy = 1;
}
static void
triangle_frame_callback(void *data, struct wl_callback *callback,
uint32_t time)
{
struct triangle *tri = data;
DBG("%stime %u\n", callback ? "" : "artificial ", time);
assert(callback == tri->frame_cb);
tri->time = time;
if (callback)
wl_callback_destroy(callback);
eglMakeCurrent(tri->egl->dpy, tri->egl_surface,
tri->egl_surface, tri->egl->ctx);
glViewport(0, 0, tri->width, tri->height);
triangle_draw(&tri->gl, tri->time);
tri->frame_cb = wl_surface_frame(tri->wl_surface);
wl_callback_add_listener(tri->frame_cb, &triangle_frame_listener, tri);
eglSwapBuffers(tri->egl->dpy, tri->egl_surface);
}
static void
frame_callback(void *data, struct wl_callback *callback, uint32_t time)
{
struct resizor *resizor = data;
assert(!callback || callback == resizor->frame_callback);
if (resizor->frame_callback) {
wl_callback_destroy(resizor->frame_callback);
resizor->frame_callback = NULL;
}
if (window_is_maximized(resizor->window))
return;
spring_update(&resizor->width);
spring_update(&resizor->height);
widget_schedule_resize(resizor->widget,
resizor->width.current + 0.5,
resizor->height.current + 0.5);
if (!spring_done(&resizor->width) || !spring_done(&resizor->height)) {
resizor->frame_callback =
wl_surface_frame(
window_get_wl_surface(resizor->window));
wl_callback_add_listener(resizor->frame_callback, &listener,
resizor);
}
}
/* must be called with the render lock */
static void
render_last_buffer (GstWaylandSink * sink)
{
GstWlMeta *meta;
struct wl_surface *surface;
struct wl_callback *callback;
meta = gst_buffer_get_wl_meta (sink->last_buffer);
surface = gst_wl_window_get_wl_surface (sink->window);
g_atomic_int_set (&sink->redraw_pending, TRUE);
callback = wl_surface_frame (surface);
wl_callback_add_listener (callback, &frame_callback_listener, sink);
/* Here we essentially add a reference to the buffer. This represents
* the fact that the compositor is using the buffer and it should
* not return back to the pool and be reused until the compositor
* releases it. The release is handled internally in the pool */
gst_wayland_compositor_acquire_buffer (meta->pool, sink->last_buffer);
wl_surface_attach (surface, meta->wbuffer, 0, 0);
wl_surface_damage (surface, 0, 0, sink->window->surface_width,
sink->window->surface_height);
wl_surface_commit (surface);
wl_display_flush (sink->display->display);
}
void QWaylandShmBackingStore::done(void *data, wl_callback *callback, uint32_t time)
{
Q_UNUSED(time);
QWaylandShmBackingStore *self =
static_cast<QWaylandShmBackingStore *>(data);
if (callback != self->mFrameCallback) // others, like QWaylandWindow, may trigger callbacks too
return;
QWaylandShmWindow *window = self->waylandWindow();
wl_callback_destroy(self->mFrameCallback);
self->mFrameCallback = 0;
if (self->mFrontBuffer != window->attached()) {
delete window->attached();
}
if (window->attached() != self->mFrontBuffer)
window->attachOffset(self->mFrontBuffer);
if (self->mFrontBufferIsDirty && !self->mPainting) {
self->mFrontBufferIsDirty = false;
self->mFrameCallback = wl_surface_frame(window->wl_surface());
wl_callback_add_listener(self->mFrameCallback,&self->frameCallbackListener,self);
window->damage(QRect(QPoint(0,0),self->mFrontBuffer->size()));
}
}
static void wl_callback_done(void* data, struct wl_callback* callback, uint32_t time)
{
wlfWindow* window = data;
wlfBuffer* buffer;
struct wl_shm_pool* shm_pool;
void* shm_data;
void* free_data;
int fd;
int fdt;
if (!window->buffers[0].busy)
buffer = &window->buffers[0];
else if (!window->buffers[1].busy)
buffer = &window->buffers[1];
else
return;
if (!buffer->buffer) {
fd = shm_open("/wlfreerdp_shm", O_CREAT | O_RDWR, 0666);
fdt = ftruncate(fd, window->width * window->height * 4);
if (fdt != 0)
{
WLog_ERR(TAG, "window_redraw: could not allocate memory");
close(fd);
return;
}
shm_data = mmap(NULL, window->width * window->height * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (shm_data == MAP_FAILED)
{
WLog_ERR(TAG, "window_redraw: failed to memory map buffer");
close(fd);
return;
}
shm_pool = wl_shm_create_pool(window->display->shm, fd, window->width * window->height * 4);
buffer->buffer = wl_shm_pool_create_buffer(shm_pool, 0, window->width, window->height, window->width* 4, WL_SHM_FORMAT_XRGB8888);
wl_buffer_add_listener(buffer->buffer, &wl_buffer_listener, buffer);
wl_shm_pool_destroy(shm_pool);
shm_unlink("/wlfreerdp_shm");
close(fd);
free_data = buffer->shm_data;
buffer->shm_data = shm_data;
munmap(free_data, window->width * window->height * 4);
}
/* this is the real surface data */
memcpy(buffer->shm_data, (void*) window->data, window->width * window->height * 4);
wl_surface_attach(window->surface, buffer->buffer, 0, 0);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
if (callback) wl_callback_destroy(callback);
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &wl_callback_listener, window);
wl_surface_commit(window->surface);
buffer->busy = TRUE;
}
void WaylandNativeWindow::finishSwap()
{
int ret = 0;
lock();
WaylandNativeWindowBuffer *wnb = queue.front();
if (!wnb) {
wnb = m_lastBuffer;
} else {
queue.pop_front();
}
assert(wnb);
m_lastBuffer = wnb;
wnb->busy = 1;
ret = readQueue(false);
if (this->frame_callback) {
do {
ret = readQueue(true);
} while (this->frame_callback && ret != -1);
}
if (ret < 0) {
HYBRIS_TRACE_END("wayland-platform", "queueBuffer_wait_for_frame_callback", "-%p", wnb);
return;
}
if (wnb->wlbuffer == NULL)
{
wnb->wlbuffer_from_native_handle(m_android_wlegl, m_display, wl_queue);
TRACE("%p add listener with %p inside", wnb, wnb->wlbuffer);
wl_buffer_add_listener(wnb->wlbuffer, &wl_buffer_listener, this);
wl_proxy_set_queue((struct wl_proxy *) wnb->wlbuffer, this->wl_queue);
}
if (m_swap_interval > 0) {
this->frame_callback = wl_surface_frame(m_window->surface);
wl_callback_add_listener(this->frame_callback, &frame_listener, this);
wl_proxy_set_queue((struct wl_proxy *) this->frame_callback, this->wl_queue);
}
wl_surface_attach(m_window->surface, wnb->wlbuffer, 0, 0);
wl_surface_damage(m_window->surface, 0, 0, wnb->width, wnb->height);
wl_surface_commit(m_window->surface);
// Some compositors, namely Weston, queue buffer release events instead
// of sending them immediately. If a frame event is used, this should
// not be a problem. Without a frame event, we need to send a sync
// request to ensure that they get flushed.
wl_callback_destroy(wl_display_sync(m_display));
wl_display_flush(m_display);
fronted.push_back(wnb);
m_window->attached_width = wnb->width;
m_window->attached_height = wnb->height;
m_damage_rects = NULL;
m_damage_n_rects = 0;
unlock();
}
static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
struct window *window = data;
static const GLfloat verts[3][2] = {
{ -0.5, -0.5 },
{ 0.5, -0.5 },
{ 0, 0.5 }
};
static const GLfloat colors[3][3] = {
{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }
};
GLfloat angle;
GLfloat rotation[4][4] = {
{ 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 }
};
static const int32_t speed_div = 5;
static uint32_t start_time = 0;
if (start_time == 0)
start_time = time;
angle = ((time-start_time) / speed_div) % 360 * M_PI / 180.0;
rotation[0][0] = cos(angle);
rotation[0][2] = sin(angle);
rotation[2][0] = -sin(angle);
rotation[2][2] = cos(angle);
glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,
(GLfloat *) rotation);
glClearColor(0.0, 0.0, 0.0, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);
glEnableVertexAttribArray(window->gl.pos);
glEnableVertexAttribArray(window->gl.col);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray(window->gl.pos);
glDisableVertexAttribArray(window->gl.col);
glFlush();
eglSwapBuffers(window->display->egl.dpy, window->egl_surface);
if (callback)
wl_callback_destroy(callback);
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &frame_listener, window);
}
int window_render(struct window *window) {
window->frame_cb = wl_surface_frame(window->surface);
wl_callback_add_listener(window->frame_cb, &listener, window);
wl_surface_damage(window->surface, 0, 0, window->buffer->width, window->buffer->height);
wl_surface_attach(window->surface, window->buffer->buffer, 0, 0);
wl_surface_commit(window->surface);
return 1;
}
int WaylandNativeWindow::queueBuffer(BaseNativeWindowBuffer* buffer, int fenceFd){
WaylandNativeWindowBuffer *backbuf = (WaylandNativeWindowBuffer *) buffer;
int ret = 0;
lock();
backbuf->busy = 2;
unlock();
while (this->frame_callback && ret != -1)
ret = wl_display_dispatch_queue(m_display, this->wl_queue);
if (ret < 0)
return ret;
lock();
this->frame_callback = wl_surface_frame(m_window->surface);
wl_callback_add_listener(this->frame_callback, &frame_listener, this);
wl_proxy_set_queue((struct wl_proxy *) this->frame_callback, this->wl_queue);
if (backbuf->wlbuffer == NULL)
{
struct wl_array ints;
int *ints_data;
struct android_wlegl_handle *wlegl_handle;
buffer_handle_t handle;
handle = backbuf->handle;
wl_array_init(&ints);
ints_data = (int*) wl_array_add(&ints, handle->numInts*sizeof(int));
memcpy(ints_data, handle->data + handle->numFds, handle->numInts*sizeof(int));
wlegl_handle = android_wlegl_create_handle(m_android_wlegl, handle->numFds, &ints);
wl_array_release(&ints);
for (int i = 0; i < handle->numFds; i++) {
android_wlegl_handle_add_fd(wlegl_handle, handle->data[i]);
}
backbuf->wlbuffer = android_wlegl_create_buffer(m_android_wlegl,
backbuf->width, backbuf->height, backbuf->stride,
backbuf->format, backbuf->usage, wlegl_handle);
android_wlegl_handle_destroy(wlegl_handle);
backbuf->common.incRef(&backbuf->common);
TRACE("Add listener for %p with %p inside", backbuf, backbuf->wlbuffer);
wl_buffer_add_listener(backbuf->wlbuffer, &wl_buffer_listener, this);
wl_proxy_set_queue((struct wl_proxy *) backbuf->wlbuffer,
this->wl_queue);
}
wl_surface_attach(m_window->surface, backbuf->wlbuffer, 0, 0);
wl_surface_damage(m_window->surface, 0, 0, backbuf->width, backbuf->height);
wl_surface_commit(m_window->surface);
fronted.push_back(backbuf);
unlock();
return NO_ERROR;
}
struct wl_callback *
frame_callback_set(struct wl_surface *surface, int *done)
{
struct wl_callback *callback;
*done = 0;
callback = wl_surface_frame(surface);
wl_callback_add_listener(callback, &frame_listener, done);
return callback;
}
static void
_eventd_nd_cursor_frame_callback(void *data, struct wl_callback *callback, uint32_t time)
{
EventdNdBackendContext *self = data;
int i;
if ( self->cursor.frame_cb != NULL )
wl_callback_destroy(self->cursor.frame_cb);
self->cursor.frame_cb = wl_surface_frame(self->cursor.surface);
wl_callback_add_listener(self->cursor.frame_cb, &_eventd_nd_cursor_frame_wl_callback_listener, self);
i = wl_cursor_frame(self->cursor.cursor, time);
_eventd_nd_cursor_set_image(self, i);
}
void QWaylandWindow::damage(const QRect &rect)
{
//We have to do sync stuff before calling damage, or we might
//get a frame callback before we get the timestamp
if (!mWaitingForFrameSync) {
mFrameCallback = wl_surface_frame(mSurface);
wl_callback_add_listener(mFrameCallback,&QWaylandWindow::callbackListener,this);
mWaitingForFrameSync = true;
}
wl_surface_damage(mSurface,
rect.x(), rect.y(), rect.width(), rect.height());
wl_surface_commit(mSurface);
}
static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
struct window *window = data;
paint_pixels(window->shm_data, window->width, window->height, time);
wl_surface_attach(window->surface, window->buffer, 0, 0);
wl_surface_damage(window->surface,
0, 0, window->width, window->height);
if (callback)
wl_callback_destroy(callback);
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &frame_listener, window);
}
void XdevLWindowWayland::onPaint() {
wl_callback_destroy(m_frameCallback);
XdevLWindowPosition position = getPosition();
XdevLWindowSize size = getSize();
wl_surface_damage(m_surface, position.x, position.y, size.width, size.height);
paint_pixels();
m_frameCallback = wl_surface_frame(m_surface);
wl_surface_attach(m_surface, m_buffer, 0, 0);
wl_callback_add_listener(m_frameCallback, &frame_listener, this);
wl_surface_commit(m_surface);
}
static void
frame_callback(void *data, struct wl_callback *callback, uint32_t time)
{
// printf ("client: frame_callback start\n");
struct nested_client *client = data;
if (callback)
wl_callback_destroy(callback);
callback = wl_surface_frame(client->surface);
wl_callback_add_listener(callback, &frame_listener, client);
render_triangle(client, time);
eglSwapBuffers(client->egl_display, client->egl_surface);
// printf ("client: frame_callback end\n");
}
static boolean
wayland_surface_swap_buffers(struct native_surface *nsurf)
{
struct wayland_surface *surface = wayland_surface(nsurf);
struct wayland_display *display = surface->display;
int ret = 0;
while (surface->frame_callback && ret != -1)
ret = wl_display_dispatch_queue(display->dpy, display->queue);
if (ret == -1)
return EGL_FALSE;
surface->frame_callback = wl_surface_frame(surface->win->surface);
wl_callback_add_listener(surface->frame_callback, &frame_listener, surface);
wl_proxy_set_queue((struct wl_proxy *) surface->frame_callback,
display->queue);
if (surface->type == WL_WINDOW_SURFACE) {
resource_surface_swap_buffers(surface->rsurf,
NATIVE_ATTACHMENT_FRONT_LEFT,
NATIVE_ATTACHMENT_BACK_LEFT, FALSE);
wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK);
if (surface->buffer[WL_BUFFER_FRONT] == NULL)
surface->buffer[WL_BUFFER_FRONT] =
display->create_buffer(display, surface,
NATIVE_ATTACHMENT_FRONT_LEFT);
wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT],
surface->dx, surface->dy);
resource_surface_get_size(surface->rsurf,
(uint *) &surface->win->attached_width,
(uint *) &surface->win->attached_height);
surface->dx = 0;
surface->dy = 0;
}
surface->sequence_number++;
wayland_event_handler->invalid_surface(&display->base,
&surface->base,
surface->sequence_number);
return TRUE;
}
static void
wayland_output_repaint(struct weston_output *output_base,
pixman_region32_t *damage)
{
struct wayland_output *output = (struct wayland_output *) output_base;
struct weston_compositor *ec = output->base.compositor;
struct wl_callback *callback;
callback = wl_surface_frame(output->parent.surface);
wl_callback_add_listener(callback, &frame_listener, output);
ec->renderer->repaint_output(&output->base, damage);
pixman_region32_subtract(&ec->primary_plane.damage,
&ec->primary_plane.damage, damage);
}
static void
button_handler(struct widget *widget,
struct input *input, uint32_t time,
uint32_t button, enum wl_pointer_button_state state, void *data)
{
struct resizor *resizor = data;
struct rectangle allocation;
struct wl_surface *surface;
struct wl_callback *callback;
if (button == BTN_RIGHT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
show_menu(resizor, input, time);
} else if (button == BTN_LEFT &&
state == WL_POINTER_BUTTON_STATE_PRESSED) {
window_get_allocation(resizor->window, &allocation);
resizor->width.current = allocation.width;
resizor->width.previous = allocation.width;
resizor->width.target = allocation.width;
resizor->height.current = allocation.height;
resizor->height.previous = allocation.height;
resizor->height.target = allocation.height;
window_lock_pointer(resizor->window, input);
window_set_pointer_locked_handler(resizor->window,
handle_pointer_locked,
handle_pointer_unlocked);
resizor->locked_input = input;
if (resizor->locked_frame_callback_registered)
return;
surface = window_get_wl_surface(resizor->window);
callback = wl_surface_frame(surface);
wl_callback_add_listener(callback,
&locked_pointer_frame_listener,
resizor);
resizor->locked_frame_callback_registered = true;
} else if (button == BTN_LEFT &&
state == WL_POINTER_BUTTON_STATE_RELEASED) {
input_set_pointer_image(input, CURSOR_LEFT_PTR);
window_unlock_pointer(resizor->window);
}
}
static struct cursor_surface *
cursor_viewer_show_cursor(struct cursor_viewer *viewer, const char *name)
{
struct wl_cursor_image *cursor_image;
struct wl_buffer *cursor_buffer = NULL;
struct cursor_surface *cursor = calloc(1, sizeof (struct cursor_surface));
if (!cursor)
die("Cannot allocate memory for cursor_surface\n");
cursor->name = name;
cursor->surface = wl_compositor_create_surface(viewer->compositor);
cursor->shsurf = wl_shell_get_shell_surface(viewer->shell, cursor->surface);
wl_shell_surface_add_listener(cursor->shsurf, &shsurf_listener, viewer);
wl_shell_surface_set_toplevel(cursor->shsurf);
wl_shell_surface_set_title(cursor->shsurf, name);
wl_surface_set_user_data(cursor->surface, viewer);
cursor->cursor = wl_cursor_theme_get_cursor(viewer->cursor_theme, name);
if (!cursor->cursor || cursor->cursor->image_count < 1) {
printf("No such cursor: %s\n", name);
cursor_surface_destroy(cursor);
return NULL;
}
cursor_image = cursor->cursor->images[0];
cursor_buffer = wl_cursor_image_get_buffer(cursor_image);
printf("%s: %s: size=%dx%d image_count=%u\n",
__func__, cursor->name,
cursor_image->width, cursor_image->height,
cursor->cursor->image_count);
if (cursor->cursor->image_count > 1) {
cursor->frame = wl_surface_frame(cursor->surface);
wl_callback_add_listener(cursor->frame, &frame_listener, cursor);
}
wl_surface_attach(cursor->surface, cursor_buffer, 0, 0);
wl_surface_damage(cursor->surface, 0, 0, cursor_image->width, cursor_image->height);
wl_surface_commit(cursor->surface);
return cursor;
}
void EglWaylandBackend::present()
{
// need to dispatch pending events as eglSwapBuffers can block
m_wayland->dispatchEvents();
m_lastFrameRendered = false;
wl_callback *callback = wl_surface_frame(m_wayland->surface());
wl_callback_add_listener(callback, &s_surfaceFrameListener, this);
if (supportsBufferAge()) {
eglSwapBuffers(m_display, m_surface);
eglQuerySurface(m_display, m_surface, EGL_BUFFER_AGE_EXT, &m_bufferAge);
setLastDamage(QRegion());
return;
} else {
eglSwapBuffers(m_display, m_surface);
setLastDamage(QRegion());
}
}
static boolean
wayland_surface_swap_buffers(struct native_surface *nsurf)
{
struct wayland_surface *surface = wayland_surface(nsurf);
struct wayland_display *display = surface->display;
struct wl_callback *callback;
while (surface->block_swap_buffers)
wl_display_iterate(display->dpy, WL_DISPLAY_READABLE);
surface->block_swap_buffers = TRUE;
callback = wl_surface_frame(surface->win->surface);
wl_callback_add_listener(callback, &frame_listener, surface);
if (surface->type == WL_WINDOW_SURFACE) {
resource_surface_swap_buffers(surface->rsurf,
NATIVE_ATTACHMENT_FRONT_LEFT,
NATIVE_ATTACHMENT_BACK_LEFT, FALSE);
wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK);
if (surface->buffer[WL_BUFFER_FRONT] == NULL)
surface->buffer[WL_BUFFER_FRONT] =
display->create_buffer(display, surface,
NATIVE_ATTACHMENT_FRONT_LEFT);
wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT],
surface->dx, surface->dy);
resource_surface_get_size(surface->rsurf,
(uint *) &surface->win->attached_width,
(uint *) &surface->win->attached_height);
surface->dx = 0;
surface->dy = 0;
}
surface->sequence_number++;
wayland_event_handler->invalid_surface(&display->base,
&surface->base,
surface->sequence_number);
return TRUE;
}
static void
redraw_handler(struct widget *widget, void *data)
{
struct ModeInfo *mi = data;
struct wscreensaver *wscr = mi->priv;
struct rectangle drawarea;
struct rectangle winarea;
struct wl_callback *callback;
int bottom;
mi->swap_buffers = 0;
widget_get_allocation(mi->widget, &drawarea);
window_get_allocation(mi->window, &winarea);
if (display_acquire_window_surface(wscr->display,
mi->window,
mi->eglctx) < 0) {
fprintf(stderr, "%s: unable to acquire window surface",
progname);
return;
}
bottom = winarea.height - (drawarea.height + drawarea.y);
glViewport(drawarea.x, bottom, drawarea.width, drawarea.height);
glScissor(drawarea.x, bottom, drawarea.width, drawarea.height);
glEnable(GL_SCISSOR_TEST);
if (mi->width != drawarea.width || mi->height != drawarea.height) {
mi->width = drawarea.width;
mi->height = drawarea.height;
wscr->plugin->reshape(mi, mi->width, mi->height);
}
wscr->plugin->draw(mi);
if (mi->swap_buffers == 0)
fprintf(stderr, "%s: swapBuffers not called\n", progname);
display_release_window_surface(wscr->display, mi->window);
callback = wl_surface_frame(window_get_wl_surface(mi->window));
wl_callback_add_listener(callback, &listener, mi);
}
static void drawImage(void)
{
memcpy(g_wlContextStruct.data,
g_wlContextStruct.ctx_bmp->data,
g_wlContextStruct.ctx_bmp->stride * g_wlContextStruct.ctx_bmp->height);
wl_surface_attach(g_wlContextStruct.wlSurface,
g_wlContextStruct.wlBuffer,
0, 0);
wl_surface_damage(g_wlContextStruct.wlSurface,
0, 0,
g_wlContextStruct.ctx_bmp->width,
g_wlContextStruct.ctx_bmp->height);
struct wl_callback* callback = wl_surface_frame(g_wlContextStruct.wlSurface);
wl_callback_add_listener(callback, &frame_listener, NULL);
wl_surface_commit(g_wlContextStruct.wlSurface);
//wl_display_flush(g_wlContextStruct.wlDisplay);
wl_display_roundtrip(g_wlContextStruct.wlDisplay);
}
static void
surface_frame_done(void *data, struct wl_callback *wl_callback, uint32_t time)
{
struct wl_cursor_image *cursor_image;
struct wl_buffer *cursor_buffer = NULL;
struct cursor_surface *cursor = (struct cursor_surface *)data;
int image_index = wl_cursor_frame(cursor->cursor, time);
cursor_image = cursor->cursor->images[image_index];
cursor_buffer = wl_cursor_image_get_buffer(cursor_image);
if (cursor->frame)
wl_callback_destroy(cursor->frame);
cursor->frame = wl_surface_frame(cursor->surface);
wl_callback_add_listener(cursor->frame, &frame_listener, cursor);
wl_surface_attach(cursor->surface, cursor_buffer, 0, 0);
wl_surface_damage(cursor->surface, 0, 0, cursor_image->width, cursor_image->height);
wl_surface_commit(cursor->surface);
}
void
WindowEGLImpl::OnRedraw(struct wl_callback* callback, uint32_t time)
{
assert(m_callback == callback);
m_callback = NULL;
if (callback)
wl_callback_destroy(callback);
glViewport(0, 0, m_window->GetWidth(), m_window->GetHeight());
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
m_window->Render();
m_callback = wl_surface_frame(m_window->GetWlSurface());
wl_callback_add_listener(m_callback, &frameListener, this);
eglSwapBuffers(m_egl.dpy, m_eglSurface);
}
/* must be called with the render lock */
static void
render_last_buffer (GstWaylandSink * sink)
{
GstWlBuffer *wlbuffer;
const GstVideoInfo *info = NULL;
struct wl_surface *surface;
struct wl_callback *callback;
wlbuffer = gst_buffer_get_wl_buffer (sink->last_buffer);
surface = gst_wl_window_get_wl_surface (sink->window);
g_atomic_int_set (&sink->redraw_pending, TRUE);
callback = wl_surface_frame (surface);
wl_callback_add_listener (callback, &frame_callback_listener, sink);
if (G_UNLIKELY (sink->video_info_changed)) {
info = &sink->video_info;
sink->video_info_changed = FALSE;
}
gst_wl_window_render (sink->window, wlbuffer, info);
}