fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-26 12:50:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallium: fix more statetrackers/drivers for not using texture width/height/depth arrays

Browse source
This commit is contained in:
Roland Scheidegger 2009-11-26 22:49:58 +01:00
parent 683e35f726
commit d509f84543
50 changed files with 360 additions and 373 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/gallium/auxiliary/util/u_gen_mipmap.c
View file

@ -1214,12 +1214,12 @@ make_3d_mipmap(struct gen_mipmap_state *ctx,
srcTrans = screen->get_tex_transfer(screen, pt, face, srcLevel, zslice,
PIPE_TRANSFER_READ, 0, 0,
pt->width[srcLevel],
pt->height[srcLevel]);
u_minify(pt->width0, srcLevel),
u_minify(pt->height0, srcLevel));
dstTrans = screen->get_tex_transfer(screen, pt, face, dstLevel, zslice,
PIPE_TRANSFER_WRITE, 0, 0,
pt->width[dstLevel],
pt->height[dstLevel]);
u_minify(pt->width0, dstLevel),
u_minify(pt->height0, dstLevel));
srcMap = (ubyte *) screen->transfer_map(screen, srcTrans);
dstMap = (ubyte *) screen->transfer_map(screen, dstTrans);

7
src/gallium/drivers/cell/ppu/cell_state_emit.c
View file

@ -27,6 +27,7 @@
#include "pipe/p_inlines.h"
#include "util/u_memory.h"
#include "util/u_math.h"
#include "cell_context.h"
#include "cell_gen_fragment.h"
#include "cell_state.h"
@ -299,9 +300,9 @@ cell_emit_state(struct cell_context *cell)
for (level = 0; level < CELL_MAX_TEXTURE_LEVELS; level++) {
texture->start[level] = (ct->mapped +
ct->level_offset[level]);
texture->width[level] = ct->base.width[level];
texture->height[level] = ct->base.height[level];
texture->depth[level] = ct->base.depth[level];
texture->width[level] = u_minify(ct->base.width0, level);
texture->height[level] = u_minify(ct->base.height0, level);
texture->depth[level] = u_minify(ct->base.depth0, level);
}
texture->target = ct->base.target;
}

27
src/gallium/drivers/cell/ppu/cell_texture.c
View file

