C++ (Cpp) pipe_buffer_flush_mapped_range示例

示例#1

文件： svga_swtnl_backend.c 项目： BNieuwenhuizen/mesa

static void
svga_vbuf_render_unmap_vertices( struct vbuf_render *render,
                                 ushort min_index,
                                 ushort max_index )
{
   struct svga_vbuf_render *svga_render = svga_vbuf_render(render);
   struct svga_context *svga = svga_render->svga;
   unsigned offset, length;
   size_t used = svga_render->vertex_size * ((size_t)max_index + 1);

   offset = svga_render->vbuf_offset + svga_render->vertex_size * min_index;
   length = svga_render->vertex_size * (max_index + 1 - min_index);

   if (0) {
      /* dump vertex data */
      const float *f = (const float *) ((char *) svga_render->vbuf_ptr +
                                        svga_render->vbuf_offset);
      unsigned i;
      debug_printf("swtnl vertex data:\n");
      for (i = 0; i < length / 4; i += 4) {
         debug_printf("%u: %f %f %f %f\n", i, f[i], f[i+1], f[i+2], f[i+3]);
      }
   }

   pipe_buffer_flush_mapped_range(&svga->pipe,
				  svga_render->vbuf_transfer,
				  offset, length);
   pipe_buffer_unmap(&svga->pipe, svga_render->vbuf_transfer);
   svga_render->min_index = min_index;
   svga_render->max_index = max_index;
   svga_render->vbuf_used = MAX2(svga_render->vbuf_used, used);
}

示例#2

文件： u_upload_mgr.c 项目： CPFDSoftware-Tony/gmv

static INLINE enum pipe_error
my_buffer_write(struct pipe_screen *screen,
                struct pipe_buffer *buf,
                unsigned offset, unsigned size, unsigned dirty_size,
                const void *data)
{
    uint8_t *map;

    assert(offset < buf->size);
    assert(offset + size <= buf->size);
    assert(dirty_size >= size);
    assert(size);

    map = pipe_buffer_map_range(screen, buf, offset, size,
    PIPE_BUFFER_USAGE_CPU_WRITE |
    PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
    PIPE_BUFFER_USAGE_DISCARD |
    PIPE_BUFFER_USAGE_UNSYNCHRONIZED);
    if (map == NULL)
        return PIPE_ERROR_OUT_OF_MEMORY;

    memcpy(map + offset, data, size);
    pipe_buffer_flush_mapped_range(screen, buf, offset, dirty_size);
    pipe_buffer_unmap(screen, buf);

    return PIPE_OK;
}

示例#3

文件： u_upload_mgr.c 项目： ChristophHaag/mesa-mesa

static void
upload_unmap_internal(struct u_upload_mgr *upload, boolean destroying)
{
   if (!upload->transfer)
      return;

   if (upload->map_flags & PIPE_TRANSFER_FLUSH_EXPLICIT) {
      struct pipe_box *box = &upload->transfer->box;
      unsigned flush_offset = box->x + upload->flushed_size;

      if (upload->offset > flush_offset) {
         pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer,
                                        flush_offset,
                                        upload->offset - flush_offset);
         upload->flushed_size = upload->offset;
      }
   }

   if (destroying || !upload->map_persistent) {
      pipe_transfer_unmap(upload->pipe, upload->transfer);
      upload->transfer = NULL;
      upload->map = NULL;
      upload->flushed_size = 0;
   }
}

示例#4

文件： u_upload_mgr.c 项目： 1065672644894730302/Chromium

/* Slightly specialized version of buffer_write designed to maximize
 * chances of the driver consolidating successive writes into a single
 * upload.
 *
 * dirty_size may be slightly greater than size to cope with
 * alignment.  We don't want to leave holes between succesively mapped
 * regions as that may prevent the driver from consolidating uploads.
 * 
 * Note that the 'data' pointer has probably come from the application
 * and we cannot read even a byte past its end without risking
 * segfaults, or at least complaints from valgrind..
 */
