Lines Matching refs:buffer
239 dri3_fence_reset(xcb_connection_t *c, struct loader_dri3_buffer *buffer)
241 xshmfence_reset(buffer->shm_fence);
245 dri3_fence_set(struct loader_dri3_buffer *buffer)
247 xshmfence_trigger(buffer->shm_fence);
251 dri3_fence_trigger(xcb_connection_t *c, struct loader_dri3_buffer *buffer)
253 xcb_sync_trigger_fence(c, buffer->sync_fence);
258 struct loader_dri3_buffer *buffer)
261 xshmfence_await(buffer->shm_fence);
301 /* On transition from flips to copies, start with a single buffer again,
333 * Free everything associated with one render buffer including pixmap, fence
338 struct loader_dri3_buffer *buffer)
340 if (buffer->own_pixmap)
341 xcb_free_pixmap(draw->conn, buffer->pixmap);
342 xcb_sync_destroy_fence(draw->conn, buffer->sync_fence);
343 xshmfence_unmap_shm(buffer->shm_fence);
344 draw->ext->image->destroyImage(buffer->image);
345 if (buffer->linear_buffer)
346 draw->ext->image->destroyImage(buffer->linear_buffer);
347 free(buffer);
638 * Wait for the completed swap buffer count to reach the specified
673 * Find an idle back buffer. If there isn't one, then
684 /* Increase the likelyhood of reusing current buffer */
687 /* Check whether we need to reuse the current back buffer as new back.
700 * to find an idle buffer that is not the last used one.
712 struct loader_dri3_buffer *buffer = draw->buffers[id];
714 if (!buffer || (!buffer->busy &&
831 /* Update the linear buffer part of the back buffer
905 /* In the psc->is_different_gpu case, the linear buffer has been updated,
906 * but not yet the tiled buffer.
907 * Copy back to the tiled buffer we use for rendering.
967 * Make the current back buffer visible using the present extension
992 * If surface is a back-buffered window surface, then the color buffer is
1022 /* Update the linear buffer before presenting the pixmap */
1030 /* If we need to preload the new back buffer, remember the source.
1032 * the back buffer across a call to this function.
1080 * "If <interval> is set to a value of 0, buffer swaps are not
1086 * between buffer swaps is the absolute value of <interval>. In this
1100 * buffer slot due to lack of local blit capabilities, make sure
1154 /* For wait and buffer age usage. */
1158 /* Pixmap is imported as front buffer image when same GPU case, so just
1159 * locally blit back buffer image to it is enough. Otherwise front buffer
1180 * b) We need to preserve the back buffer,
1295 /* Map format of render buffer to corresponding format for the linear_buffer
1404 struct loader_dri3_buffer *buffer;
1430 buffer = calloc(1, sizeof *buffer);
1431 if (!buffer)
1434 buffer->cpp = dri3_cpp_for_format(format);
1435 if (!buffer->cpp)
1450 depth, buffer->cpp * 8);
1494 buffer->image = loader_dri_create_image(draw->dri_screen, draw->ext->image,
1501 modifiers, count, buffer);
1504 pixmap_buffer = buffer->image;
1506 if (!buffer->image)
1509 buffer->image = draw->ext->image->createImage(draw->dri_screen,
1513 buffer);
1515 if (!buffer->image)
1531 buffer);
1536 buffer->linear_buffer =
1545 buffer);
1547 pixmap_buffer = buffer->linear_buffer;
1548 if (!buffer->linear_buffer) {
1573 &buffer->strides[i]);
1575 &buffer->offsets[i]);
1585 buffer->modifier = (uint64_t) mod << 32;
1588 buffer->modifier |= (uint64_t)(mod & 0xffffffff);
1591 buffer->modifier = DRM_FORMAT_MOD_INVALID;
1595 /* The linear buffer was created in the display GPU's vram, so we
1599 buffer->linear_buffer =
1606 &buffer->strides[0],
1607 &buffer->offsets[0],
1608 buffer);
1610 buffer->linear_buffer =
1616 &buffer->strides[0],
1617 &buffer->offsets[0],
1618 buffer);
1619 if (!buffer->linear_buffer)
1628 buffer->modifier != DRM_FORMAT_MOD_INVALID) {
1634 buffer->strides[0], buffer->offsets[0],
1635 buffer->strides[1], buffer->offsets[1],
1636 buffer->strides[2], buffer->offsets[2],
1637 buffer->strides[3], buffer->offsets[3],
1638 depth, buffer->cpp * 8,
1639 buffer->modifier,
1647 buffer->size,
1648 width, height, buffer->strides[0],
1649 depth, buffer->cpp * 8,
1659 buffer->pixmap = pixmap;
1660 buffer->own_pixmap = true;
1661 buffer->sync_fence = sync_fence;
1662 buffer->shm_fence = shm_fence;
1663 buffer->width = width;
1664 buffer->height = height;
1666 /* Mark the buffer as idle
1668 dri3_fence_set(buffer);
1670 return buffer;
1680 draw->ext->image->destroyImage(buffer->image);
1682 free(buffer);
1911 struct loader_dri3_buffer *buffer = draw->buffers[buf_id];
1920 if (buffer)
1921 return buffer;
1925 buffer = calloc(1, sizeof *buffer);
1926 if (!buffer)
1964 buffer->image =
1967 buffer);
1982 buffer->image = loader_dri3_create_image(draw->conn, bp_reply, format,
1984 buffer);
1990 if (!buffer->image)
1993 buffer->pixmap = pixmap;
1994 buffer->own_pixmap = false;
1995 buffer->width = width;
1996 buffer->height = height;
1997 buffer->shm_fence = shm_fence;
1998 buffer->sync_fence = sync_fence;
2000 draw->buffers[buf_id] = buffer;
2002 return buffer;
2008 free(buffer);
2015 * Find a front or back buffer, allocating new ones as necessary
2023 struct loader_dri3_buffer *buffer;
2038 buffer = draw->buffers[buf_id];
2040 /* Allocate a new buffer if there isn't an old one, if that
2043 if (!buffer || buffer->width != draw->width ||
2044 buffer->height != draw->height ||
2045 buffer->reallocate) {
2058 /* When resizing, copy the contents of the old buffer, waiting for that
2063 && buffer) {
2065 /* Fill the new buffer with data from an old buffer */
2068 buffer->image,
2070 MIN2(buffer->width, new_buffer->width),
2071 MIN2(buffer->height, new_buffer->height),
2073 !buffer->linear_buffer) {
2076 buffer->pixmap,
2084 dri3_free_render_buffer(draw, buffer);
2107 buffer = new_buffer;
2108 draw->buffers[buf_id] = buffer;
2112 dri3_fence_await(draw->conn, draw, buffer);
2115 * Do we need to preserve the content of a previous buffer?
2117 * Note that this blit is needed only to avoid a wait for a buffer that
2126 buffer != draw->buffers[draw->cur_blit_source]) {
2132 buffer->image,
2136 buffer->last_swap = source->last_swap;
2139 /* Return the requested buffer */
2140 return buffer;
2153 struct loader_dri3_buffer *buffer;
2174 buffer = draw->buffers[buf_id];
2175 if (buffer) {
2176 dri3_free_render_buffer(draw, buffer);
2184 * The published buffer allocation API.
2230 * as buffer since it is potentially tiled a way
2232 * a fake front buffer. Hopefully the pixmap
2234 * buffer.
2342 * Find a backbuffer slot - potentially allocating a back buffer
2345 * \return Pointer to a new back buffer or NULL if allocation failed or was
2348 * Find a potentially new back buffer, and if it's not been allocated yet and