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; }