static void
create_opaque_region(int width, int height) {
region = wl_compositor_create_region(compositor);
wl_region_add(region, 0, 0,
width,
height);
wl_surface_set_opaque_region(surface, region);
}
void XdevLWindowWayland::onSizeChanged(xdl_int width, xdl_int height) {
XDEVL_MODULE_INFO("Size changed: (width, height): (" << width << ", " << height << ")\n");
XdevLWindowSize size(width, height);
setSize(size);
wl_egl_window_resize(m_egl.m_eglWindow, width, height, 0, 0);
wl_region *region = wl_compositor_create_region(m_compositor);
wl_region_add(region, 0, 0, width, height);
wl_surface_set_opaque_region(m_surface, region);
wl_region_destroy(region);
}
static void
gst_wl_window_set_opaque (GstWlWindow * window, const GstVideoInfo * info)
{
struct wl_region *region;
/* Set area opaque */
region = wl_compositor_create_region (window->display->compositor);
wl_region_add (region, 0, 0, window->render_rectangle.w,
window->render_rectangle.h);
wl_surface_set_opaque_region (window->area_surface, region);
wl_region_destroy (region);
if (!GST_VIDEO_INFO_HAS_ALPHA (info)) {
/* Set video opaque */
region = wl_compositor_create_region (window->display->compositor);
wl_region_add (region, 0, 0, window->render_rectangle.w,
window->render_rectangle.h);
wl_surface_set_opaque_region (window->video_surface, region);
wl_region_destroy (region);
}
}
// Makes the surface considered as XRGB instead of ARGB.
static void setOpaqueRegion(_GLFWwindow* window)
{
struct wl_region* region;
region = wl_compositor_create_region(_glfw.wl.compositor);
if (!region)
return;
wl_region_add(region, 0, 0, window->wl.width, window->wl.height);
wl_surface_set_opaque_region(window->wl.surface, region);
wl_surface_commit(window->wl.surface);
wl_region_destroy(region);
}
void cWaylandInterface::SwapBuffers()
{
struct wl_region *region;
region = wl_compositor_create_region(GLWin.wl_compositor);
wl_region_add(region, 0, 0,
GLWin.geometry.width,
GLWin.geometry.height);
wl_surface_set_opaque_region(GLWin.wl_surface, region);
wl_region_destroy(region);
eglSwapBuffers(GLWin.egl_dpy, GLWin.egl_surf);
}
void Wayland_SetWindowSize(_THIS, SDL_Window * window)
{
SDL_VideoData *data = _this->driverdata;
SDL_WindowData *wind = window->driverdata;
struct wl_region *region;
WAYLAND_wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
region =wl_compositor_create_region(data->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(wind->surface, region);
wl_region_destroy(region);
}
void XdevLWindowWayland::setSize(const XdevLWindowSize& size) {
XdevLWindowImpl::setSize(size);
wl_egl_window_resize(m_egl.m_eglWindow, size.width, size.height, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(m_egl.m_eglDisplay, m_egl.m_eglSurface);
wl_region* region = wl_compositor_create_region(m_compositor);
wl_region_add(region, 0, 0, size.width, size.height);
wl_surface_set_opaque_region(m_surface, region);
wl_region_destroy(region);
wl_surface_commit(m_surface);
}
UwacReturnCode UwacWindowSetOpaqueRegion(UwacWindow* window, uint32_t x, uint32_t y, uint32_t width,
uint32_t height)
{
assert(window);
if (window->opaque_region)
wl_region_destroy(window->opaque_region);
window->opaque_region = wl_compositor_create_region(window->display->compositor);
if (!window->opaque_region)
return UWAC_ERROR_NOMEMORY;
wl_region_add(window->opaque_region, x, y, width, height);
wl_surface_set_opaque_region(window->surface, window->opaque_region);
return UWAC_SUCCESS;
}
static void
handle_configure_wl_shell_surface(void *data, struct wl_shell_surface *shell_surface,
uint32_t edges, int32_t width, int32_t height)
{
SDL_WindowData *wind = (SDL_WindowData *)data;
SDL_Window *window = wind->sdlwindow;
struct wl_region *region;
/* wl_shell_surface spec states that this is a suggestion.
Ignore if less than or greater than max/min size. */
if (width == 0 || height == 0) {
return;
}
if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
if ((window->flags & SDL_WINDOW_RESIZABLE)) {
if (window->max_w > 0) {
width = SDL_min(width, window->max_w);
}
width = SDL_max(width, window->min_w);
if (window->max_h > 0) {
height = SDL_min(height, window->max_h);
}
height = SDL_max(height, window->min_h);
} else {
return;
}
}
if (width == window->w && height == window->h) {
return;
}
window->w = width;
window->h = height;
WAYLAND_wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
region = wl_compositor_create_region(wind->waylandData->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(wind->surface, region);
wl_region_destroy(region);
SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, window->w, window->h);
}
static void
handle_configure(void *data, struct wl_shell_surface *shell_surface,
uint32_t edges, int32_t width, int32_t height)
{
SDL_WindowData *wind = (SDL_WindowData *)data;
SDL_Window *window = wind->sdlwindow;
struct wl_region *region;
window->w = width;
window->h = height;
WAYLAND_wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
region = wl_compositor_create_region(wind->waylandData->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(wind->surface, region);
wl_region_destroy(region);
SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, window->w, window->h);
}
static void
handle_configure_xdg_shell_surface(void *data, struct xdg_surface *xdg, uint32_t serial)
{
SDL_WindowData *wind = (SDL_WindowData *)data;
SDL_Window *window = wind->sdlwindow;
struct wl_region *region;
wind->shell_surface.xdg.initial_configure_seen = SDL_TRUE;
WAYLAND_wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
region = wl_compositor_create_region(wind->waylandData->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(wind->surface, region);
wl_region_destroy(region);
SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, window->w, window->h);
xdg_surface_ack_configure(xdg, serial);
}
bool
NativeStateWayland::create_window(WindowProperties const& properties)
{
struct my_output *output = 0;
if (!display_->outputs.empty()) output = display_->outputs.at(0);
window_ = new struct my_window();
window_->properties = properties;
window_->surface = wl_compositor_create_surface(display_->compositor);
if (window_->properties.fullscreen && output) {
window_->native = wl_egl_window_create(window_->surface,
output->width, output->height);
window_->properties.width = output->width;
window_->properties.height = output->height;
} else {
window_->native = wl_egl_window_create(window_->surface,
properties.width, properties.height);
}
window_->opaque_reqion = wl_compositor_create_region(display_->compositor);
wl_region_add(window_->opaque_reqion, 0, 0,
window_->properties.width,
window_->properties.height);
wl_surface_set_opaque_region(window_->surface, window_->opaque_reqion);
window_->shell_surface = wl_shell_get_shell_surface(display_->shell,
window_->surface);
if (window_->shell_surface) {
wl_shell_surface_add_listener(window_->shell_surface,
&shell_surface_listener_, this);
}
wl_shell_surface_set_title(window_->shell_surface, "glmark2");
if (window_->properties.fullscreen) {
wl_shell_surface_set_fullscreen(window_->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER,
output->refresh, output->output);
} else {
wl_shell_surface_set_toplevel(window_->shell_surface);
}
return true;
}
static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
struct window *window = data;
struct display *display = window->display;
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 uint32_t speed_div = 5, benchmark_interval = 5;
struct wl_region *region;
EGLint rect[4];
EGLint buffer_age = 0;
struct timeval tv;
assert(window->callback == callback);
window->callback = NULL;
if (callback)
wl_callback_destroy(callback);
gettimeofday(&tv, NULL);
time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (window->frames == 0)
window->benchmark_time = time;
if (time - window->benchmark_time > (benchmark_interval * 1000)) {
printf("%d frames in %d seconds: %f fps\n",
window->frames,
benchmark_interval,
(float) window->frames / benchmark_interval);
window->benchmark_time = time;
window->frames = 0;
}
angle = (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);
if (display->swap_buffers_with_damage)
eglQuerySurface(display->egl.dpy, window->egl_surface,
EGL_BUFFER_AGE_EXT, &buffer_age);
glViewport(0, 0, window->geometry.width, window->geometry.height);
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);
if (window->opaque || window->fullscreen) {
region = wl_compositor_create_region(window->display->compositor);
wl_region_add(region, 0, 0,
window->geometry.width,
window->geometry.height);
wl_surface_set_opaque_region(window->surface, region);
wl_region_destroy(region);
} else {
wl_surface_set_opaque_region(window->surface, NULL);
}
if (display->swap_buffers_with_damage && buffer_age > 0) {
rect[0] = window->geometry.width / 4 - 1;
rect[1] = window->geometry.height / 4 - 1;
rect[2] = window->geometry.width / 2 + 2;
rect[3] = window->geometry.height / 2 + 2;
display->swap_buffers_with_damage(display->egl.dpy,
window->egl_surface,
rect, 1);
} else {
eglSwapBuffers(display->egl.dpy, window->egl_surface);
}
window->frames++;
}
static gboolean
gst_vaapi_window_wayland_render (GstVaapiWindow * window,
GstVaapiSurface * surface,
const GstVaapiRectangle * src_rect,
const GstVaapiRectangle * dst_rect, guint flags)
{
GstVaapiWindowWaylandPrivate *const priv =
GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window);
GstVaapiDisplay *const display = GST_VAAPI_OBJECT_DISPLAY (window);
struct wl_display *const wl_display =
GST_VAAPI_OBJECT_NATIVE_DISPLAY (window);
struct wl_buffer *buffer;
FrameState *frame;
guint width, height, va_flags;
VAStatus status;
gboolean need_vpp = FALSE;
/* Check that we don't need to crop source VA surface */
gst_vaapi_surface_get_size (surface, &width, &height);
if (src_rect->x != 0 || src_rect->y != 0)
need_vpp = TRUE;
if (src_rect->width != width || src_rect->height != height)
need_vpp = TRUE;
/* Check that we don't render to a subregion of this window */
if (dst_rect->x != 0 || dst_rect->y != 0)
need_vpp = TRUE;
if (dst_rect->width != window->width || dst_rect->height != window->height)
need_vpp = TRUE;
/* Try to construct a Wayland buffer from VA surface as is (without VPP) */
if (!need_vpp) {
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
va_flags = from_GstVaapiSurfaceRenderFlags (flags);
status = vaGetSurfaceBufferWl (GST_VAAPI_DISPLAY_VADISPLAY (display),
GST_VAAPI_OBJECT_ID (surface),
va_flags & (VA_TOP_FIELD | VA_BOTTOM_FIELD), &buffer);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (status == VA_STATUS_ERROR_FLAG_NOT_SUPPORTED)
need_vpp = TRUE;
else if (!vaapi_check_status (status, "vaGetSurfaceBufferWl()"))
return FALSE;
}
/* Try to construct a Wayland buffer with VPP */
if (need_vpp) {
if (priv->use_vpp) {
GstVaapiSurface *const vpp_surface =
vpp_convert (window, surface, src_rect, dst_rect, flags);
if (G_UNLIKELY (!vpp_surface))
need_vpp = FALSE;
else {
surface = vpp_surface;
width = window->width;
height = window->height;
}
}
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
status = vaGetSurfaceBufferWl (GST_VAAPI_DISPLAY_VADISPLAY (display),
GST_VAAPI_OBJECT_ID (surface), VA_FRAME_PICTURE, &buffer);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!vaapi_check_status (status, "vaGetSurfaceBufferWl()"))
return FALSE;
}
/* Wait for the previous frame to complete redraw */
if (!gst_vaapi_window_wayland_sync (window)) {
wl_buffer_destroy (buffer);
return !priv->sync_failed;
}
frame = frame_state_new (window);
if (!frame)
return FALSE;
g_atomic_pointer_set (&priv->last_frame, frame);
g_atomic_int_inc (&priv->num_frames_pending);
if (need_vpp && priv->use_vpp) {
frame->surface = surface;
frame->surface_pool = gst_vaapi_video_pool_ref (priv->surface_pool);
}
/* XXX: attach to the specified target rectangle */
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
wl_surface_attach (priv->surface, buffer, 0, 0);
wl_surface_damage (priv->surface, 0, 0, width, height);
if (priv->opaque_region) {
wl_surface_set_opaque_region (priv->surface, priv->opaque_region);
wl_region_destroy (priv->opaque_region);
priv->opaque_region = NULL;
}
wl_proxy_set_queue ((struct wl_proxy *) buffer, priv->event_queue);
wl_buffer_add_listener (buffer, &frame_buffer_listener, frame);
frame->callback = wl_surface_frame (priv->surface);
wl_callback_add_listener (frame->callback, &frame_callback_listener, frame);
wl_surface_commit (priv->surface);
wl_display_flush (wl_display);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
return TRUE;
}
static void create_opaque_region()
{
region = wl_compositor_create_region(compositor);
wl_region_add(region, 0, 0, 480, 360);
wl_surface_set_opaque_region(surface, region);
}
int Wayland_CreateWindow(_THIS, SDL_Window *window)
{
SDL_WindowData *data;
SDL_VideoData *c;
struct wl_region *region;
data = calloc(1, sizeof *data);
if (data == NULL)
return 0;
c = _this->driverdata;
window->driverdata = data;
if (!(window->flags & SDL_WINDOW_OPENGL)) {
SDL_GL_LoadLibrary(NULL);
window->flags |= SDL_WINDOW_OPENGL;
}
if (window->x == SDL_WINDOWPOS_UNDEFINED) {
window->x = 0;
}
if (window->y == SDL_WINDOWPOS_UNDEFINED) {
window->y = 0;
}
data->waylandData = c;
data->sdlwindow = window;
data->surface =
wl_compositor_create_surface(c->compositor);
wl_surface_set_user_data(data->surface, data);
data->shell_surface = wl_shell_get_shell_surface(c->shell,
data->surface);
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (c->surface_extension) {
data->extended_surface = qt_surface_extension_get_extended_surface(
c->surface_extension, data->surface);
}
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
/**
* If the user specified 0x0 as the size (turned to 1x1 by SDL_CreateWindow
* in SDL_video.c), we want to make the window fill the whole screen
**/
if (window->w == 1) {
window->w = c->screen_allocation.width;
}
if (window->h == 1) {
window->h = c->screen_allocation.height;
}
data->egl_window = WAYLAND_wl_egl_window_create(data->surface,
window->w, window->h);
/* Create the GLES window surface */
data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->egl_window);
if (data->egl_surface == EGL_NO_SURFACE) {
SDL_SetError("failed to create a window surface");
return -1;
}
if (data->shell_surface) {
wl_shell_surface_set_user_data(data->shell_surface, data);
wl_shell_surface_add_listener(data->shell_surface,
&shell_surface_listener, data);
}
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (data->extended_surface) {
qt_extended_surface_set_user_data(data->extended_surface, data);
qt_extended_surface_add_listener(data->extended_surface,
&extended_surface_listener, data);
}
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
region = wl_compositor_create_region(c->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(data->surface, region);
wl_region_destroy(region);
WAYLAND_wl_display_flush(c->display);
return 0;
}
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;
struct wl_region *region;
assert(window->callback == callback);
window->callback = NULL;
if (callback)
wl_callback_destroy(callback);
if (!window->configured)
return;
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);
glViewport(0, 0, window->geometry.width, window->geometry.height);
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);
if (window->opaque || window->fullscreen) {
region = wl_compositor_create_region(window->display->compositor);
wl_region_add(region, 0, 0,
window->geometry.width,
window->geometry.height);
wl_surface_set_opaque_region(window->surface, region);
wl_region_destroy(region);
} else {
wl_surface_set_opaque_region(window->surface, NULL);
}
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &frame_listener, window);
eglSwapBuffers(window->display->egl.dpy, window->egl_surface);
}
int Wayland_CreateWindow(_THIS, SDL_Window *window)
{
SDL_WindowData *data;
SDL_VideoData *c;
struct wl_region *region;
data = calloc(1, sizeof *data);
if (data == NULL)
return SDL_OutOfMemory();
c = _this->driverdata;
window->driverdata = data;
if (!(window->flags & SDL_WINDOW_OPENGL)) {
SDL_GL_LoadLibrary(NULL);
window->flags |= SDL_WINDOW_OPENGL;
}
if (window->x == SDL_WINDOWPOS_UNDEFINED) {
window->x = 0;
}
if (window->y == SDL_WINDOWPOS_UNDEFINED) {
window->y = 0;
}
data->waylandData = c;
data->sdlwindow = window;
data->surface =
wl_compositor_create_surface(c->compositor);
wl_surface_set_user_data(data->surface, data);
if (c->shell.xdg) {
data->shell_surface.xdg.surface = xdg_wm_base_get_xdg_surface(c->shell.xdg, data->surface);
/* !!! FIXME: add popup role */
data->shell_surface.xdg.roleobj.toplevel = xdg_surface_get_toplevel(data->shell_surface.xdg.surface);
xdg_toplevel_add_listener(data->shell_surface.xdg.roleobj.toplevel, &toplevel_listener_xdg, data);
xdg_toplevel_set_app_id(data->shell_surface.xdg.roleobj.toplevel, c->classname);
} else if (c->shell.zxdg) {
data->shell_surface.zxdg.surface = zxdg_shell_v6_get_xdg_surface(c->shell.zxdg, data->surface);
/* !!! FIXME: add popup role */
data->shell_surface.zxdg.roleobj.toplevel = zxdg_surface_v6_get_toplevel(data->shell_surface.zxdg.surface);
zxdg_toplevel_v6_add_listener(data->shell_surface.zxdg.roleobj.toplevel, &toplevel_listener_zxdg, data);
zxdg_toplevel_v6_set_app_id(data->shell_surface.zxdg.roleobj.toplevel, c->classname);
} else {
data->shell_surface.wl = wl_shell_get_shell_surface(c->shell.wl, data->surface);
wl_shell_surface_set_class(data->shell_surface.wl, c->classname);
}
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (c->surface_extension) {
data->extended_surface = qt_surface_extension_get_extended_surface(
c->surface_extension, data->surface);
QtExtendedSurface_Subscribe(data->extended_surface, SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION);
QtExtendedSurface_Subscribe(data->extended_surface, SDL_HINT_QTWAYLAND_WINDOW_FLAGS);
}
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
data->egl_window = WAYLAND_wl_egl_window_create(data->surface,
window->w, window->h);
/* Create the GLES window surface */
data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->egl_window);
if (data->egl_surface == EGL_NO_SURFACE) {
return SDL_SetError("failed to create a window surface");
}
if (c->shell.xdg) {
if (data->shell_surface.xdg.surface) {
xdg_surface_set_user_data(data->shell_surface.xdg.surface, data);
xdg_surface_add_listener(data->shell_surface.xdg.surface, &shell_surface_listener_xdg, data);
}
} else if (c->shell.zxdg) {
if (data->shell_surface.zxdg.surface) {
zxdg_surface_v6_set_user_data(data->shell_surface.zxdg.surface, data);
zxdg_surface_v6_add_listener(data->shell_surface.zxdg.surface, &shell_surface_listener_zxdg, data);
}
} else {
if (data->shell_surface.wl) {
wl_shell_surface_set_user_data(data->shell_surface.wl, data);
wl_shell_surface_add_listener(data->shell_surface.wl, &shell_surface_listener_wl, data);
}
}
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (data->extended_surface) {
qt_extended_surface_set_user_data(data->extended_surface, data);
qt_extended_surface_add_listener(data->extended_surface,
&extended_surface_listener, data);
}
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
region = wl_compositor_create_region(c->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(data->surface, region);
wl_region_destroy(region);
if (c->relative_mouse_mode) {
Wayland_input_lock_pointer(c->input);
}
wl_surface_commit(data->surface);
WAYLAND_wl_display_flush(c->display);
/* we have to wait until the surface gets a "configure" event, or
use of this surface will fail. This is a new rule for xdg_shell. */
if (c->shell.xdg) {
if (data->shell_surface.xdg.surface) {
while (!data->shell_surface.xdg.initial_configure_seen) {
WAYLAND_wl_display_flush(c->display);
WAYLAND_wl_display_dispatch(c->display);
}
}
} else if (c->shell.zxdg) {
if (data->shell_surface.zxdg.surface) {
while (!data->shell_surface.zxdg.initial_configure_seen) {
WAYLAND_wl_display_flush(c->display);
WAYLAND_wl_display_dispatch(c->display);
}
}
}
return 0;
}
void XdevLWindowWayland::createOpaqueRegion(xdl_int x, xdl_int y, xdl_int width, xdl_int height) {
m_region = wl_compositor_create_region(m_compositor);
wl_region_add(m_region, x, y, width, height);
wl_surface_set_opaque_region(m_surface, m_region);
}
static gboolean
gst_mfx_window_wayland_render (GstMfxWindow * window,
GstMfxSurface * surface,
const GstMfxRectangle * src_rect, const GstMfxRectangle * dst_rect)
{
GstMfxWindowWaylandPrivate *const priv =
GST_MFX_WINDOW_WAYLAND_GET_PRIVATE (window);
GstMfxDisplayWaylandPrivate *const display_priv =
GST_MFX_DISPLAY_WAYLAND_GET_PRIVATE (GST_MFX_WINDOW_DISPLAY (window));
struct wl_display *const display =
GST_MFX_DISPLAY_HANDLE (GST_MFX_WINDOW_DISPLAY (window));
GstMfxPrimeBufferProxy *buffer_proxy;
struct wl_buffer *buffer;
FrameState *frame;
guintptr fd = 0;
guint32 drm_format = 0;
gint offsets[3] = { 0 }, pitches[3] = { 0 }, num_planes = 0, i = 0;
VaapiImage *vaapi_image;
buffer_proxy = gst_mfx_prime_buffer_proxy_new_from_surface (surface);
if (!buffer_proxy)
return FALSE;
fd = GST_MFX_PRIME_BUFFER_PROXY_HANDLE (buffer_proxy);
vaapi_image = gst_mfx_prime_buffer_proxy_get_vaapi_image (buffer_proxy);
num_planes = vaapi_image_get_plane_count (vaapi_image);
if ((dst_rect->height != src_rect->height)
|| (dst_rect->width != src_rect->width)) {
#ifdef USE_WESTON_4_0
if (priv->wp_viewport) {
wp_viewport_set_destination (priv->wp_viewport,
dst_rect->width, dst_rect->height);
}
#else
if (priv->viewport) {
wl_viewport_set_destination (priv->viewport,
dst_rect->width, dst_rect->height);
}
#endif
}
for (i = 0; i < num_planes; i++) {
offsets[i] = vaapi_image_get_offset (vaapi_image, i);
pitches[i] = vaapi_image_get_pitch (vaapi_image, i);
}
if (GST_VIDEO_FORMAT_NV12 == vaapi_image_get_format (vaapi_image)) {
drm_format = WL_DRM_FORMAT_NV12;
} else if (GST_VIDEO_FORMAT_BGRA == vaapi_image_get_format (vaapi_image)) {
drm_format = WL_DRM_FORMAT_ARGB8888;
}
if (!drm_format)
goto error;
if (!display_priv->drm)
goto error;
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
buffer =
wl_drm_create_prime_buffer (display_priv->drm, fd,
src_rect->width, src_rect->height, drm_format,
offsets[0], pitches[0],
offsets[1], pitches[1],
offsets[2], pitches[2]);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
if (!buffer) {
GST_ERROR ("No wl_buffer created\n");
goto error;
}
frame = frame_state_new (window);
if (!frame)
goto error;
g_atomic_pointer_set (&priv->last_frame, frame);
g_atomic_int_inc (&priv->num_frames_pending);
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
wl_surface_attach (priv->surface, buffer, 0, 0);
wl_surface_damage (priv->surface, 0, 0, dst_rect->width, dst_rect->height);
if (priv->opaque_region) {
wl_surface_set_opaque_region (priv->surface, priv->opaque_region);
wl_region_destroy (priv->opaque_region);
priv->opaque_region = NULL;
}
wl_proxy_set_queue ((struct wl_proxy *) buffer, priv->event_queue);
wl_buffer_add_listener (buffer, &frame_buffer_listener, frame);
frame->callback = wl_surface_frame (priv->surface);
wl_callback_add_listener (frame->callback, &frame_callback_listener, frame);
wl_surface_commit (priv->surface);
wl_display_flush (display);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
vaapi_image_unref (vaapi_image);
gst_mfx_prime_buffer_proxy_unref (buffer_proxy);
return TRUE;
error:
{
vaapi_image_unref (vaapi_image);
gst_mfx_prime_buffer_proxy_unref (buffer_proxy);
return FALSE;
}
}
int Wayland_CreateWindow(_THIS, SDL_Window *window)
{
SDL_WindowData *data;
SDL_VideoData *c;
struct wl_region *region;
data = calloc(1, sizeof *data);
if (data == NULL)
return SDL_OutOfMemory();
c = _this->driverdata;
window->driverdata = data;
if (!(window->flags & SDL_WINDOW_OPENGL)) {
SDL_GL_LoadLibrary(NULL);
window->flags |= SDL_WINDOW_OPENGL;
}
if (window->x == SDL_WINDOWPOS_UNDEFINED) {
window->x = 0;
}
if (window->y == SDL_WINDOWPOS_UNDEFINED) {
window->y = 0;
}
data->waylandData = c;
data->sdlwindow = window;
data->surface =
wl_compositor_create_surface(c->compositor);
wl_surface_set_user_data(data->surface, data);
data->shell_surface = wl_shell_get_shell_surface(c->shell,
data->surface);
wl_shell_surface_set_class (data->shell_surface, c->classname);
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (c->surface_extension) {
data->extended_surface = qt_surface_extension_get_extended_surface(
c->surface_extension, data->surface);
QtExtendedSurface_Subscribe(data->extended_surface, SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION);
QtExtendedSurface_Subscribe(data->extended_surface, SDL_HINT_QTWAYLAND_WINDOW_FLAGS);
}
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
data->egl_window = WAYLAND_wl_egl_window_create(data->surface,
window->w, window->h);
/* Create the GLES window surface */
data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->egl_window);
if (data->egl_surface == EGL_NO_SURFACE) {
return SDL_SetError("failed to create a window surface");
}
if (data->shell_surface) {
wl_shell_surface_set_user_data(data->shell_surface, data);
wl_shell_surface_add_listener(data->shell_surface,
&shell_surface_listener, data);
}
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (data->extended_surface) {
qt_extended_surface_set_user_data(data->extended_surface, data);
qt_extended_surface_add_listener(data->extended_surface,
&extended_surface_listener, data);
}
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
region = wl_compositor_create_region(c->compositor);
wl_region_add(region, 0, 0, window->w, window->h);
wl_surface_set_opaque_region(data->surface, region);
wl_region_destroy(region);
if (c->relative_mouse_mode) {
Wayland_input_lock_pointer(c->input);
}
WAYLAND_wl_display_flush(c->display);
return 0;
}