@ -49,9 +49,9 @@ cell_texture_layout(struct cell_texture *ct)
{
struct pipe_texture *pt = &ct->base;
unsigned level;
unsigned width = pt->width[0];
unsigned height = pt->height[0];
unsigned depth = pt->depth[0];
unsigned width = pt->width0;
unsigned height = pt->height0;
unsigned depth = pt->depth0;
ct->buffer_size = 0;
@ -65,9 +65,6 @@ cell_texture_layout(struct cell_texture *ct)
w_tile = align(width, TILE_SIZE);
h_tile = align(height, TILE_SIZE);
pt->width[level] = width;
pt->height[level] = height;
pt->depth[level] = depth;
pt->nblocksx[level] = pf_get_nblocksx(&pt->block, w_tile);
pt->nblocksy[level] = pf_get_nblocksy(&pt->block, h_tile);
@ -83,9 +80,9 @@ cell_texture_layout(struct cell_texture *ct)
ct->buffer_size += size;
width = minify(width);
height = minify(height);
depth = minify(depth);
width = u_minify(width, 1);
height = u_minify(height, 1);
depth = u_minify(depth, 1);
}
}
@ -276,8 +273,8 @@ cell_get_tex_surface(struct pipe_screen *screen,
pipe_reference_init(&ps->reference, 1);
pipe_texture_reference(&ps->texture, pt);
ps->format = pt->format;
ps->width = pt->width[level];
ps->height = pt->height[level];
ps->width = u_minify(pt->width0, level);
ps->height = u_minify(pt->height0, level);
ps->offset = ct->level_offset[level];
/* XXX may need to override usage flags (see sp_texture.c) */
ps->usage = usage;
@ -386,8 +383,8 @@ cell_transfer_map(struct pipe_screen *screen, struct pipe_transfer *transfer)
struct pipe_texture *pt = transfer->texture;
struct cell_texture *ct = cell_texture(pt);
const uint level = ctrans->base.level;
const uint texWidth = pt->width[level];
const uint texHeight = pt->height[level];
const uint texWidth = u_minify(pt->width0, level);
const uint texHeight = u_minify(pt->height0, level);
const uint stride = ct->stride[level];
unsigned size;
@ -440,8 +437,8 @@ cell_transfer_unmap(struct pipe_screen *screen,
struct pipe_texture *pt = transfer->texture;
struct cell_texture *ct = cell_texture(pt);
const uint level = ctrans->base.level;
const uint texWidth = pt->width[level];
const uint texHeight = pt->height[level];
const uint texWidth = u_minify(pt->width0, level);
const uint texHeight = u_minify(pt->height0, level);
const uint stride = ct->stride[level];
if (!ct->mapped) {

6
src/gallium/drivers/llvmpipe/lp_bld_sample.c
View file

@ -59,9 +59,9 @@ lp_sampler_static_state(struct lp_sampler_static_state *state,
state->format = texture->format;
state->target = texture->target;
state->pot_width = util_is_pot(texture->width[0]);
state->pot_height = util_is_pot(texture->height[0]);
state->pot_depth = util_is_pot(texture->depth[0]);
state->pot_width = util_is_pot(texture->width0);
state->pot_height = util_is_pot(texture->height0);
state->pot_depth = util_is_pot(texture->depth0);
state->wrap_s = sampler->wrap_s;
state->wrap_t = sampler->wrap_t;

4
src/gallium/drivers/llvmpipe/lp_state_sampler.c
View file

@ -102,8 +102,8 @@ llvmpipe_set_sampler_textures(struct pipe_context *pipe,
if(tex) {
struct llvmpipe_texture *lp_tex = llvmpipe_texture(tex);
struct lp_jit_texture *jit_tex = &llvmpipe->jit_context.textures[i];
jit_tex->width = tex->width[0];
jit_tex->height = tex->height[0];
jit_tex->width = tex->width0;
jit_tex->height = tex->height0;
jit_tex->stride = lp_tex->stride[0];
if(!lp_tex->dt)
jit_tex->data = lp_tex->data;

5
src/gallium/drivers/llvmpipe/lp_tex_cache.c
View file

@ -36,6 +36,7 @@
#include "util/u_memory.h"
#include "util/u_tile.h"
#include "util/u_format.h"
#include "util/u_math.h"
#include "lp_context.h"
#include "lp_surface.h"
#include "lp_texture.h"
@ -270,8 +271,8 @@ lp_find_cached_tex_tile(struct llvmpipe_tex_tile_cache *tc,
addr.bits.level,
addr.bits.z,
PIPE_TRANSFER_READ, 0, 0,
tc->texture->width[addr.bits.level],
tc->texture->height[addr.bits.level]);
u_minify(tc->texture->width0, addr.bits.level),
u_minify(tc->texture->height0, addr.bits.level));
tc->tex_trans_map = screen->transfer_map(screen, tc->tex_trans);

30
src/gallium/drivers/llvmpipe/lp_tex_sample_c.c
View file

@ -544,7 +544,7 @@ compute_lambda(struct tgsi_sampler *tgsi_sampler,
float dsdy = s[QUAD_TOP_LEFT] - s[QUAD_BOTTOM_LEFT];
dsdx = fabsf(dsdx);
dsdy = fabsf(dsdy);
rho = MAX2(dsdx, dsdy) * texture->width[0];
rho = MAX2(dsdx, dsdy) * texture->width0;
}
if (t) {
float dtdx = t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT];
@ -552,7 +552,7 @@ compute_lambda(struct tgsi_sampler *tgsi_sampler,
float max;
dtdx = fabsf(dtdx);
dtdy = fabsf(dtdy);
max = MAX2(dtdx, dtdy) * texture->height[0];
max = MAX2(dtdx, dtdy) * texture->height0;
rho = MAX2(rho, max);
}
if (p) {
@ -561,7 +561,7 @@ compute_lambda(struct tgsi_sampler *tgsi_sampler,
float max;
dpdx = fabsf(dpdx);
dpdy = fabsf(dpdy);
max = MAX2(dpdx, dpdy) * texture->depth[0];
max = MAX2(dpdx, dpdy) * texture->depth0;
rho = MAX2(rho, max);
}
@ -726,9 +726,9 @@ get_texel(const struct tgsi_sampler *tgsi_sampler,
const struct pipe_texture *texture = samp->texture;
const struct pipe_sampler_state *sampler = samp->sampler;
if (x < 0 || x >= (int) texture->width[level] ||
y < 0 || y >= (int) texture->height[level] ||
z < 0 || z >= (int) texture->depth[level]) {
if (x < 0 || x >= (int) u_minify(texture->width0, level) ||
y < 0 || y >= (int) u_minify(texture->height0, level) ||
z < 0 || z >= (int) u_minify(texture->depth0, level)) {
rgba[0][j] = sampler->border_color[0];
rgba[1][j] = sampler->border_color[1];
rgba[2][j] = sampler->border_color[2];
@ -1093,8 +1093,8 @@ lp_get_samples_2d_common(struct tgsi_sampler *tgsi_sampler,
assert(sampler->normalized_coords);
width = texture->width[level0];
height = texture->height[level0];
width = u_minify(texture->width0, level0);
height = u_minify(texture->height0, level0);
assert(width > 0);
@ -1250,9 +1250,9 @@ lp_get_samples_3d(struct tgsi_sampler *tgsi_sampler,
assert(sampler->normalized_coords);
width = texture->width[level0];
height = texture->height[level0];
depth = texture->depth[level0];
width = u_minify(texture->width0, level0);
height = u_minify(texture->height0, level0);
depth = u_minify(texture->depth0, level0);
assert(width > 0);
assert(height > 0);
@ -1394,8 +1394,8 @@ lp_get_samples_rect(struct tgsi_sampler *tgsi_sampler,
/* texture RECTS cannot be mipmapped */
assert(level0 == level1);
width = texture->width[level0];
height = texture->height[level0];
width = u_minify(texture->width0, level0);
height = u_minify(texture->height0, level0);
assert(width > 0);
@ -1513,8 +1513,8 @@ lp_get_samples(struct tgsi_sampler *tgsi_sampler,
/* Do this elsewhere:
*/
samp->xpot = util_unsigned_logbase2( samp->texture->width[0] );
samp->ypot = util_unsigned_logbase2( samp->texture->height[0] );
samp->xpot = util_unsigned_logbase2( samp->texture->width0 );
samp->ypot = util_unsigned_logbase2( samp->texture->height0 );
/* Try to hook in a faster sampler. Ultimately we'll have to
* code-generate these. Luckily most of this looks like it is

31
src/gallium/drivers/llvmpipe/lp_texture.c
View file

@ -57,9 +57,9 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
{
struct pipe_texture *pt = &lpt->base;
unsigned level;
unsigned width = pt->width[0];
unsigned height = pt->height[0];
unsigned depth = pt->depth[0];
unsigned width = pt->width0;
unsigned height = pt->height0;
unsigned depth = pt->depth0;
unsigned buffer_size = 0;
@ -68,9 +68,6 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
for (level = 0; level <= pt->last_level; level++) {
unsigned nblocksx, nblocksy;
pt->width[level] = width;
pt->height[level] = height;
pt->depth[level] = depth;
pt->nblocksx[level] = pf_get_nblocksx(&pt->block, width);
pt->nblocksy[level] = pf_get_nblocksy(&pt->block, height);
@ -87,9 +84,9 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
((pt->target == PIPE_TEXTURE_CUBE) ? 6 : depth) *
lpt->stride[level]);
width = minify(width);
height = minify(height);
depth = minify(depth);
width = u_minify(width, 1);
height = u_minify(height, 1);
depth = u_minify(depth, 1);
}
lpt->data = align_malloc(buffer_size, 16);
@ -104,13 +101,13 @@ llvmpipe_displaytarget_layout(struct llvmpipe_screen *screen,
struct llvmpipe_winsys *winsys = screen->winsys;
pf_get_block(lpt->base.format, &lpt->base.block);
lpt->base.nblocksx[0] = pf_get_nblocksx(&lpt->base.block, lpt->base.width[0]);
lpt->base.nblocksy[0] = pf_get_nblocksy(&lpt->base.block, lpt->base.height[0]);
lpt->base.nblocksx[0] = pf_get_nblocksx(&lpt->base.block, lpt->base.width0);
lpt->base.nblocksy[0] = pf_get_nblocksy(&lpt->base.block, lpt->base.height0);
lpt->dt = winsys->displaytarget_create(winsys,
lpt->base.format,
lpt->base.width[0],
lpt->base.height[0],
lpt->base.width0,
lpt->base.height0,
16,
&lpt->stride[0] );
@ -183,8 +180,8 @@ llvmpipe_texture_blanket(struct pipe_screen * screen,
lpt->base = *base;
pipe_reference_init(&lpt->base.reference, 1);
lpt->base.screen = screen;
lpt->base.nblocksx[0] = pf_get_nblocksx(&lpt->base.block, lpt->base.width[0]);
lpt->base.nblocksy[0] = pf_get_nblocksy(&lpt->base.block, lpt->base.height[0]);
lpt->base.nblocksx[0] = pf_get_nblocksx(&lpt->base.block, lpt->base.width0);
lpt->base.nblocksy[0] = pf_get_nblocksy(&lpt->base.block, lpt->base.height0);
lpt->stride[0] = stride[0];
pipe_buffer_reference(&lpt->buffer, buffer);
@ -229,8 +226,8 @@ llvmpipe_get_tex_surface(struct pipe_screen *screen,
pipe_reference_init(&ps->reference, 1);
pipe_texture_reference(&ps->texture, pt);
ps->format = pt->format;
ps->width = pt->width[level];
ps->height = pt->height[level];
ps->width = u_minify(pt->width0, level);
ps->height = u_minify(pt->height0, level);
ps->offset = lpt->level_offset[level];
ps->usage = usage;

4
src/gallium/drivers/nv04/nv04_fragtex.c
View file

@ -57,8 +57,8 @@ nv04_fragtex_build(struct nv04_context *nv04, int unit)
| NV04_DX5_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CORNER
| nv04_fragtex_format(pt->format)
| ( (pt->last_level + 1) << NV04_DX5_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS_SHIFT )
| ( log2i(pt->width[0]) << NV04_DX5_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U_SHIFT )
| ( log2i(pt->height[0]) << NV04_DX5_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V_SHIFT )
| ( log2i(pt->width0) << NV04_DX5_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U_SHIFT )
| ( log2i(pt->height0) << NV04_DX5_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V_SHIFT )
| NV04_DX5_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_EDGE
| NV04_DX5_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_EDGE
;

19
src/gallium/drivers/nv04/nv04_miptree.c
View file

@ -1,6 +1,7 @@
#include "pipe/p_state.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "nv04_context.h"
#include "nv04_screen.h"
@ -9,31 +10,29 @@ static void
nv04_miptree_layout(struct nv04_miptree *nv04mt)
{
struct pipe_texture *pt = &nv04mt->base;
uint width = pt->width[0], height = pt->height[0];
uint width = pt->width0, height = pt->height0;
uint offset = 0;
int nr_faces, l;
nr_faces = 1;
for (l = 0; l <= pt->last_level; l++) {
pt->width[l] = width;
pt->height[l] = height;
pt->nblocksx[l] = pf_get_nblocksx(&pt->block, width);
pt->nblocksy[l] = pf_get_nblocksy(&pt->block, height);
nv04mt->level[l].pitch = pt->width[0];
nv04mt->level[l].pitch = pt->width0;
nv04mt->level[l].pitch = (nv04mt->level[l].pitch + 63) & ~63;
width = MAX2(1, width >> 1);
height = MAX2(1, height >> 1);
width = u_minify(width, 1);
height = u_minify(height, 1);
}
for (l = 0; l <= pt->last_level; l++) {
nv04mt->level[l].image_offset =
CALLOC(nr_faces, sizeof(unsigned));
offset += nv04mt->level[l].pitch * pt->height[l];
offset += nv04mt->level[l].pitch * u_minify(pt->height0, l);
}
nv04mt->total_size = offset;
@ -75,7 +74,7 @@ nv04_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(nv04_miptree);
@ -120,8 +119,8 @@ nv04_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;

7
src/gallium/drivers/nv04/nv04_transfer.c
View file

@ -2,6 +2,7 @@
#include <pipe/p_defines.h>
#include <pipe/p_inlines.h>
#include <util/u_memory.h>
#include <util/u_math.h>
#include <nouveau/nouveau_winsys.h>
#include "nv04_context.h"
#include "nv04_screen.h"
@ -20,9 +21,9 @@ nv04_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
memset(template, 0, sizeof(struct pipe_texture));
template->target = pt->target;
template->format = pt->format;
template->width[0] = pt->width[level];
template->height[0] = pt->height[level];
template->depth[0] = 1;
template->width0 = u_minify(pt->width0, level);
template->height0 = u_minify(pt->height0, level);
template->depth0 = 1;
template->block = pt->block;
template->nblocksx[0] = pt->nblocksx[level];
template->nblocksy[0] = pt->nblocksx[level];

8
src/gallium/drivers/nv10/nv10_fragtex.c
View file

@ -62,9 +62,9 @@ nv10_fragtex_build(struct nv10_context *nv10, int unit)
txf = tf->format << 8;
txf |= (pt->last_level + 1) << 16;
txf |= log2i(pt->width[0]) << 20;
txf |= log2i(pt->height[0]) << 24;
txf |= log2i(pt->depth[0]) << 28;
txf |= log2i(pt->width0) << 20;
txf |= log2i(pt->height0) << 24;
txf |= log2i(pt->depth0) << 28;
txf |= 8;
switch (pt->target) {
@ -89,7 +89,7 @@ nv10_fragtex_build(struct nv10_context *nv10, int unit)
OUT_RING (0x40000000); /* enable */
OUT_RING (txs);
OUT_RING (ps->filt | 0x2000 /* magic */);
OUT_RING ((pt->width[0] << 16) | pt->height[0]);
OUT_RING ((pt->width0 << 16) | pt->height0);
OUT_RING (ps->bcol);
#endif
}

18
src/gallium/drivers/nv10/nv10_miptree.c
View file

@ -1,6 +1,7 @@
#include "pipe/p_state.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "nv10_context.h"
#include "nv10_screen.h"
@ -10,7 +11,7 @@ nv10_miptree_layout(struct nv10_miptree *nv10mt)
{
struct pipe_texture *pt = &nv10mt->base;
boolean swizzled = FALSE;
uint width = pt->width[0], height = pt->height[0];
uint width = pt->width0, height = pt->height0;
uint offset = 0;
int nr_faces, l, f;
@ -21,8 +22,7 @@ nv10_miptree_layout(struct nv10_miptree *nv10mt)
}
for (l = 0; l <= pt->last_level; l++) {
pt->width[l] = width;
pt->height[l] = height;
pt->nblocksx[l] = pf_get_nblocksx(&pt->block, width);
pt->nblocksy[l] = pf_get_nblocksy(&pt->block, height);
@ -35,15 +35,15 @@ nv10_miptree_layout(struct nv10_miptree *nv10mt)
nv10mt->level[l].image_offset =
CALLOC(nr_faces, sizeof(unsigned));
width = MAX2(1, width >> 1);
height = MAX2(1, height >> 1);
width = u_minify(width, 1);
height = u_minify(height, 1);
}
for (f = 0; f < nr_faces; f++) {
for (l = 0; l <= pt->last_level; l++) {
nv10mt->level[l].image_offset[f] = offset;
offset += nv10mt->level[l].pitch * pt->height[l];
offset += nv10mt->level[l].pitch * u_minify(pt->height0, l);
}
}
@ -58,7 +58,7 @@ nv10_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(nv10_miptree);
@ -133,8 +133,8 @@ nv10_miptree_surface_get(struct pipe_screen *screen, 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;

7
src/gallium/drivers/nv10/nv10_transfer.c
View file

@ -2,6 +2,7 @@
#include <pipe/p_defines.h>
#include <pipe/p_inlines.h>
#include <util/u_memory.h>
#include <util/u_math.h>
#include <nouveau/nouveau_winsys.h>
#include "nv10_context.h"
#include "nv10_screen.h"
@ -20,9 +21,9 @@ nv10_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
memset(template, 0, sizeof(struct pipe_texture));
template->target = pt->target;
template->format = pt->format;
template->width[0] = pt->width[level];
template->height[0] = pt->height[level];
template->depth[0] = 1;
template->width0 = u_minify(pt->width0, level);
template->height0 = u_minify(pt->height0, level);
template->depth0 = 1;
template->block = pt->block;
template->nblocksx[0] = pt->nblocksx[level];
template->nblocksy[0] = pt->nblocksx[level];

8
src/gallium/drivers/nv20/nv20_fragtex.c
View file

@ -62,9 +62,9 @@ nv20_fragtex_build(struct nv20_context *nv20, int unit)
txf = tf->format << 8;
txf |= (pt->last_level + 1) << 16;
txf |= log2i(pt->width[0]) << 20;
txf |= log2i(pt->height[0]) << 24;
txf |= log2i(pt->depth[0]) << 28;
txf |= log2i(pt->width0) << 20;
txf |= log2i(pt->height0) << 24;
txf |= log2i(pt->depth0) << 28;
txf |= 8;
switch (pt->target) {
@ -89,7 +89,7 @@ nv20_fragtex_build(struct nv20_context *nv20, int unit)
OUT_RING (0x40000000); /* enable */
OUT_RING (txs);
OUT_RING (ps->filt | 0x2000 /* magic */);
OUT_RING ((pt->width[0] << 16) | pt->height[0]);
OUT_RING ((pt->width0 << 16) | pt->height0);
OUT_RING (ps->bcol);
#endif
}

31
src/gallium/drivers/nv20/nv20_miptree.c
View file

@ -1,6 +1,7 @@
#include "pipe/p_state.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "nv20_context.h"
#include "nv20_screen.h"
@ -9,7 +10,7 @@ static void
nv20_miptree_layout(struct nv20_miptree *nv20mt)
{
struct pipe_texture *pt = &nv20mt->base;
uint width = pt->width[0], height = pt->height[0];
uint width = pt->width0, height = pt->height0;
uint offset = 0;
int nr_faces, l, f;
uint wide_pitch = pt->tex_usage & (PIPE_TEXTURE_USAGE_SAMPLER |
@ -25,21 +26,19 @@ nv20_miptree_layout(struct nv20_miptree *nv20mt)
}
for (l = 0; l <= pt->last_level; l++) {
pt->width[l] = width;
pt->height[l] = height;
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))
nv20mt->level[l].pitch = align(pt->width[0] * pt->block.size, 64);
nv20mt->level[l].pitch = align(pt->width0 * pt->block.size, 64);
else
nv20mt->level[l].pitch = pt->width[l] * pt->block.size;
nv20mt->level[l].pitch = u_minify(pt->width0, l) * pt->block.size;
nv20mt->level[l].image_offset =
CALLOC(nr_faces, sizeof(unsigned));
width = MAX2(1, width >> 1);
height = MAX2(1, height >> 1);
width = u_minify(width, 1);
height = u_minify(height, 1);
}
for (f = 0; f < nr_faces; f++) {
@ -47,14 +46,14 @@ nv20_miptree_layout(struct nv20_miptree *nv20mt)
nv20mt->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(nv20mt->level[l].pitch * pt->height[l], 64);
u_minify(pt->width0, l + 1) > 1 && u_minify(pt->height0, l + 1) > 1)
offset += align(nv20mt->level[l].pitch * u_minify(pt->height0, l), 64);
else
offset += nv20mt->level[l].pitch * pt->height[l];
offset += nv20mt->level[l].pitch * u_minify(pt->height0, l);
}
nv20mt->level[l].image_offset[f] = offset;
offset += nv20mt->level[l].pitch * pt->height[l];
offset += nv20mt->level[l].pitch * u_minify(pt->height0, l);
}
nv20mt->total_size = offset;
@ -68,7 +67,7 @@ nv20_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(nv20_miptree);
@ -100,8 +99,8 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
mt->base.screen = screen;
/* 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 |
@ -167,8 +166,8 @@ nv20_miptree_surface_get(struct pipe_screen *screen, 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;

7
src/gallium/drivers/nv20/nv20_transfer.c
View file

@ -2,6 +2,7 @@
#include <pipe/p_defines.h>
#include <pipe/p_inlines.h>
#include <util/u_memory.h>
#include <util/u_math.h>
#include <nouveau/nouveau_winsys.h>
#include "nv20_context.h"
#include "nv20_screen.h"
@ -20,9 +21,9 @@ nv20_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
memset(template, 0, sizeof(struct pipe_texture));
template->target = pt->target;
template->format = pt->format;
template->width[0] = pt->width[level];
template->height[0] = pt->height[level];
template->depth[0] = 1;
template->width0 = u_minify(pt->width0, level);
template->height0 = u_minify(pt->height0, level);
template->depth0 = 1;
template->block = pt->block;
template->nblocksx[0] = pt->nblocksx[level];
template->nblocksy[0] = pt->nblocksx[level];

10
src/gallium/drivers/nv30/nv30_fragtex.c
View file

@ -74,9 +74,9 @@ nv30_fragtex_build(struct nv30_context *nv30, int unit)
txf = tf->format;
txf |= ((pt->last_level>0) ? NV34TCL_TX_FORMAT_MIPMAP : 0);
txf |= log2i(pt->width[0]) << NV34TCL_TX_FORMAT_BASE_SIZE_U_SHIFT;
txf |= log2i(pt->height[0]) << NV34TCL_TX_FORMAT_BASE_SIZE_V_SHIFT;
txf |= log2i(pt->depth[0]) << NV34TCL_TX_FORMAT_BASE_SIZE_W_SHIFT;
txf |= log2i(pt->width0) << NV34TCL_TX_FORMAT_BASE_SIZE_U_SHIFT;
txf |= log2i(pt->height0) << NV34TCL_TX_FORMAT_BASE_SIZE_V_SHIFT;
txf |= log2i(pt->depth0) << NV34TCL_TX_FORMAT_BASE_SIZE_W_SHIFT;
txf |= NV34TCL_TX_FORMAT_NO_BORDER | 0x10000;
switch (pt->target) {
@ -115,8 +115,8 @@ nv30_fragtex_build(struct nv30_context *nv30, int unit)
so_data (so, NV34TCL_TX_ENABLE_ENABLE | ps->en);
so_data (so, txs);
so_data (so, ps->filt | 0x2000 /*voodoo*/);
so_data (so, (pt->width[0] << NV34TCL_TX_NPOT_SIZE_W_SHIFT) |
pt->height[0]);
so_data (so, (pt->width0 << NV34TCL_TX_NPOT_SIZE_W_SHIFT) |
pt->height0);
so_data (so, ps->bcol);
return so;

36
src/gallium/drivers/nv30/nv30_miptree.c
View file

@ -1,6 +1,7 @@
#include "pipe/p_state.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "nv30_context.h"
@ -8,7 +9,7 @@ static void
nv30_miptree_layout(struct nv30_miptree *nv30mt)
{
struct pipe_texture *pt = &nv30mt->base;
uint width = pt->width[0], height = pt->height[0], depth = pt->depth[0];
uint width = pt->width0, height = pt->height0, depth = pt->depth0;
uint offset = 0;
int nr_faces, l, f;
uint wide_pitch = pt->tex_usage & (PIPE_TEXTURE_USAGE_SAMPLER |
@ -21,29 +22,26 @@ nv30_miptree_layout(struct nv30_miptree *nv30mt)
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))
nv30mt->level[l].pitch = align(pt->width[0] * pt->block.size, 64);
nv30mt->level[l].pitch = align(pt->width0 * pt->block.size, 64);
else
nv30mt->level[l].pitch = pt->width[l] * pt->block.size;
nv30mt->level[l].pitch = u_minify(pt->width0, l) * pt->block.size;
nv30mt->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);
height = u_minify(height, 1);
depth = u_minify(depth, 1);
}
for (f = 0; f < nr_faces; f++) {
@ -51,14 +49,14 @@ nv30_miptree_layout(struct nv30_miptree *nv30mt)
nv30mt->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(nv30mt->level[l].pitch * pt->height[l], 64);
u_minify(pt->width0, l + 1) > 1 && u_minify(pt->height0, l + 1) > 1)
offset += align(nv30mt->level[l].pitch * u_minify(pt->height0, l), 64);
else
offset += nv30mt->level[l].pitch * pt->height[l];
offset += nv30mt->level[l].pitch * u_minify(pt->height0, l);
}
nv30mt->level[l].image_offset[f] = offset;
offset += nv30mt->level[l].pitch * pt->height[l];
offset += nv30mt->level[l].pitch * u_minify(pt->height0, l);
}
nv30mt->total_size = offset;
@ -79,8 +77,8 @@ nv30_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 |
@ -134,7 +132,7 @@ nv30_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(nv30_miptree);
@ -182,8 +180,8 @@ nv30_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;

7
src/gallium/drivers/nv30/nv30_transfer.c
View file

@ -2,6 +2,7 @@
#include <pipe/p_defines.h>
#include <pipe/p_inlines.h>
#include <util/u_memory.h>
#include <util/u_math.h>
#include <nouveau/nouveau_winsys.h>
#include "nv30_context.h"
#include "nv30_screen.h"
@ -20,9 +21,9 @@ nv30_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
memset(template, 0, sizeof(struct pipe_texture));
template->target = pt->target;
template->format = pt->format;
template->width[0] = pt->width[level];
template->height[0] = pt->height[level];
template->depth[0] = 1;
template->width0 = u_minify(pt->width0, level);
template->height0 = u_minify(pt->height0, level);
template->depth0 = 1;
template->block = pt->block;
template->nblocksx[0] = pt->nblocksx[level];
template->nblocksy[0] = pt->nblocksx[level];

6
src/gallium/drivers/nv40/nv40_fragtex.c
View file

@ -117,11 +117,11 @@ nv40_fragtex_build(struct nv40_context *nv40, int unit)
so_data (so, NV40TCL_TEX_ENABLE_ENABLE | ps->en);
so_data (so, txs);
so_data (so, ps->filt | tf->sign | 0x2000 /*voodoo*/);
so_data (so, (pt->width[0] << NV40TCL_TEX_SIZE0_W_SHIFT) |
pt->height[0]);
so_data (so, (pt->width0 << NV40TCL_TEX_SIZE0_W_SHIFT) |
pt->height0);
so_data (so, ps->bcol);
so_method(so, nv40->screen->curie, NV40TCL_TEX_SIZE1(unit), 1);
so_data (so, (pt->depth[0] << NV40TCL_TEX_SIZE1_DEPTH_SHIFT) | txp);
so_data (so, (pt->depth0 << NV40TCL_TEX_SIZE1_DEPTH_SHIFT) | txp);
return so;
}

36
src/gallium/drivers/nv40/nv40_miptree.c
View file

@ -1,6 +1,7 @@
#include "pipe/p_state.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "nv40_context.h"
@ -8,7 +9,7 @@ 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, height = pt->height0, depth = pt->depth0;
uint offset = 0;
int nr_faces, l, f;
uint wide_pitch = pt->tex_usage & (PIPE_TEXTURE_USAGE_SAMPLER |
@ -21,29 +22,26 @@ 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(pt->width0 * pt->block.size, 64);
else
mt->level[l].pitch = pt->width[l] * pt->block.size;
mt->level[l].pitch = u_minify(pt->width0, l) * pt->block.size;
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);
height = u_minify(height, 1);
depth = u_minify(depth, 1);
}
for (f = 0; f < nr_faces; f++) {
@ -51,14 +49,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 +77,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 |
@ -128,7 +126,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);
@ -176,8 +174,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;

7
src/gallium/drivers/nv40/nv40_transfer.c
View file

@ -2,6 +2,7 @@
#include <pipe/p_defines.h>
#include <pipe/p_inlines.h>
#include <util/u_memory.h>
#include <util/u_math.h>
#include <nouveau/nouveau_winsys.h>
#include "nv40_context.h"
#include "nv40_screen.h"
@ -20,9 +21,9 @@ nv40_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
memset(template, 0, sizeof(struct pipe_texture));
template->target = pt->target;
template->format = pt->format;
template->width[0] = pt->width[level];
template->height[0] = pt->height[level];
template->depth[0] = 1;
template->width0 = u_minify(pt->width0, level);
template->height0 = u_minify(pt->height0, level);
template->depth0 = 1;
template->block = pt->block;
template->nblocksx[0] = pt->nblocksx[level];
template->nblocksy[0] = pt->nblocksx[level];

21
src/gallium/drivers/nv50/nv50_miptree.c
View file

@ -61,8 +61,8 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
struct nouveau_device *dev = nouveau_screen(pscreen)->device;
struct nv50_miptree *mt = CALLOC_STRUCT(nv50_miptree);
struct pipe_texture *pt = &mt->base.base;
unsigned width = tmp->width[0], height = tmp->height[0];
unsigned depth = tmp->depth[0], image_alignment;
unsigned width = tmp->width0, height = tmp->height0;
unsigned depth = tmp->depth0, image_alignment;
uint32_t tile_flags;
int ret, i, l;
@ -92,9 +92,6 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
for (l = 0; l <= pt->last_level; l++) {
struct nv50_miptree_level *lvl = &mt->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);
@ -102,9 +99,9 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
lvl->pitch = align(pt->nblocksx[l] * pt->block.size, 64);
lvl->tile_mode = get_tile_mode(pt->nblocksy[l], depth);
width = MAX2(1, width >> 1);
height = MAX2(1, height >> 1);
depth = MAX2(1, depth >> 1);
width = u_minify(width, 1);
height = u_minify(height, 1);
depth = u_minify(depth, 1);
}
image_alignment = get_tile_height(mt->level[0].tile_mode) * 64;
@ -122,7 +119,7 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
size = lvl->pitch;
size *= align(pt->nblocksy[l], tile_h);
size *= align(pt->depth[l], tile_d);
size *= align(u_minify(pt->depth0, l), tile_d);
lvl->image_offset[i] = mt->total_size;
@ -151,7 +148,7 @@ nv50_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(nv50_miptree);
@ -202,8 +199,8 @@ nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
return NULL;
pipe_texture_reference(&ps->texture, pt);
ps->format = pt->format;
ps->width = pt->width[level];
ps->height = pt->height[level];
ps->width = u_minify(pt->width0, level);
ps->height = u_minify(pt->height0, level);
ps->usage = flags;
pipe_reference_init(&ps->reference, 1);
ps->face = face;

4
src/gallium/drivers/nv50/nv50_tex.c
View file

@ -131,9 +131,9 @@ nv50_tex_construct(struct nv50_context *nv50, struct nouveau_stateobj *so,
NOUVEAU_BO_RD, 0, 0);
so_data (so, mode);
so_data (so, 0x00300000);
so_data (so, mt->base.base.width[0] | (1 << 31));
so_data (so, mt->base.base.width0 | (1 << 31));
so_data (so, (mt->base.base.last_level << 28) |
(mt->base.base.depth[0] << 16) | mt->base.base.height[0]);
(mt->base.base.depth0 << 16) | mt->base.base.height0);
so_data (so, 0x03000000);
so_data (so, mt->base.base.last_level << 4);

11
src/gallium/drivers/nv50/nv50_transfer.c
View file

@ -1,6 +1,7 @@
#include "pipe/p_context.h"
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "nv50_context.h"
@ -156,9 +157,9 @@ nv50_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
tx->base.block = pt->block;
if (!pt->nblocksx[level]) {
tx->base.nblocksx = pf_get_nblocksx(&pt->block,
pt->width[level]);
u_minify(pt->width0, level));
tx->base.nblocksy = pf_get_nblocksy(&pt->block,
pt->height[level]);
u_minify(pt->height0, level));
} else {
tx->base.nblocksx = pt->nblocksx[level];
tx->base.nblocksy = pt->nblocksy[level];
@ -167,9 +168,9 @@ nv50_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
tx->base.usage = usage;
tx->level_pitch = lvl->pitch;
tx->level_width = mt->base.base.width[level];
tx->level_height = mt->base.base.height[level];
tx->level_depth = mt->base.base.depth[level];
tx->level_width = u_minify(mt->base.base.width0, level);
tx->level_height = u_minify(mt->base.base.height0, level);
tx->level_depth = u_minify(mt->base.base.depth0, level);
tx->level_offset = lvl->image_offset[image];
tx->level_tiling = lvl->tile_mode;
tx->level_x = pf_get_nblocksx(&tx->base.block, x);

48
src/gallium/drivers/r300/r300_texture.c
View file

@ -34,8 +34,8 @@ static void r300_setup_texture_state(struct r300_texture* tex, boolean is_r500)
struct r300_texture_state* state = &tex->state;
struct pipe_texture *pt = &tex->tex;
state->format0 = R300_TX_WIDTH((pt->width[0] - 1) & 0x7ff) |
R300_TX_HEIGHT((pt->height[0] - 1) & 0x7ff);
state->format0 = R300_TX_WIDTH((pt->width0 - 1) & 0x7ff) |
R300_TX_HEIGHT((pt->height0 - 1) & 0x7ff);
if (tex->is_npot) {
/* rectangles love this */
@ -43,7 +43,7 @@ static void r300_setup_texture_state(struct r300_texture* tex, boolean is_r500)
state->format2 = (tex->pitch[0] - 1) & 0x1fff;
} else {
/* power of two textures (3D, mipmaps, and no pitch) */
state->format0 |= R300_TX_DEPTH(util_logbase2(pt->depth[0]) & 0xf) |
state->format0 |= R300_TX_DEPTH(util_logbase2(pt->depth0) & 0xf) |
R300_TX_NUM_LEVELS(pt->last_level & 0xf);
}
@ -58,17 +58,17 @@ static void r300_setup_texture_state(struct r300_texture* tex, boolean is_r500)
/* large textures on r500 */
if (is_r500)
{
if (pt->width[0] > 2048) {
if (pt->width0 > 2048) {
state->format2 |= R500_TXWIDTH_BIT11;
}
if (pt->height[0] > 2048) {
if (pt->height0 > 2048) {
state->format2 |= R500_TXHEIGHT_BIT11;
}
}
assert(is_r500 || (pt->width[0] <= 2048 && pt->height[0] <= 2048));
assert(is_r500 || (pt->width0 <= 2048 && pt->height0 <= 2048));
debug_printf("r300: Set texture state (%dx%d, %d levels)\n",
pt->width[0], pt->height[0], pt->last_level);
pt->width0, pt->height0, pt->last_level);
}
unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
@ -106,7 +106,7 @@ unsigned r300_texture_get_stride(struct r300_texture* tex, unsigned level)
return 0;
}
return align(pf_get_stride(&tex->tex.block, tex->tex.width[level]), 32);
return align(pf_get_stride(&tex->tex.block, u_minify(tex->tex.width0, level)), 32);
}
static void r300_setup_miptree(struct r300_texture* tex)
@ -116,14 +116,8 @@ static void r300_setup_miptree(struct r300_texture* tex)
int i;
for (i = 0; i <= base->last_level; i++) {
if (i > 0) {
base->width[i] = minify(base->width[i-1]);
base->height[i] = minify(base->height[i-1]);
base->depth[i] = minify(base->depth[i-1]);
}
base->nblocksx[i] = pf_get_nblocksx(&base->block, base->width[i]);
base->nblocksy[i] = pf_get_nblocksy(&base->block, base->height[i]);
base->nblocksx[i] = pf_get_nblocksx(&base->block, u_minify(base->width0, i));
base->nblocksy[i] = pf_get_nblocksy(&base->block, u_minify(base->height0, i));
stride = r300_texture_get_stride(tex, i);
layer_size = stride * base->nblocksy[i];
@ -131,7 +125,7 @@ static void r300_setup_miptree(struct r300_texture* tex)
if (base->target == PIPE_TEXTURE_CUBE)
size = layer_size * 6;
else
size = layer_size * base->depth[i];
size = layer_size * u_minify(base->depth0, i);
tex->offset[i] = align(tex->size, 32);
tex->size = tex->offset[i] + size;
@ -140,15 +134,15 @@ static void r300_setup_miptree(struct r300_texture* tex)
debug_printf("r300: Texture miptree: Level %d "
"(%dx%dx%d px, pitch %d bytes)\n",
i, base->width[i], base->height[i], base->depth[i],
stride);
i, u_minify(base->width0, i), u_minify(base->height0, i),
u_minify(base->depth0, i), stride);
}
}
static void r300_setup_flags(struct r300_texture* tex)
{
tex->is_npot = !util_is_power_of_two(tex->tex.width[0]) ||
!util_is_power_of_two(tex->tex.height[0]);
tex->is_npot = !util_is_power_of_two(tex->tex.width0) ||
!util_is_power_of_two(tex->tex.height0);
}
/* Create a new texture. */
@ -208,8 +202,8 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
pipe_reference_init(&surface->reference, 1);
pipe_texture_reference(&surface->texture, texture);
surface->format = texture->format;
surface->width = texture->width[level];
surface->height = texture->height[level];
surface->width = u_minify(texture->width0, level);
surface->height = u_minify(texture->height0, level);
surface->offset = offset;
surface->usage = flags;
surface->zslice = zslice;
@ -237,7 +231,7 @@ static struct pipe_texture*
/* Support only 2D textures without mipmaps */
if (base->target != PIPE_TEXTURE_2D ||
base->depth[0] != 1 ||
base->depth0 != 1 ||
base->last_level != 0) {
return NULL;
}
@ -287,9 +281,9 @@ r300_video_surface_create(struct pipe_screen *screen,
template.target = PIPE_TEXTURE_2D;
template.format = PIPE_FORMAT_X8R8G8B8_UNORM;
template.last_level = 0;
template.width[0] = util_next_power_of_two(width);
template.height[0] = util_next_power_of_two(height);
template.depth[0] = 1;
template.width0 = util_next_power_of_two(width);
template.height0 = util_next_power_of_two(height);
template.depth0 = 1;
pf_get_block(template.format, &template.block);
template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER |
PIPE_TEXTURE_USAGE_RENDER_TARGET;

8
src/gallium/state_trackers/dri/dri_drawable.c
View file

@ -46,7 +46,7 @@
#include "util/u_memory.h"
#include "util/u_rect.h"
static struct pipe_surface *
dri_surface_from_handle(struct drm_api *api,
struct pipe_screen *screen,
@ -62,10 +62,10 @@ dri_surface_from_handle(struct drm_api *api,
templat.tex_usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
templat.target = PIPE_TEXTURE_2D;
templat.last_level = 0;
templat.depth[0] = 1;
templat.depth0 = 1;
templat.format = format;
templat.width[0] = width;
templat.height[0] = height;
templat.width0 = width;
templat.height0 = height;
pf_get_block(templat.format, &templat.block);
texture = api->texture_from_shared_handle(api, screen, &templat,

6
src/gallium/state_trackers/egl/egl_surface.c
View file

@ -114,10 +114,10 @@ drm_create_texture(_EGLDisplay *dpy,
templat.tex_usage |= PIPE_TEXTURE_USAGE_PRIMARY;
templat.target = PIPE_TEXTURE_2D;
templat.last_level = 0;
templat.depth[0] = 1;
templat.depth0 = 1;
templat.format = PIPE_FORMAT_A8R8G8B8_UNORM;
templat.width[0] = w;
templat.height[0] = h;
templat.width0 = w;
templat.height0 = h;
pf_get_block(templat.format, &templat.block);
texture = screen->texture_create(dev->screen,

6
src/gallium/state_trackers/python/p_device.i
View file

@ -113,9 +113,9 @@ struct st_device {
memset(&templat, 0, sizeof(templat));
templat.format = format;
pf_get_block(templat.format, &templat.block);
templat.width[0] = width;
templat.height[0] = height;
templat.depth[0] = depth;
templat.width0 = width;
templat.height0 = height;
templat.depth0 = depth;
templat.last_level = last_level;
templat.target = target;
templat.tex_usage = tex_usage;

12
src/gallium/state_trackers/python/p_texture.i
View file

@ -59,15 +59,15 @@
}
unsigned get_width(unsigned level=0) {
return $self->width[level];
return u_minify($self->width0, level);
}
unsigned get_height(unsigned level=0) {
return $self->height[level];
return u_minify($self->height0, level);
}
unsigned get_depth(unsigned level=0) {
return $self->depth[level];
return u_minify($self->depth0, level);
}
unsigned get_nblocksx(unsigned level=0) {
@ -88,7 +88,7 @@
SWIG_exception(SWIG_ValueError, "face out of bounds");
if(level > $self->last_level)
SWIG_exception(SWIG_ValueError, "level out of bounds");
if(zslice >= $self->depth[level])
if(zslice >= u_minify($self->depth0, level))
SWIG_exception(SWIG_ValueError, "zslice out of bounds");
surface = CALLOC_STRUCT(st_surface);
@ -375,13 +375,13 @@ struct st_surface
static unsigned
st_surface_width_get(struct st_surface *surface)
{
return surface->texture->width[surface->level];
return u_minify(surface->texture->width0, surface->level);
}
static unsigned
st_surface_height_get(struct st_surface *surface)
{
return surface->texture->height[surface->level];
return u_minify(surface->texture->height0, surface->level);
}
static unsigned

6
src/gallium/state_trackers/python/retrace/interpreter.py
View file

@ -279,9 +279,9 @@ class Screen(Object):
def texture_create(self, templat):
return self.real.texture_create(
format = templat.format,
width = templat.width[0],
height = templat.height[0],
depth = templat.depth[0],
width = templat.width0,
height = templat.height0,
depth = templat.depth0,
last_level = templat.last_level,
target = templat.target,
tex_usage = templat.tex_usage,

10
src/gallium/state_trackers/python/st_device.c
View file

@ -252,9 +252,9 @@ st_context_create(struct st_device *st_dev)
templat.block.size = 4;
templat.block.width = 1;
templat.block.height = 1;
templat.width[0] = 1;
templat.height[0] = 1;
templat.depth[0] = 1;
templat.width0 = 1;
templat.height0 = 1;
templat.depth0 = 1;
templat.last_level = 0;
st_ctx->default_texture = screen->texture_create( screen, &templat );
@ -264,8 +264,8 @@ st_context_create(struct st_device *st_dev)
0, 0, 0,
PIPE_TRANSFER_WRITE,
0, 0,
st_ctx->default_texture->width[0],
st_ctx->default_texture->height[0]);
st_ctx->default_texture->width0,
st_ctx->default_texture->height0);
if (transfer) {
uint32_t *map;
map = (uint32_t *) screen->transfer_map(screen, transfer);

4
src/gallium/state_trackers/python/st_sample.c
View file

@ -528,8 +528,8 @@ st_sample_surface(struct st_surface *surface, float *rgba)
{
struct pipe_texture *texture = surface->texture;
struct pipe_screen *screen = texture->screen;
unsigned width = texture->width[surface->level];
unsigned height = texture->height[surface->level];
unsigned width = u_minify(texture->width0, surface->level);
unsigned height = u_minify(texture->height0, surface->level);
uint rgba_stride = width * 4;
struct pipe_transfer *transfer;
void *raw;

8
src/gallium/state_trackers/vega/api_filters.c
View file

@ -68,9 +68,9 @@ static INLINE struct pipe_texture *create_texture_1d(struct vg_context *ctx,
templ.target = PIPE_TEXTURE_1D;
templ.format = PIPE_FORMAT_A8R8G8B8_UNORM;
templ.last_level = 0;
templ.width[0] = color_data_len;
templ.height[0] = 1;
templ.depth[0] = 1;
templ.width0 = color_data_len;
templ.height0 = 1;
templ.depth0 = 1;
pf_get_block(PIPE_FORMAT_A8R8G8B8_UNORM, &templ.block);
templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
@ -81,7 +81,7 @@ static INLINE struct pipe_texture *create_texture_1d(struct vg_context *ctx,
screen->get_tex_transfer(screen, tex,
0, 0, 0,
PIPE_TRANSFER_READ_WRITE ,
0, 0, tex->width[0], tex->height[0]);
0, 0, tex->width0, tex->height0);
void *map = screen->transfer_map(screen, transfer);
memcpy(map, color_data, sizeof(VGint)*color_data_len);
screen->transfer_unmap(screen, transfer);

16
src/gallium/state_trackers/vega/image.c
View file

@ -93,8 +93,8 @@ static void vg_copy_texture(struct vg_context *ctx,
dst_loc[3] = height;
dst_bounds[0] = 0.f;
dst_bounds[1] = 0.f;
dst_bounds[2] = dst->width[0];
dst_bounds[3] = dst->height[0];
dst_bounds[2] = dst->width0;
dst_bounds[3] = dst->height0;
src_loc[0] = sx;
src_loc[1] = sy;
@ -102,8 +102,8 @@ static void vg_copy_texture(struct vg_context *ctx,
src_loc[3] = height;
src_bounds[0] = 0.f;
src_bounds[1] = 0.f;
src_bounds[2] = src->width[0];
src_bounds[3] = src->height[0];
src_bounds[2] = src->width0;
src_bounds[3] = src->height0;
vg_bound_rect(src_loc, src_bounds, src_shift);
vg_bound_rect(dst_loc, dst_bounds, dst_shift);
@ -272,9 +272,9 @@ struct vg_image * image_create(VGImageFormat format,
pt.format = pformat;
pf_get_block(pformat, &pt.block);
pt.last_level = 0;
pt.width[0] = width;
pt.height[0] = height;
pt.depth[0] = 1;
pt.width0 = width;
pt.height0 = height;
pt.depth0 = 1;
pt.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
newtex = screen->texture_create(screen, &pt);
@ -414,7 +414,7 @@ void image_sub_data(struct vg_image *image,
{ /* upload color_data */
struct pipe_transfer *transfer = screen->get_tex_transfer(
screen, texture, 0, 0, 0,
PIPE_TRANSFER_WRITE, 0, 0, texture->width[0], texture->height[0]);
PIPE_TRANSFER_WRITE, 0, 0, texture->width0, texture->height0);
src += (dataStride * yoffset);
for (i = 0; i < height; i++) {
_vega_unpack_float_span_rgba(ctx, width, xoffset, src, dataFormat, temp);

12
src/gallium/state_trackers/vega/mask.c
View file

@ -426,7 +426,7 @@ static void mask_using_texture(struct pipe_texture *texture,
if (!surface)
return;
if (!intersect_rectangles(surface->width, surface->height,
texture->width[0], texture->height[0],
texture->width0, texture->height0,
x, y, width, height,
offsets, loc))
return;
@ -493,9 +493,9 @@ struct vg_mask_layer * mask_layer_create(VGint width, VGint height)
pt.format = PIPE_FORMAT_A8R8G8B8_UNORM;
pf_get_block(PIPE_FORMAT_A8R8G8B8_UNORM, &pt.block);
pt.last_level = 0;
pt.width[0] = width;
pt.height[0] = height;
pt.depth[0] = 1;
pt.width0 = width;
pt.height0 = height;
pt.depth0 = 1;
pt.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
pt.compressed = 0;
@ -607,8 +607,8 @@ void mask_render_to(struct path *path,
struct vg_mask_layer *temp_layer;
VGint width, height;
width = fb_buffers->alpha_mask->width[0];
height = fb_buffers->alpha_mask->width[0];
width = fb_buffers->alpha_mask->width0;
height = fb_buffers->alpha_mask->width0;
temp_layer = mask_layer_create(width, height);

10
src/gallium/state_trackers/vega/paint.c
View file

@ -151,9 +151,9 @@ static INLINE struct pipe_texture *create_gradient_texture(struct vg_paint *p)
templ.target = PIPE_TEXTURE_1D;
templ.format = PIPE_FORMAT_A8R8G8B8_UNORM;
templ.last_level = 0;
templ.width[0] = 1024;
templ.height[0] = 1;
templ.depth[0] = 1;
templ.width0 = 1024;
templ.height0 = 1;
templ.depth0 = 1;
pf_get_block(PIPE_FORMAT_A8R8G8B8_UNORM, &templ.block);
templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
@ -328,8 +328,8 @@ static INLINE void paint_pattern_buffer(struct vg_paint *paint, void *buffer)
map[4] = 0.f;
map[5] = 1.f;
map[6] = paint->pattern.texture->width[0];
map[7] = paint->pattern.texture->height[0];
map[6] = paint->pattern.texture->width0;
map[7] = paint->pattern.texture->height0;
{
struct matrix mat;
memcpy(&mat, &ctx->state.vg.fill_paint_to_user_matrix,

46
src/gallium/state_trackers/vega/renderer.c
View file

@ -230,13 +230,13 @@ void renderer_draw_texture(struct renderer *r,
struct pipe_buffer *buf;
VGfloat s0, t0, s1, t1;
assert(tex->width[0] != 0);
assert(tex->height[0] != 0);
assert(tex->width0 != 0);
assert(tex->height0 != 0);
s0 = x1offset / tex->width[0];
s1 = x2offset / tex->width[0];
t0 = y1offset / tex->height[0];
t1 = y2offset / tex->height[0];
s0 = x1offset / tex->width0;
s1 = x2offset / tex->width0;
t0 = y1offset / tex->height0;
t1 = y2offset / tex->height0;
cso_save_vertex_shader(r->cso);
/* shaders */
@ -276,10 +276,10 @@ void renderer_copy_texture(struct renderer *ctx,
struct pipe_framebuffer_state fb;
float s0, t0, s1, t1;
assert(src->width[0] != 0);
assert(src->height[0] != 0);
assert(dst->width[0] != 0);
assert(dst->height[0] != 0);
assert(src->width0 != 0);
assert(src->height0 != 0);
assert(dst->width0 != 0);
assert(dst->height0 != 0);
#if 0
debug_printf("copy texture [%f, %f, %f, %f], [%f, %f, %f, %f]\n",
@ -287,10 +287,10 @@ void renderer_copy_texture(struct renderer *ctx,
#endif
#if 1
s0 = sx1 / src->width[0];
s1 = sx2 / src->width[0];
t0 = sy1 / src->height[0];
t1 = sy2 / src->height[0];
s0 = sx1 / src->width0;
s1 = sx2 / src->width0;
t0 = sy1 / src->height0;
t1 = sy2 / src->height0;
#else
s0 = 0;
s1 = 1;
@ -445,9 +445,9 @@ void renderer_copy_surface(struct renderer *ctx,
texTemp.target = PIPE_TEXTURE_2D;
texTemp.format = src->format;
texTemp.last_level = 0;
texTemp.width[0] = srcW;
texTemp.height[0] = srcH;
texTemp.depth[0] = 1;
texTemp.width0 = srcW;
texTemp.height0 = srcH;
texTemp.depth0 = 1;
pf_get_block(src->format, &texTemp.block);
tex = screen->texture_create(screen, &texTemp);
@ -570,13 +570,13 @@ void renderer_texture_quad(struct renderer *r,
struct pipe_buffer *buf;
VGfloat s0, t0, s1, t1;
assert(tex->width[0] != 0);
assert(tex->height[0] != 0);
assert(tex->width0 != 0);
assert(tex->height0 != 0);
s0 = x1offset / tex->width[0];
s1 = x2offset / tex->width[0];
t0 = y1offset / tex->height[0];
t1 = y2offset / tex->height[0];
s0 = x1offset / tex->width0;
s1 = x2offset / tex->width0;
t0 = y1offset / tex->height0;
t1 = y2offset / tex->height0;
cso_save_vertex_shader(r->cso);
/* shaders */

6
src/gallium/state_trackers/vega/vg_tracker.c
View file

@ -51,9 +51,9 @@ create_texture(struct pipe_context *pipe, enum pipe_format format,
templ.target = PIPE_TEXTURE_2D;
pf_get_block(templ.format, &templ.block);
templ.width[0] = width;
templ.height[0] = height;
templ.depth[0] = 1;
templ.width0 = width;
templ.height0 = height;
templ.depth0 = 1;
templ.last_level = 0;
if (pf_get_component_bits(format, PIPE_FORMAT_COMP_S)) {

4
src/gallium/state_trackers/xorg/xorg_composite.c
View file

@ -436,8 +436,8 @@ setup_fs_constant_buffer(struct exa_context *exa)
static void
setup_constant_buffers(struct exa_context *exa, struct exa_pixmap_priv *pDst)
{
int width = pDst->tex->width[0];
int height = pDst->tex->height[0];
int width = pDst->tex->width0;
int height = pDst->tex->height0;
setup_vs_constant_buffer(exa, width, height);
setup_fs_constant_buffer(exa);

6
src/gallium/state_trackers/xorg/xorg_crtc.c
View file

@ -187,10 +187,10 @@ crtc_load_cursor_argb(xf86CrtcPtr crtc, CARD32 * image)
templat.tex_usage |= PIPE_TEXTURE_USAGE_PRIMARY;
templat.target = PIPE_TEXTURE_2D;
templat.last_level = 0;
templat.depth[0] = 1;
templat.depth0 = 1;
templat.format = PIPE_FORMAT_A8R8G8B8_UNORM;
templat.width[0] = 64;
templat.height[0] = 64;
templat.width0 = 64;
templat.height0 = 64;
pf_get_block(templat.format, &templat.block);
crtcp->cursor_tex = ms->screen->texture_create(ms->screen,

6
src/gallium/state_trackers/xorg/xorg_dri2.c
View file

@ -103,9 +103,9 @@ driDoCreateBuffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int format)
template.format = ms->ds_depth_bits_last ?
PIPE_FORMAT_S8Z24_UNORM : PIPE_FORMAT_Z24S8_UNORM;
pf_get_block(template.format, &template.block);
template.width[0] = pDraw->width;
template.height[0] = pDraw->height;
template.depth[0] = 1;
template.width0 = pDraw->width;
template.height0 = pDraw->height;
template.depth0 = 1;
template.last_level = 0;
template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL |
PIPE_TEXTURE_USAGE_DISPLAY_TARGET;

30
src/gallium/state_trackers/xorg/xorg_exa.c
View file

@ -288,7 +288,7 @@ ExaPrepareAccess(PixmapPtr pPix, int index)
PIPE_TRANSFER_MAP_DIRECTLY |
#endif
PIPE_TRANSFER_READ_WRITE,
0, 0, priv->tex->width[0], priv->tex->height[0]);
0, 0, priv->tex->width0, priv->tex->height0);
if (!priv->map_transfer)
#ifdef EXA_MIXED_PIXMAPS
return FALSE;
@ -752,8 +752,8 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
/* Deal with screen resize */
if (!priv->tex ||
(priv->tex->width[0] != width ||
priv->tex->height[0] != height ||
(priv->tex->width0 != width ||
priv->tex->height0 != height ||
priv->tex_flags != priv->flags)) {
struct pipe_texture *texture = NULL;
struct pipe_texture template;
@ -762,9 +762,9 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
template.target = PIPE_TEXTURE_2D;
exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &priv->picture_format);
pf_get_block(template.format, &template.block);
template.width[0] = width;
template.height[0] = height;
template.depth[0] = 1;
template.width0 = width;
template.height0 = height;
template.depth0 = 1;
template.last_level = 0;
template.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET | priv->flags;
priv->tex_flags = priv->flags;
@ -779,12 +779,12 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
src_surf = xorg_gpu_surface(exa->pipe->screen, priv);
if (exa->pipe->surface_copy) {
exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf,
0, 0, min(width, texture->width[0]),
min(height, texture->height[0]));
0, 0, min(width, texture->width0),
min(height, texture->height0));
} else {
util_surface_copy(exa->pipe, FALSE, dst_surf, 0, 0, src_surf,
0, 0, min(width, texture->width[0]),
min(height, texture->height[0]));
0, 0, min(width, texture->width0),
min(height, texture->height0));
}
exa->scrn->tex_surface_destroy(dst_surf);
exa->scrn->tex_surface_destroy(src_surf);
@ -817,8 +817,8 @@ xorg_exa_set_texture(PixmapPtr pPixmap, struct pipe_texture *tex)
if (!priv)
return FALSE;
if (pPixmap->drawable.width != tex->width[0] ||
pPixmap->drawable.height != tex->height[0])
if (pPixmap->drawable.width != tex->width0 ||
pPixmap->drawable.height != tex->height0)
return FALSE;
pipe_texture_reference(&priv->tex, tex);
@ -841,9 +841,9 @@ xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
template.target = PIPE_TEXTURE_2D;
exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &dummy);
pf_get_block(template.format, &template.block);
template.width[0] = width;
template.height[0] = height;
template.depth[0] = 1;
template.width0 = width;
template.height0 = height;
template.depth0 = 1;
template.last_level = 0;
template.tex_usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
template.tex_usage |= PIPE_TEXTURE_USAGE_PRIMARY;

82
src/gallium/state_trackers/xorg/xorg_renderer.c
View file

@ -167,14 +167,14 @@ add_vertex_data1(struct xorg_renderer *r,
map_point(src_matrix, pt3[0], pt3[1], &pt3[0], &pt3[1]);
}
s0 = pt0[0] / src->width[0];
s1 = pt1[0] / src->width[0];
s2 = pt2[0] / src->width[0];
s3 = pt3[0] / src->width[0];
t0 = pt0[1] / src->height[0];
t1 = pt1[1] / src->height[0];
t2 = pt2[1] / src->height[0];
t3 = pt3[1] / src->height[0];
s0 = pt0[0] / src->width0;
s1 = pt1[0] / src->width0;
s2 = pt2[0] / src->width0;
s3 = pt3[0] / src->width0;
t0 = pt0[1] / src->height0;
t1 = pt1[1] / src->height0;
t2 = pt2[1] / src->height0;
t3 = pt3[1] / src->height0;
/* 1st vertex */
add_vertex_1tex(r, dstX, dstY, s0, t0);
@ -262,15 +262,15 @@ add_vertex_data2(struct xorg_renderer *r,
map_point(mask_matrix, mpt1[0], mpt1[1], &mpt1[0], &mpt1[1]);
}
src_s0 = spt0[0] / src->width[0];
src_t0 = spt0[1] / src->height[0];
src_s1 = spt1[0] / src->width[0];
src_t1 = spt1[1] / src->height[0];
src_s0 = spt0[0] / src->width0;
src_t0 = spt0[1] / src->height0;
src_s1 = spt1[0] / src->width0;
src_t1 = spt1[1] / src->height0;
mask_s0 = mpt0[0] / mask->width[0];
mask_t0 = mpt0[1] / mask->height[0];
mask_s1 = mpt1[0] / mask->width[0];
mask_t1 = mpt1[1] / mask->height[0];
mask_s0 = mpt0[0] / mask->width0;
mask_t0 = mpt0[1] / mask->height0;
mask_s1 = mpt1[0] / mask->width0;
mask_t1 = mpt1[1] / mask->height0;
/* 1st vertex */
add_vertex_2tex(r, dstX, dstY,
@ -300,10 +300,10 @@ setup_vertex_data_yuv(struct xorg_renderer *r,
spt1[0] = srcX + srcW;
spt1[1] = srcY + srcH;
s0 = spt0[0] / tex[0]->width[0];
t0 = spt0[1] / tex[0]->height[0];
s1 = spt1[0] / tex[0]->width[0];
t1 = spt1[1] / tex[0]->height[0];
s0 = spt0[0] / tex[0]->width0;
t0 = spt0[1] / tex[0]->height0;
s1 = spt1[0] / tex[0]->width0;
t1 = spt1[1] / tex[0]->height0;
/* 1st vertex */
add_vertex_1tex(r, dstX, dstY, s0, t0);
@ -387,8 +387,8 @@ void renderer_bind_framebuffer(struct xorg_renderer *r,
struct pipe_surface *surface = xorg_gpu_surface(r->pipe->screen, priv);
memset(&state, 0, sizeof(struct pipe_framebuffer_state));
state.width = priv->tex->width[0];
state.height = priv->tex->height[0];
state.width = priv->tex->width0;
state.height = priv->tex->height0;
state.nr_cbufs = 1;
state.cbufs[0] = surface;
@ -407,8 +407,8 @@ void renderer_bind_framebuffer(struct xorg_renderer *r,
void renderer_bind_viewport(struct xorg_renderer *r,
struct exa_pixmap_priv *dst)
{
int width = dst->tex->width[0];
int height = dst->tex->height[0];
int width = dst->tex->width0;
int height = dst->tex->height0;
/*debug_printf("Bind viewport (%d, %d)\n", width, height);*/
@ -584,16 +584,16 @@ static void renderer_copy_texture(struct xorg_renderer *r,
float s0, t0, s1, t1;
struct xorg_shader shader;
assert(src->width[0] != 0);
assert(src->height[0] != 0);
assert(dst->width[0] != 0);
assert(dst->height[0] != 0);
assert(src->width0 != 0);
assert(src->height0 != 0);
assert(dst->width0 != 0);
assert(dst->height0 != 0);
#if 1
s0 = sx1 / src->width[0];
s1 = sx2 / src->width[0];
t0 = sy1 / src->height[0];
t1 = sy2 / src->height[0];
s0 = sx1 / src->width0;
s1 = sx2 / src->width0;
t0 = sy1 / src->height0;
t1 = sy2 / src->height0;
#else
s0 = 0;
s1 = 1;
@ -730,9 +730,9 @@ create_sampler_texture(struct xorg_renderer *r,
templ.target = PIPE_TEXTURE_2D;
templ.format = format;
templ.last_level = 0;
templ.width[0] = src->width[0];
templ.height[0] = src->height[0];
templ.depth[0] = 1;
templ.width0 = src->width0;
templ.height0 = src->height0;
templ.depth0 = 1;
pf_get_block(format, &templ.block);
templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
@ -754,13 +754,13 @@ create_sampler_texture(struct xorg_renderer *r,
ps_tex, /* dest */
0, 0, /* destx/y */
ps_read,
0, 0, src->width[0], src->height[0]);
0, 0, src->width0, src->height0);
} else {
util_surface_copy(pipe, FALSE,
ps_tex, /* dest */
0, 0, /* destx/y */
ps_read,
0, 0, src->width[0], src->height[0]);
0, 0, src->width0, src->height0);
}
pipe_surface_reference(&ps_read, NULL);
pipe_surface_reference(&ps_tex, NULL);
@ -791,8 +791,8 @@ void renderer_copy_pixmap(struct xorg_renderer *r,
dst_loc[3] = height;
dst_bounds[0] = 0.f;
dst_bounds[1] = 0.f;
dst_bounds[2] = dst->width[0];
dst_bounds[3] = dst->height[0];
dst_bounds[2] = dst->width0;
dst_bounds[3] = dst->height0;
src_loc[0] = sx;
src_loc[1] = sy;
@ -800,8 +800,8 @@ void renderer_copy_pixmap(struct xorg_renderer *r,
src_loc[3] = height;
src_bounds[0] = 0.f;
src_bounds[1] = 0.f;
src_bounds[2] = src->width[0];
src_bounds[3] = src->height[0];
src_bounds[2] = src->width0;
src_bounds[3] = src->height0;
bound_rect(src_loc, src_bounds, src_shift);
bound_rect(dst_loc, dst_bounds, dst_shift);

22
src/gallium/state_trackers/xorg/xorg_xv.c
View file

@ -166,9 +166,9 @@ create_component_texture(struct pipe_context *pipe,
templ.target = PIPE_TEXTURE_2D;
templ.format = PIPE_FORMAT_L8_UNORM;
templ.last_level = 0;
templ.width[0] = width;
templ.height[0] = height;
templ.depth[0] = 1;
templ.width0 = width;
templ.height0 = height;
templ.depth0 = 1;
pf_get_block(PIPE_FORMAT_L8_UNORM, &templ.block);
templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
@ -182,18 +182,18 @@ check_yuv_textures(struct xorg_xv_port_priv *priv, int width, int height)
{
struct pipe_texture **dst = priv->yuv[priv->current_set];
if (!dst[0] ||
dst[0]->width[0] != width ||
dst[0]->height[0] != height) {
dst[0]->width0 != width ||
dst[0]->height0 != height) {
pipe_texture_reference(&dst[0], NULL);
}
if (!dst[1] ||
dst[1]->width[0] != width ||
dst[1]->height[0] != height) {
dst[1]->width0 != width ||
dst[1]->height0 != height) {
pipe_texture_reference(&dst[1], NULL);
}
if (!dst[2] ||
dst[2]->width[0] != width ||
dst[2]->height[0] != height) {
dst[2]->width0 != width ||
dst[2]->height0 != height) {
pipe_texture_reference(&dst[2], NULL);
}
@ -320,8 +320,8 @@ copy_packed_data(ScrnInfoPtr pScrn,
static void
setup_vs_video_constants(struct xorg_renderer *r, struct exa_pixmap_priv *dst)
{
int width = dst->tex->width[0];
int height = dst->tex->height[0];
int width = dst->tex->width0;
int height = dst->tex->height0;
const int param_bytes = 8 * sizeof(float);
float vs_consts[8] = {
2.f/width, 2.f/height, 1, 1,

6
src/gallium/state_trackers/xorg/xvmc/surface.c
View file

@ -103,9 +103,9 @@ CreateOrResizeBackBuffer(struct pipe_video_context *vpipe, unsigned int width, u
/* XXX: Needs to match the drawable's format? */
template.format = PIPE_FORMAT_X8R8G8B8_UNORM;
template.last_level = 0;
template.width[0] = width;
template.height[0] = height;
template.depth[0] = 1;
template.width0 = width;
template.height0 = height;
template.depth0 = 1;
pf_get_block(template.format, &template.block);
template.tex_usage = PIPE_TEXTURE_USAGE_DISPLAY_TARGET;

6
src/gallium/winsys/drm/nouveau/drm/nouveau_drm_api.c
View file

@ -24,10 +24,10 @@ dri_surface_from_handle(struct drm_api *api, struct pipe_screen *pscreen,
tmpl.tex_usage = PIPE_TEXTURE_USAGE_PRIMARY;
tmpl.target = PIPE_TEXTURE_2D;
tmpl.last_level = 0;
tmpl.depth[0] = 1;
tmpl.depth0 = 1;
tmpl.format = format;
tmpl.width[0] = width;
tmpl.height[0] = height;
tmpl.width0 = width;
tmpl.height0 = height;
pf_get_block(tmpl.format, &tmpl.block);
pt = api->texture_from_shared_handle(api, pscreen, &tmpl,

6
src/gallium/winsys/drm/radeon/core/radeon_buffer.c
View file

@ -317,9 +317,9 @@ struct pipe_surface *radeon_surface_from_handle(struct radeon_context *radeon_co
memset(&tmpl, 0, sizeof(tmpl));
tmpl.tex_usage = PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
tmpl.target = PIPE_TEXTURE_2D;
tmpl.width[0] = w;
tmpl.height[0] = h;
tmpl.depth[0] = 1;
tmpl.width0 = w;
tmpl.height0 = h;
tmpl.depth0 = 1;
tmpl.format = format;
pf_get_block(tmpl.format, &tmpl.block);
tmpl.nblocksx[0] = pf_get_nblocksx(&tmpl.block, w);

2
src/mesa/state_tracker/st_cb_fbo.c
View file

@ -376,7 +376,7 @@ st_render_texture(GLcontext *ctx,
rb->_BaseFormat = texImage->_BaseFormat;
/*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/
/*printf("***** pipe texture %d x %d\n", pt->width[0], pt->height[0]);*/
/*printf("***** pipe texture %d x %d\n", pt->width0, pt->height0);*/
pipe_texture_reference( &strb->texture, pt );