static INLINE enum pipe_error
my_buffer_write(struct pipe_context *pipe,
                struct pipe_resource *buf,
                unsigned offset, unsigned size, unsigned dirty_size,
                const void *data)
{
   struct pipe_transfer *transfer = NULL;
   uint8_t *map;
   
   assert(offset < buf->width0);
   assert(offset + size <= buf->width0);
   assert(dirty_size >= size);
   assert(size);

   map = pipe_buffer_map_range(pipe, buf, offset, dirty_size,
                               PIPE_TRANSFER_WRITE |
                               PIPE_TRANSFER_FLUSH_EXPLICIT |
                               PIPE_TRANSFER_DISCARD |
                               PIPE_TRANSFER_UNSYNCHRONIZED,
			       &transfer);
   if (map == NULL) 
      return PIPE_ERROR_OUT_OF_MEMORY;

   memcpy(map + offset, data, size);
   pipe_buffer_flush_mapped_range(pipe, transfer, offset, dirty_size);
   pipe_buffer_unmap(pipe, buf, transfer);

   return PIPE_OK;
}

示例#5

文件： u_upload_mgr.c 项目： venkatarajasekhar/Qt

void u_upload_unmap( struct u_upload_mgr *upload )
{
   if (upload->transfer) {
      struct pipe_box *box = &upload->transfer->box;
      if (upload->offset > box->x) {

         pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer,
                                        box->x, upload->offset - box->x);
      }
      pipe_transfer_unmap(upload->pipe, upload->transfer);
      pipe_transfer_destroy(upload->pipe, upload->transfer);
      upload->transfer = NULL;
      upload->map = NULL;
   }
}

示例#6

文件： st_cb_bufferobjects.c 项目： toastpp/toastpp

static void
st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, 
                                GLintptr offset, GLsizeiptr length,
                                struct gl_buffer_object *obj)
{
   struct pipe_context *pipe = st_context(ctx)->pipe;
   struct st_buffer_object *st_obj = st_buffer_object(obj);

   /* Subrange is relative to mapped range */
   assert(offset >= 0);
   assert(length >= 0);
   assert(offset + length <= obj->Length);
   
   pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer, 
                                  obj->Offset + offset, length);
}

示例#7

文件： svga_swtnl_backend.c 项目： MttDs/new-rexeno-tindpe

static void
svga_vbuf_render_unmap_vertices( struct vbuf_render *render,
                                 ushort min_index,
                                 ushort max_index )
{
   struct svga_vbuf_render *svga_render = svga_vbuf_render(render);
   struct svga_context *svga = svga_render->svga;
   struct pipe_screen *screen = svga->pipe.screen;
   unsigned offset, length;
   size_t used = svga_render->vertex_size * ((size_t)max_index + 1);

   offset = svga_render->vbuf_offset + svga_render->vertex_size * min_index;
   length = svga_render->vertex_size * (max_index + 1 - min_index);
   pipe_buffer_flush_mapped_range(screen, svga_render->vbuf, offset, length);
   pipe_buffer_unmap(screen, svga_render->vbuf);
   svga_render->min_index = min_index;
   svga_render->max_index = max_index;
   svga_render->vbuf_used = MAX2(svga_render->vbuf_used, used);
}

示例#8

文件： u_upload_mgr.c 项目： ValveSoftware/steamos_mesa

static void
upload_unmap_internal(struct u_upload_mgr *upload, boolean destroying)
{
   if (!destroying && upload->map_persistent)
      return;

   if (upload->transfer) {
      struct pipe_box *box = &upload->transfer->box;

      if (!upload->map_persistent && (int) upload->offset > box->x) {
         pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer,
                                        box->x, upload->offset - box->x);
      }

      pipe_transfer_unmap(upload->pipe, upload->transfer);
      upload->transfer = NULL;
      upload->map = NULL;
   }
}

示例#9

文件： st_cb_bufferobjects.c 项目： DirectFB/mesa

static void
st_bufferobj_flush_mapped_range(struct gl_context *ctx,
                                GLintptr offset, GLsizeiptr length,
                                struct gl_buffer_object *obj)
{
   struct pipe_context *pipe = st_context(ctx)->pipe;
   struct st_buffer_object *st_obj = st_buffer_object(obj);

   /* Subrange is relative to mapped range */
   assert(offset >= 0);
   assert(length >= 0);
   assert(offset + length <= obj->Length);
   assert(obj->Pointer);

   if (!length)
      return;

   pipe_buffer_flush_mapped_range(pipe, st_obj->transfer,
                                  obj->Offset + offset, length);
}