X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fidentity%2Fid_objects.c;h=63454410525ee4e8639d794e8bb637962ffb6f83;hb=a3fccafda9596d9377a621904098afe223825576;hp=d37fb0042e54a2c6d46dfb1d2a6fb704ddb4236a;hpb=ee30e24f5f9cc2ec6c5a3edbe498e5e0334f788b;p=mesa.git

diff --git a/src/gallium/drivers/identity/id_objects.c b/src/gallium/drivers/identity/id_objects.c
index d37fb0042e5..63454410525 100644
--- a/src/gallium/drivers/identity/id_objects.c
+++ b/src/gallium/drivers/identity/id_objects.c
@@ -32,119 +32,125 @@
 #include "id_objects.h"
 #include "id_context.h"
 
-struct pipe_buffer *
-identity_buffer_create(struct identity_screen *id_screen,
-                       struct pipe_buffer *buffer)
+
+
+struct pipe_resource *
+identity_resource_create(struct identity_screen *id_screen,
+                        struct pipe_resource *resource)
 {
-   struct identity_buffer *id_buffer;
+   struct identity_resource *id_resource;
 
-   if(!buffer)
+   if(!resource)
       goto error;
 
-   assert(buffer->screen == id_screen->screen);
+   assert(resource->screen == id_screen->screen);
 
-   id_buffer = CALLOC_STRUCT(identity_buffer);
-   if(!id_buffer)
+   id_resource = CALLOC_STRUCT(identity_resource);
+   if(!id_resource)
       goto error;
 
-   memcpy(&id_buffer->base, buffer, sizeof(struct pipe_buffer));
+   memcpy(&id_resource->base, resource, sizeof(struct pipe_resource));
 
-   pipe_reference_init(&id_buffer->base.reference, 1);
-   id_buffer->base.screen = &id_screen->base;
-   id_buffer->buffer = buffer;
+   pipe_reference_init(&id_resource->base.reference, 1);
+   id_resource->base.screen = &id_screen->base;
+   id_resource->resource = resource;
 
-   return &id_buffer->base;
+   return &id_resource->base;
 
 error:
-   pipe_buffer_reference(&buffer, NULL);
+   pipe_resource_reference(&resource, NULL);
    return NULL;
 }
 
 void
-identity_buffer_destroy(struct identity_buffer *id_buffer)
+identity_resource_destroy(struct identity_resource *id_resource)
 {
-   pipe_buffer_reference(&id_buffer->buffer, NULL);
-   FREE(id_buffer);
+   pipe_resource_reference(&id_resource->resource, NULL);
+   FREE(id_resource);
 }
 
 
-struct pipe_texture *
-identity_texture_create(struct identity_screen *id_screen,
-                        struct pipe_texture *texture)
+struct pipe_surface *
+identity_surface_create(struct identity_context *id_context,
+                        struct identity_resource *id_resource,
+                        struct pipe_surface *surface)
 {
-   struct identity_texture *id_texture;
+   struct identity_surface *id_surface;
 
-   if(!texture)
+   if(!surface)
       goto error;
 
-   assert(texture->screen == id_screen->screen);
+   assert(surface->texture == id_resource->resource);
 
-   id_texture = CALLOC_STRUCT(identity_texture);
-   if(!id_texture)
+   id_surface = CALLOC_STRUCT(identity_surface);
+   if(!id_surface)
       goto error;
 
-   memcpy(&id_texture->base, texture, sizeof(struct pipe_texture));
+   memcpy(&id_surface->base, surface, sizeof(struct pipe_surface));
 
-   pipe_reference_init(&id_texture->base.reference, 1);
-   id_texture->base.screen = &id_screen->base;
-   id_texture->texture = texture;
+   pipe_reference_init(&id_surface->base.reference, 1);
+   id_surface->base.texture = NULL;
+   pipe_resource_reference(&id_surface->base.texture, &id_resource->base);
+   id_surface->surface = surface;
 
-   return &id_texture->base;
+   return &id_surface->base;
 
 error:
-   pipe_texture_reference(&texture, NULL);
+   pipe_surface_reference(&surface, NULL);
    return NULL;
 }
 
 void
-identity_texture_destroy(struct identity_texture *id_texture)
+identity_surface_destroy(struct identity_context *id_context,
+                         struct identity_surface *id_surface)
 {
-   pipe_texture_reference(&id_texture->texture, NULL);
-   FREE(id_texture);
+   pipe_resource_reference(&id_surface->base.texture, NULL);
+   id_context->pipe->surface_destroy(id_context->pipe,
+                                     id_surface->surface);
+   FREE(id_surface);
 }
 
 
