Merge branch 'master' into pipe-video

[mesa.git] / src / gallium / drivers / nv40 / nv40_miptree.c

diff --git a/src/gallium/drivers/nv40/nv40_miptree.c b/src/gallium/drivers/nv40/nv40_miptree.c
index 3e7420077448a4646e60d68995e10b2ec4be44ba..0c14024dab206cb71da06f40305d2f91d7c1ce01 100644 (file)
--- a/src/gallium/drivers/nv40/nv40_miptree.c
+++ b/src/gallium/drivers/nv40/nv40_miptree.c
@@ -1,14 +1,17 @@
 #include "pipe/p_state.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
+#include "util/u_math.h"
 
 #include "nv40_context.h"
 
+
+
 static void
 nv40_miptree_layout(struct nv40_miptree *mt)
 {
        struct pipe_texture *pt = &mt->base;
-       uint width = pt->width[0], height = pt->height[0], depth = pt->depth[0];
+       uint width = pt->width0;
        uint offset = 0;
        int nr_faces, l, f;
        uint wide_pitch = pt->tex_usage & (PIPE_TEXTURE_USAGE_SAMPLER |
@@ -21,29 +24,21 @@ nv40_miptree_layout(struct nv40_miptree *mt)
                nr_faces = 6;
        } else
        if (pt->target == PIPE_TEXTURE_3D) {
-               nr_faces = pt->depth[0];
+               nr_faces = pt->depth0;
        } else {
                nr_faces = 1;
        }
 
        for (l = 0; l <= pt->last_level; l++) {
-               pt->width[l] = width;
-               pt->height[l] = height;
-               pt->depth[l] = depth;
-               pt->nblocksx[l] = pf_get_nblocksx(&pt->block, width);
-               pt->nblocksy[l] = pf_get_nblocksy(&pt->block, height);
-
                if (wide_pitch && (pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR))
-                       mt->level[l].pitch = align(pt->width[0] * pt->block.size, 64);
+                       mt->level[l].pitch = align(pf_get_stride(pt->format, pt->width0), 64);
                else
-                       mt->level[l].pitch = pt->width[l] * pt->block.size;
+                       mt->level[l].pitch = pf_get_stride(pt->format, width);
 
                mt->level[l].image_offset =
                        CALLOC(nr_faces, sizeof(unsigned));
 
-               width  = MAX2(1, width  >> 1);
-               height = MAX2(1, height >> 1);
-               depth  = MAX2(1, depth  >> 1);
+               width  = u_minify(width, 1);
        }
 
        for (f = 0; f < nr_faces; f++) {
@@ -51,14 +46,14 @@ nv40_miptree_layout(struct nv40_miptree *mt)
                        mt->level[l].image_offset[f] = offset;
 
                        if (!(pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR) &&
-                           pt->width[l + 1] > 1 && pt->height[l + 1] > 1)
-                               offset += align(mt->level[l].pitch * pt->height[l], 64);
+                           u_minify(pt->width0, l + 1) > 1 && u_minify(pt->height0, l + 1) > 1)
+                               offset += align(mt->level[l].pitch * u_minify(pt->height0, l), 64);
                        else
-                               offset += mt->level[l].pitch * pt->height[l];
+                               offset += mt->level[l].pitch * u_minify(pt->height0, l);
                }
 
                mt->level[l].image_offset[f] = offset;
-               offset += mt->level[l].pitch * pt->height[l];
+               offset += mt->level[l].pitch * u_minify(pt->height0, l);
        }
 
        mt->total_size = offset;
@@ -79,8 +74,8 @@ nv40_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
        mt->base.screen = pscreen;
 
        /* Swizzled textures must be POT */
-       if (pt->width[0] & (pt->width[0] - 1) ||
-           pt->height[0] & (pt->height[0] - 1))
+       if (pt->width0 & (pt->width0 - 1) ||
+           pt->height0 & (pt->height0 - 1))
                mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
        else
        if (pt->tex_usage & (PIPE_TEXTURE_USAGE_PRIMARY |
@@ -116,7 +111,7 @@ nv40_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
                FREE(mt);
                return NULL;
        }
-
+       mt->bo = nouveau_bo(mt->buffer);
        return &mt->base;
 }
 
@@ -128,7 +123,7 @@ nv40_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 
        /* Only supports 2D, non-mipmapped textures for the moment */
        if (pt->target != PIPE_TEXTURE_2D || pt->last_level != 0 ||
-           pt->depth[0] != 1)
+           pt->depth0 != 1)
                return NULL;
 
        mt = CALLOC_STRUCT(nv40_miptree);
@@ -145,6 +140,7 @@ nv40_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
        mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 
        pipe_buffer_reference(&mt->buffer, pb);
+       mt->bo = nouveau_bo(mt->buffer);
        return &mt->base;
 }
 
@@ -176,8 +172,8 @@ nv40_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
                return NULL;
        pipe_texture_reference(&ns->base.texture, pt);
        ns->base.format = pt->format;
-       ns->base.width = pt->width[level];
-       ns->base.height = pt->height[level];
+       ns->base.width = u_minify(pt->width0, level);
+       ns->base.height = u_minify(pt->height0, level);
        ns->base.usage = flags;
        pipe_reference_init(&ns->base.reference, 1);
        ns->base.face = face;
@@ -231,10 +227,9 @@ nv40_video_surface_new(struct pipe_screen *screen,
    template.format = PIPE_FORMAT_X8R8G8B8_UNORM;
    template.last_level = 0;
    /* vl_mpeg12_mc_renderer expects this when it's initialized with pot_buffers=true */
-   template.width[0] = util_next_power_of_two(width);
-   template.height[0] = util_next_power_of_two(height);
-   template.depth[0] = 1;
-   pf_get_block(template.format, &template.block);
+   template.width0 = util_next_power_of_two(width);
+   template.height0 = util_next_power_of_two(height);
+   template.depth0 = 1;
    template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER | PIPE_TEXTURE_USAGE_RENDER_TARGET;
 
    nv40_vsfc->tex = screen->texture_create(screen, &template);