1 files changed, 124 insertions, 164 deletions

diff --git a/src/gallium/drivers/r300/r300_texture.c b/src/gallium/drivers/r300/r300_texture.c
index 8e5afc5082e..60ea763dfae 100644
--- a/src/gallium/drivers/r300/r300_texture.c
+++ b/src/gallium/drivers/r300/r300_texture.c
@@ -29,6 +29,7 @@
 
 #include "r300_context.h"
 #include "r300_texture.h"
+#include "r300_transfer.h"
 #include "r300_screen.h"
 #include "r300_winsys.h"
 
@@ -513,7 +514,7 @@ boolean r300_is_sampler_format_supported(enum pipe_format format)
 static void r300_setup_texture_state(struct r300_screen* screen, struct r300_texture* tex)
 {
     struct r300_texture_format_state* state = &tex->state;
-    struct pipe_texture *pt = &tex->tex;
+    struct pipe_resource *pt = &tex->b.b;
     unsigned i;
     boolean is_r500 = screen->caps.is_r500;
 
@@ -554,28 +555,28 @@ static void r300_setup_texture_state(struct r300_screen* screen, struct r300_tex
                pt->width0, pt->height0, pt->last_level);
 
     /* Set framebuffer state. */
-    if (util_format_is_depth_or_stencil(tex->tex.format)) {
-        for (i = 0; i <= tex->tex.last_level; i++) {
+    if (util_format_is_depth_or_stencil(tex->b.b.format)) {
+        for (i = 0; i <= tex->b.b.last_level; i++) {
             tex->fb_state.depthpitch[i] =
                 tex->pitch[i] |
                 R300_DEPTHMACROTILE(tex->mip_macrotile[i]) |
                 R300_DEPTHMICROTILE(tex->microtile);
         }
-        tex->fb_state.zb_format = r300_translate_zsformat(tex->tex.format);
+        tex->fb_state.zb_format = r300_translate_zsformat(tex->b.b.format);
     } else {
-        for (i = 0; i <= tex->tex.last_level; i++) {
+        for (i = 0; i <= tex->b.b.last_level; i++) {
             tex->fb_state.colorpitch[i] =
                 tex->pitch[i] |
-                r300_translate_colorformat(tex->tex.format) |
+                r300_translate_colorformat(tex->b.b.format) |
                 R300_COLOR_TILE(tex->mip_macrotile[i]) |
                 R300_COLOR_MICROTILE(tex->microtile);
         }
-        tex->fb_state.us_out_fmt = r300_translate_out_fmt(tex->tex.format);
+        tex->fb_state.us_out_fmt = r300_translate_out_fmt(tex->b.b.format);
     }
 }
 
 void r300_texture_reinterpret_format(struct pipe_screen *screen,
-                                     struct pipe_texture *tex,
+                                     struct pipe_resource *tex,
                                      enum pipe_format new_format)
 {
     struct r300_screen *r300screen = r300_screen(screen);
@@ -593,7 +594,7 @@ unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
 {
     unsigned offset = tex->offset[level];
 
-    switch (tex->tex.target) {
+    switch (tex->b.b.target) {
         case PIPE_TEXTURE_3D:
             assert(face == 0);
             return offset + zslice * tex->layer_size[level];
@@ -617,7 +618,7 @@ static unsigned r300_texture_get_tile_size(struct r300_texture* tex,
 {
     unsigned pixsize, tile_size;
 
-    pixsize = util_format_get_blocksize(tex->tex.format);
+    pixsize = util_format_get_blocksize(tex->b.b.format);
     tile_size = microblock_table[util_logbase2(pixsize)][tex->microtile][dim];
 
     if (macrotile) {
@@ -638,9 +639,9 @@ static boolean r300_texture_macro_switch(struct r300_texture *tex,
 
     tile = r300_texture_get_tile_size(tex, dim, TRUE);
     if (dim == TILE_WIDTH) {
-        texdim = u_minify(tex->tex.width0, level);
+        texdim = u_minify(tex->b.b.width0, level);
     } else {
-        texdim = u_minify(tex->tex.height0, level);
+        texdim = u_minify(tex->b.b.height0, level);
     }
 
     /* See TX_FILTER1_n.MACRO_SWITCH. */
@@ -664,22 +665,22 @@ unsigned r300_texture_get_stride(struct r300_screen* screen,
         return tex->stride_override;
 
     /* Check the level. */
-    if (level > tex->tex.last_level) {
+    if (level > tex->b.b.last_level) {
         SCREEN_DBG(screen, DBG_TEX, "%s: level (%u) > last_level (%u)\n",
-                   __FUNCTION__, level, tex->tex.last_level);
+                   __FUNCTION__, level, tex->b.b.last_level);
         return 0;
     }
 
-    width = u_minify(tex->tex.width0, level);
+    width = u_minify(tex->b.b.width0, level);
 
-    if (r300_format_is_plain(tex->tex.format)) {
+    if (r300_format_is_plain(tex->b.b.format)) {
         tile_width = r300_texture_get_tile_size(tex, TILE_WIDTH,
                                                 tex->mip_macrotile[level]);
         width = align(width, tile_width);
 
-        return util_format_get_stride(tex->tex.format, width);
+        return util_format_get_stride(tex->b.b.format, width);
     } else {
-        return align(util_format_get_stride(tex->tex.format, width), 32);
+        return align(util_format_get_stride(tex->b.b.format, width), 32);
     }
 }
 
@@ -688,9 +689,9 @@ static unsigned r300_texture_get_nblocksy(struct r300_texture* tex,
 {
     unsigned height, tile_height;
 
-    height = u_minify(tex->tex.height0, level);
+    height = u_minify(tex->b.b.height0, level);
 
-    if (r300_format_is_plain(tex->tex.format)) {
+    if (r300_format_is_plain(tex->b.b.format)) {
         tile_height = r300_texture_get_tile_size(tex, TILE_HEIGHT,
                                                  tex->mip_macrotile[level]);
         height = align(height, tile_height);
@@ -699,13 +700,13 @@ static unsigned r300_texture_get_nblocksy(struct r300_texture* tex,
         height = util_next_power_of_two(height);
     }
 
-    return util_format_get_nblocksy(tex->tex.format, height);
+    return util_format_get_nblocksy(tex->b.b.format, height);
 }
 
 static void r300_setup_miptree(struct r300_screen* screen,
                                struct r300_texture* tex)
 {
-    struct pipe_texture* base = &tex->tex;
+    struct pipe_resource* base = &tex->b.b;
     unsigned stride, size, layer_size, nblocksy, i;
     boolean rv350_mode = screen->caps.family >= CHIP_FAMILY_RV350;
 
@@ -744,8 +745,8 @@ static void r300_setup_miptree(struct r300_screen* screen,
 
 static void r300_setup_flags(struct r300_texture* tex)
 {
-    tex->uses_pitch = !util_is_power_of_two(tex->tex.width0) ||
-                      !util_is_power_of_two(tex->tex.height0) ||
+    tex->uses_pitch = !util_is_power_of_two(tex->b.b.width0) ||
+                      !util_is_power_of_two(tex->b.b.height0) ||
                       tex->stride_override;
 }
 
@@ -753,15 +754,15 @@ static void r300_setup_tiling(struct pipe_screen *screen,
                               struct r300_texture *tex)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    enum pipe_format format = tex->tex.format;
+    enum pipe_format format = tex->b.b.format;
     boolean rv350_mode = r300_screen(screen)->caps.family >= CHIP_FAMILY_RV350;
 
     if (!r300_format_is_plain(format)) {
         return;
     }
 
-    if (tex->tex.width0 == 1 ||
-        tex->tex.height0 == 1) {
+    if (tex->b.b.width0 == 1 ||
+        tex->b.b.height0 == 1) {
         return;
     }
 
@@ -787,9 +788,73 @@ static void r300_setup_tiling(struct pipe_screen *screen,
     }
 }
 
+
+static unsigned r300_texture_is_referenced(struct pipe_context *context,
+					 struct pipe_resource *texture,
+					 unsigned face, unsigned level)
+{
+    struct r300_context *r300 = r300_context(context);
+    struct r300_texture *rtex = (struct r300_texture *)texture;
+
+    if (r300->rws->is_buffer_referenced(r300->rws, rtex->buffer))
+        return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+
+    return PIPE_UNREFERENCED;
+}
+
+static void r300_texture_destroy(struct pipe_screen *screen,
+				 struct pipe_resource* texture)
+{
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
+
+    rws->buffer_reference(rws, &tex->buffer, NULL);
+    FREE(tex);
+}
+
+
+
+
+static boolean
+    r300_texture_get_handle(struct pipe_screen* screen,
+                            struct pipe_resource *texture,
+                            struct winsys_handle *whandle)
+{
+    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    unsigned stride;
+
+    if (!tex) {
+        return FALSE;
+    }
+
+    stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
+
+    rws->buffer_get_handle(rws, tex->buffer, stride, whandle);
+
+    return TRUE;
+}
+
+
+
+struct u_resource_vtbl r300_texture_vtbl = 
+{
+   r300_texture_get_handle,	      /* get_handle */
+   r300_texture_destroy,	      /* resource_destroy */
+   r300_texture_is_referenced,	      /* is_resource_referenced */
+   r300_texture_get_transfer,	      /* get_transfer */
+   r300_texture_transfer_destroy,     /* transfer_destroy */
+   r300_texture_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   r300_texture_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
 /* Create a new texture. */
-static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
-                                         const struct pipe_texture* base)
+struct pipe_resource* r300_texture_create(struct pipe_screen* screen,
+                                          const struct pipe_resource* base)
 {
     struct r300_texture* tex = CALLOC_STRUCT(r300_texture);
     struct r300_screen* rscreen = r300_screen(screen);
@@ -799,20 +864,21 @@ static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
         return NULL;
     }
 
-    tex->tex = *base;
-    pipe_reference_init(&tex->tex.reference, 1);
-    tex->tex.screen = screen;
+    tex->b.b = *base;
+    tex->b.vtbl = &r300_texture_vtbl;
+    pipe_reference_init(&tex->b.b.reference, 1);
+    tex->b.b.screen = screen;
 
     r300_setup_flags(tex);
-    if (!(base->tex_usage & R300_TEXTURE_USAGE_TRANSFER) &&
-        !(base->tex_usage & PIPE_TEXTURE_USAGE_SCANOUT)) {
+    if (!(base->flags & R300_RESOURCE_FLAG_TRANSFER) &&
+        !(base->bind & PIPE_BIND_SCANOUT)) {
         r300_setup_tiling(screen, tex);
     }
     r300_setup_miptree(rscreen, tex);
     r300_setup_texture_state(rscreen, tex);
 
     tex->buffer = rws->buffer_create(rws, 2048,
-				     PIPE_BUFFER_USAGE_PIXEL,
+				     PIPE_BIND_SAMPLER_VIEW, /* XXX */
 				     tex->size);
     rws->buffer_set_tiling(rws, tex->buffer,
 			   tex->pitch[0],
@@ -824,24 +890,19 @@ static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
         return NULL;
     }
 
-    return (struct pipe_texture*)tex;
+    return (struct pipe_resource*)tex;
 }
 
-static void r300_texture_destroy(struct pipe_texture* texture)
-{
-    struct r300_texture* tex = r300_texture(texture);
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
 
-    rws->buffer_reference(rws, &tex->buffer, NULL);
-    FREE(tex);
-}
 
-static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
-                                                 struct pipe_texture* texture,
-                                                 unsigned face,
-                                                 unsigned level,
-                                                 unsigned zslice,
-                                                 unsigned flags)
+/* Not required to implement u_resource_vtbl, consider moving to another file:
+ */
+struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
+					  struct pipe_resource* texture,
+					  unsigned face,
+					  unsigned level,
+					  unsigned zslice,
+					  unsigned flags)
 {
     struct r300_texture* tex = r300_texture(texture);
     struct pipe_surface* surface = CALLOC_STRUCT(pipe_surface);
@@ -851,7 +912,7 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
 
     if (surface) {
         pipe_reference_init(&surface->reference, 1);
-        pipe_texture_reference(&surface->texture, texture);
+        pipe_resource_reference(&surface->texture, texture);
         surface->format = texture->format;
         surface->width = u_minify(texture->width0, level);
         surface->height = u_minify(texture->height0, level);
@@ -866,17 +927,18 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
     return surface;
 }
 
-static void r300_tex_surface_destroy(struct pipe_surface* s)
+/* Not required to implement u_resource_vtbl, consider moving to another file:
+ */
+void r300_tex_surface_destroy(struct pipe_surface* s)
 {
-    pipe_texture_reference(&s->texture, NULL);
+    pipe_resource_reference(&s->texture, NULL);
     FREE(s);
 }
 
-
-static struct pipe_texture*
-    r300_texture_from_handle(struct pipe_screen* screen,
-                             const struct pipe_texture* base,
-                             struct winsys_handle *whandle)
+struct pipe_resource*
+r300_texture_from_handle(struct pipe_screen* screen,
+			  const struct pipe_resource* base,
+			  struct winsys_handle *whandle)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen*)screen->winsys;
     struct r300_screen* rscreen = r300_screen(screen);
@@ -902,9 +964,10 @@ static struct pipe_texture*
         return NULL;
     }
 
-    tex->tex = *base;
-    pipe_reference_init(&tex->tex.reference, 1);
-    tex->tex.screen = screen;
+    tex->b.b = *base;
+    tex->b.vtbl = &r300_texture_vtbl;
+    pipe_reference_init(&tex->b.b.reference, 1);
+    tex->b.b.screen = screen;
 
     tex->stride_override = stride;
 
@@ -945,109 +1008,6 @@ static struct pipe_texture*
                                tex->microtile,
                                tex->macrotile);
     }
-    return (struct pipe_texture*)tex;
-}
-
-static boolean
-    r300_texture_get_handle(struct pipe_screen* screen,
-                            struct pipe_texture *texture,
-                            struct winsys_handle *whandle)
-{
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    struct r300_texture* tex = r300_texture(texture);
-    unsigned stride;
-
-    if (!tex) {
-        return FALSE;
-    }
-
-    stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
-
-    rws->buffer_get_handle(rws, tex->buffer, stride, whandle);
-
-    return TRUE;
+    return (struct pipe_resource*)tex;
 }
 
-static struct pipe_video_surface *
-r300_video_surface_create(struct pipe_screen *screen,
-                          enum pipe_video_chroma_format chroma_format,
-                          unsigned width, unsigned height)
-{
-    struct r300_video_surface *r300_vsfc;
-    struct pipe_texture base;
-
-    assert(screen);
-    assert(width && height);
-
-    r300_vsfc = CALLOC_STRUCT(r300_video_surface);
-    if (!r300_vsfc)
-       return NULL;
-
-    pipe_reference_init(&r300_vsfc->base.reference, 1);
-    r300_vsfc->base.screen = screen;
-    r300_vsfc->base.chroma_format = chroma_format;
-    r300_vsfc->base.width = width;
-    r300_vsfc->base.height = height;
-
-    memset(&base, 0, sizeof(struct pipe_texture));
-    base.target = PIPE_TEXTURE_2D;
-    base.format = PIPE_FORMAT_B8G8R8X8_UNORM;
-    base.last_level = 0;
-    base.width0 = util_next_power_of_two(width);
-    base.height0 = util_next_power_of_two(height);
-    base.depth0 = 1;
-    base.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER |
-                     PIPE_TEXTURE_USAGE_RENDER_TARGET;
-
-    r300_vsfc->tex = screen->texture_create(screen, &base);
-    if (!r300_vsfc->tex)
-    {
-        FREE(r300_vsfc);
-        return NULL;
-    }
-
-    return &r300_vsfc->base;
-}
-
-static void r300_video_surface_destroy(struct pipe_video_surface *vsfc)
-{
-    struct r300_video_surface *r300_vsfc = r300_video_surface(vsfc);
-    pipe_texture_reference(&r300_vsfc->tex, NULL);
-    FREE(r300_vsfc);
-}
-
-void r300_init_screen_texture_functions(struct pipe_screen* screen)
-{
-    screen->texture_create = r300_texture_create;
-    screen->texture_from_handle = r300_texture_from_handle;
-    screen->texture_get_handle = r300_texture_get_handle;
-    screen->texture_destroy = r300_texture_destroy;
-    screen->get_tex_surface = r300_get_tex_surface;
-    screen->tex_surface_destroy = r300_tex_surface_destroy;
-
-    screen->video_surface_create = r300_video_surface_create;
-    screen->video_surface_destroy= r300_video_surface_destroy;
-}
-
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture* texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned* stride)
-{
-    struct r300_texture* tex = r300_texture(texture);
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    struct r300_winsys_buffer *buf;
-
-    if (!tex) {
-        return FALSE;
-    }
-
-    rws->buffer_reference(rws, &buf, tex->buffer);
-
-    if (stride) {
-        *stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
-    }
-
-    *buffer = buf;
-    return TRUE;
-}