-struct pipe_surface *
-identity_surface_create(struct identity_texture *id_texture,
-                        struct pipe_surface *surface)
+struct pipe_sampler_view *
+identity_sampler_view_create(struct identity_context *id_context,
+                             struct identity_resource *id_resource,
+                             struct pipe_sampler_view *view)
 {
-   struct identity_surface *id_surface;
+   struct identity_sampler_view *id_view;
 
-   if(!surface)
-      goto error;
-
-   assert(surface->texture == id_texture->texture);
-
-   id_surface = CALLOC_STRUCT(identity_surface);
-   if(!id_surface)
+   if (!view)
       goto error;
 
-   memcpy(&id_surface->base, surface, sizeof(struct pipe_surface));
+   assert(view->texture == id_resource->resource);
 
-   pipe_reference_init(&id_surface->base.reference, 1);
-   id_surface->base.texture = NULL;
-   pipe_texture_reference(&id_surface->base.texture, &id_texture->base);
-   id_surface->surface = surface;
+   id_view = CALLOC_STRUCT(identity_sampler_view);
 
-   return &id_surface->base;
+   id_view->base = *view;
+   id_view->base.reference.count = 1;
+   id_view->base.texture = NULL;
+   pipe_resource_reference(&id_view->base.texture, id_resource->resource);
+   id_view->base.context = id_context->pipe;
+   id_view->sampler_view = view;
 
+   return &id_view->base;
 error:
-   pipe_surface_reference(&surface, NULL);
    return NULL;
 }
 
 void
-identity_surface_destroy(struct identity_surface *id_surface)
+identity_sampler_view_destroy(struct identity_context *id_context,
+                              struct identity_sampler_view *id_view)
 {
-   pipe_texture_reference(&id_surface->base.texture, NULL);
-   pipe_surface_reference(&id_surface->surface, NULL);
-   FREE(id_surface);
+   pipe_resource_reference(&id_view->base.texture, NULL);
+   id_context->pipe->sampler_view_destroy(id_context->pipe,
+                                          id_view->sampler_view);
+   FREE(id_view);
 }
 
 
 struct pipe_transfer *
 identity_transfer_create(struct identity_context *id_context,
-			 struct identity_texture *id_texture,
+                         struct identity_resource *id_resource,
                          struct pipe_transfer *transfer)
 {
    struct identity_transfer *id_transfer;
@@ -152,7 +158,7 @@ identity_transfer_create(struct identity_context *id_context,
    if(!transfer)
       goto error;
 
-   assert(transfer->texture == id_texture->texture);
+   assert(transfer->resource == id_resource->resource);
 
    id_transfer = CALLOC_STRUCT(identity_transfer);
    if(!id_transfer)
@@ -160,16 +166,16 @@ identity_transfer_create(struct identity_context *id_context,
 
    memcpy(&id_transfer->base, transfer, sizeof(struct pipe_transfer));
 
-   id_transfer->base.texture = NULL;
+   id_transfer->base.resource = NULL;
    id_transfer->transfer = transfer;
 
-   pipe_texture_reference(&id_transfer->base.texture, &id_texture->base);
-   assert(id_transfer->base.texture == &id_texture->base);
+   pipe_resource_reference(&id_transfer->base.resource, &id_resource->base);
+   assert(id_transfer->base.resource == &id_resource->base);
 
    return &id_transfer->base;
 
 error:
-   id_context->pipe->tex_transfer_destroy(id_context->pipe, transfer);
+   id_context->pipe->transfer_destroy(id_context->pipe, transfer);
    return NULL;
 }
 
@@ -177,47 +183,9 @@ void
 identity_transfer_destroy(struct identity_context *id_context,
                           struct identity_transfer *id_transfer)
 {
-   pipe_texture_reference(&id_transfer->base.texture, NULL);
-   id_context->pipe->tex_transfer_destroy(id_context->pipe,
-                                          id_transfer->transfer);
+   pipe_resource_reference(&id_transfer->base.resource, NULL);
+   id_context->pipe->transfer_destroy(id_context->pipe,
+                                      id_transfer->transfer);
    FREE(id_transfer);
 }
 
-struct pipe_video_surface *
-identity_video_surface_create(struct identity_screen *id_screen,
-                              struct pipe_video_surface *video_surface)
-{
-   struct identity_video_surface *id_video_surface;
-
-   if (!video_surface) {
-      goto error;
-   }
-
-   assert(video_surface->screen == id_screen->screen);
-
-   id_video_surface = CALLOC_STRUCT(identity_video_surface);
-   if (!id_video_surface) {
-      goto error;
-   }
-
-   memcpy(&id_video_surface->base,
-          video_surface,
-          sizeof(struct pipe_video_surface));
-
-   pipe_reference_init(&id_video_surface->base.reference, 1);
-   id_video_surface->base.screen = &id_screen->base;
-   id_video_surface->video_surface = video_surface;
-
-   return &id_video_surface->base;
-
-error:
-   pipe_video_surface_reference(&video_surface, NULL);
-   return NULL;
-}
-
-void
-identity_video_surface_destroy(struct identity_video_surface *id_video_surface)
-{
-   pipe_video_surface_reference(&id_video_surface->video_surface, NULL);
-   FREE(id_video_surface);
-}