uint8_t fini_wayland_buffer(struct wayland *wayland)
{
uint8_t exit_code = 0;
wl_buffer_destroy(wayland->back_buffer);
wl_buffer_destroy(wayland->front_buffer);
wl_shm_pool_destroy(wayland->shm_pool);
if (munmap(wayland->data, wayland->capacity) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
static void
destroy_window(struct window *window)
{
if (window->callback)
wl_callback_destroy(window->callback);
if (window->buffers[0].buffer)
wl_buffer_destroy(window->buffers[0].buffer);
if (window->buffers[1].buffer)
wl_buffer_destroy(window->buffers[1].buffer);
wl_shell_surface_destroy(window->shell_surface);
wl_surface_destroy(window->surface);
free(window);
}
static void
gst_wl_meta_free (GstWlMeta * meta, GstBuffer * buffer)
{
gst_object_unref (meta->sink);
munmap (meta->data, meta->size);
wl_buffer_destroy (meta->wbuffer);
}
/**
* Called via eglDestroySurface(), drv->API.DestroySurface().
*/
static EGLBoolean
dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
{
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
int i;
(void) drv;
if (!_eglPutSurface(surf))
return EGL_TRUE;
(*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
for (i = 0; i < WL_BUFFER_COUNT; ++i)
if (dri2_surf->wl_drm_buffer[i])
wl_buffer_destroy(dri2_surf->wl_drm_buffer[i]);
for (i = 0; i < __DRI_BUFFER_COUNT; ++i)
if (dri2_surf->dri_buffers[i] && !(i == __DRI_BUFFER_FRONT_LEFT &&
dri2_surf->base.Type == EGL_PIXMAP_BIT))
dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
dri2_surf->dri_buffers[i]);
if (dri2_surf->third_buffer) {
dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
dri2_surf->third_buffer);
}
free(surf);
return EGL_TRUE;
}
static void
clutter_backend_wayland_dispose (GObject *gobject)
{
ClutterBackendWayland *backend_wayland = CLUTTER_BACKEND_WAYLAND (gobject);
if (backend_wayland->device_manager)
{
g_object_unref (backend_wayland->device_manager);
backend_wayland->device_manager = NULL;
}
if (backend_wayland->cursor_buffer)
{
wl_buffer_destroy (backend_wayland->cursor_buffer);
backend_wayland->cursor_buffer = NULL;
}
if (backend_wayland->cursor_theme)
{
wl_cursor_theme_destroy (backend_wayland->cursor_theme);
backend_wayland->cursor_theme = NULL;
}
G_OBJECT_CLASS (clutter_backend_wayland_parent_class)->dispose (gobject);
}
/* Delete a specific drawable */
static WSEGLError wseglDeleteDrawable(WSEGLDrawableHandle _drawable)
{
struct wl_egl_window *drawable = (struct wl_egl_window *) _drawable;
int index;
int numBuffers = WAYLANDWSEGL_MAX_BACK_BUFFERS;
if (drawable->header.type == WWSEGL_DRAWABLE_TYPE_WINDOW) {
for (index = 0; index < numBuffers; ++index) {
if (drawable->drmbuffers[index])
wl_buffer_destroy(drawable->drmbuffers[index]);
if (drawable->backBuffers[index])
PVR2DMemFree(drawable->display->context, drawable->backBuffers[index]);
}
memset(drawable->drmbuffers, 0, sizeof(drawable->drmbuffers));
memset(drawable->backBuffers, 0, sizeof(drawable->backBuffers));
drawable->backBuffersValid = 0;
return WSEGL_SUCCESS;
} else if (drawable->header.type == WWSEGL_DRAWABLE_TYPE_PIXMAP) {
struct wl_egl_pixmap *pixmap = (struct wl_egl_pixmap *)drawable;
PVR2DMemFree(pixmap->display->context, pixmap->pvrmem);
} else {
assert(0);
}
return WSEGL_SUCCESS;
}
static void
_destroy_buffer (BufferData *buffer)
{
if (!buffer)
return;
buffer->disposed = TRUE;
/* If the buffer is acquired by the compositor, don't free it
* yet, but wait until it's been released.
*/
if (!buffer->released)
return;
if (buffer->surface)
cairo_surface_destroy (buffer->surface);
if (buffer->wl_buffer)
wl_buffer_destroy (buffer->wl_buffer);
if (buffer->wl_pool)
wl_shm_pool_destroy (buffer->wl_pool);
if (buffer->data && buffer->data_len)
munmap (buffer->data, buffer->data_len);
g_free (buffer);
}
static void
shm_surface_data_destroy(void *p)
{
struct shm_surface_data *data = p;
wl_buffer_destroy(data->data.buffer);
munmap(data->map, data->length);
}
static void
frame_release_callback (void *data, struct wl_buffer *wl_buffer)
{
FrameState *const frame = data;
if (!frame->done)
frame_done (frame);
wl_buffer_destroy (wl_buffer);
frame_state_free (frame);
}
static void buffer_release_cb(void *data, struct wl_buffer *buffer)
{
struct buffer_data *d = data;
picture_Release(d->picture);
(*(d->counter))--;
free(d);
wl_buffer_destroy(buffer);
}
static void
destroy_window(struct window *window)
{
if (window->callback)
wl_callback_destroy(window->callback);
if (window->buffers[0].buffer)
wl_buffer_destroy(window->buffers[0].buffer);
if (window->buffers[1].buffer)
wl_buffer_destroy(window->buffers[1].buffer);
if (window->xdg_surface)
xdg_surface_destroy(window->xdg_surface);
if (window->viewport)
wl_viewport_destroy(window->viewport);
wl_surface_destroy(window->surface);
free(window);
}
void hello_free_cursor(void)
{
struct pointer_data *data;
data = wl_pointer_get_user_data(pointer);
wl_buffer_destroy(data->buffer);
wl_surface_destroy(data->surface);
free(data);
wl_pointer_set_user_data(pointer, NULL);
}
static void
wl_cursor_image_destroy(struct wl_cursor_image *_img)
{
struct cursor_image *image = (struct cursor_image *) _img;
if (image->buffer)
wl_buffer_destroy(image->buffer);
free(image);
}
static void
frame_redraw_callback(void *data, struct wl_callback *callback, uint32_t time)
{
GstVaapiWindowWaylandPrivate * const priv = data;
priv->redraw_pending = FALSE;
wl_buffer_destroy(priv->buffer);
priv->buffer = NULL;
wl_callback_destroy(callback);
}
ServerWaylandBuffer::~ServerWaylandBuffer()
{
if (m_buf)
wl_buffer_destroy(m_buf);
m_gralloc->unregisterBuffer(m_gralloc, handle);
native_handle_close(handle);
native_handle_delete(const_cast<native_handle_t *>(handle));
wl_array_release(&ints);
wl_array_release(&fds);
}
static block_t *Shoot(demux_t *demux)
{
demux_sys_t *sys = demux->p_sys;
int fd = vlc_memfd();
if (fd == -1)
{
msg_Err(demux, "buffer creation error: %s", vlc_strerror_c(errno));
return NULL;
}
/* NOTE: one extra line for overflow if screen-left > 0 */
uint32_t pitch = 4u * sys->width;
size_t size = (pitch * (sys->height + 1) + sys->pagemask) & ~sys->pagemask;
block_t *block = NULL;
if (ftruncate(fd, size) < 0)
{
msg_Err(demux, "buffer allocation error: %s", vlc_strerror_c(errno));
goto out;
}
struct wl_shm_pool *pool = wl_shm_create_pool(sys->shm, fd, size);
if (pool == NULL)
goto out;
struct wl_buffer *buffer;
buffer = wl_shm_pool_create_buffer(pool, 0, sys->width, sys->height,
pitch, WL_SHM_FORMAT_XRGB8888);
wl_shm_pool_destroy(pool);
if (buffer == NULL)
goto out;
sys->done = false;
screenshooter_shoot(sys->screenshooter, sys->output, buffer);
while (!sys->done)
wl_display_roundtrip(sys->display);
wl_buffer_destroy(buffer);
block = block_File(fd, true);
if (block != NULL)
{
size_t skip = (sys->y * sys->width + sys->x) * 4;
block->p_buffer += skip;
block->i_buffer -= skip;
}
out:
vlc_close(fd);
return block;
}
void WaylandNativeWindow::destroyBuffer(WaylandNativeWindowBuffer* wnb)
{
TRACE("wnb:%p", wnb);
assert(wnb != NULL);
if (wnb->wlbuffer)
wl_buffer_destroy(wnb->wlbuffer);
wnb->wlbuffer = NULL;
wnb->common.decRef(&wnb->common);
m_freeBufs--;
}
void shm_buffer_destroy(shm_buffer_t *buffer)
{
if (!buffer)
return;
wl_buffer_destroy(buffer->buffer);
wl_shm_pool_destroy(buffer->shm_pool);
munmap(buffer->data, buffer->pool_size);
close(buffer->fd);
free(buffer);
}
void wlf_DestroyWindow(wlfContext* wlfc, wlfWindow* window)
{
if (window == NULL)
return;
if (wlfc->window == window)
wlfc->window = NULL;
if (window->buffers[0].buffer)
wl_buffer_destroy(window->buffers[0].buffer);
if (window->buffers[1].buffer)
wl_buffer_destroy(window->buffers[1].buffer);
if (window->shell_surface)
wl_shell_surface_destroy(window->shell_surface);
if (window->surface)
wl_surface_destroy(window->surface);
free(window->data);
free(window);
}
static void
wayland_free_buffer (ClutterStageWaylandWaylandBuffer *buffer)
{
cogl_handle_unref (buffer->tex);
wl_buffer_destroy (buffer->wayland_buffer);
cogl_handle_unref (buffer->offscreen);
if (buffer->type == BUFFER_TYPE_DRM)
wayland_free_drm_buffer(buffer);
else if (buffer->type == BUFFER_TYPE_SHM)
wayland_free_shm_buffer(buffer);
}
static void
notify_surface_destroy(struct wl_compositor *compositor,
struct wl_surface *surface)
{
struct wl_buffer *b;
b = wl_surface_get_data(surface);
if (b == NULL)
return;
wl_buffer_destroy (b);
}
static void
drm_surface_data_destroy(void *p)
{
struct drm_surface_data *data = p;
struct display *d = data->display;
cairo_device_acquire(d->device);
glDeleteTextures(1, &data->texture);
cairo_device_release(d->device);
eglDestroyImageKHR(d->dpy, data->image);
wl_buffer_destroy(data->data.buffer);
}
static void
ss_shm_buffer_destroy(struct ss_shm_buffer *buffer)
{
pixman_image_unref(buffer->pm_image);
wl_buffer_destroy(buffer->buffer);
munmap(buffer->data, buffer->size);
pixman_region32_fini(&buffer->damage);
wl_list_remove(&buffer->link);
wl_list_remove(&buffer->free_link);
free(buffer);
}
void Buffer::Destroy() {
if (nullptr != p_->wl_buffer) {
p_->data = nullptr;
p_->offset = 0;
p_->format = 0;
p_->stride = 0;
p_->size.width = 0;
p_->size.height = 0;
wl_buffer_destroy(p_->wl_buffer);
p_->wl_buffer = nullptr;
destroyed_.Emit();
}
}
static void
wayland_surface_destroy(struct native_surface *nsurf)
{
struct wayland_surface *surface = wayland_surface(nsurf);
enum wayland_buffer_type buffer;
for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) {
if (surface->buffer[buffer])
wl_buffer_destroy(surface->buffer[buffer]);
}
resource_surface_destroy(surface->rsurf);
FREE(surface);
}
static void
_eventd_nd_wl_buffer_release(gpointer data, struct wl_buffer *buf)
{
EventdNdWlBuffer *self = data;
if ( self->released )
{
wl_buffer_destroy(self->buffer);
munmap(self->data, self->size);
g_free(self);
}
else
self->released = TRUE;
}
static void
wayland_shm_buffer_destroy(struct wayland_shm_buffer *buffer)
{
cairo_surface_destroy(buffer->c_surface);
pixman_image_unref(buffer->pm_image);
wl_buffer_destroy(buffer->buffer);
munmap(buffer->data, buffer->size);
pixman_region32_fini(&buffer->damage);
wl_list_remove(&buffer->link);
wl_list_remove(&buffer->free_link);
free(buffer);
}
static void
_evas_swapper_buffer_free(Wl_Buffer *wb)
{
LOGFN(__FILE__, __LINE__, __FUNCTION__);
/* check for valid buffer */
if ((!wb) || (wb->valid)) return;
/* kill the wl_buffer */
if (wb->buffer) wl_buffer_destroy(wb->buffer);
wb->buffer = NULL;
/* unmap the buffer data */
/* if (wb->data) munmap(wb->data, wb->size); */
wb->data = NULL;
}
static void
wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap)
{
struct pipe_resource *resource = egl_pixmap->driver_private;
assert(resource);
pipe_resource_reference(&resource, NULL);
if (egl_pixmap->buffer) {
wl_buffer_destroy(egl_pixmap->buffer);
egl_pixmap->buffer = NULL;
}
egl_pixmap->driver_private = NULL;
egl_pixmap->destroy = NULL;
}
QWaylandShmBuffer::~QWaylandShmBuffer(void)
{
delete mMarginsImage;
munmap((void *) mImage.constBits(), mImage.byteCount());
wl_buffer_destroy(mBuffer);
wl_shm_pool_destroy(mShmPool);
}
