Merge branch 'width0'
Conflicts: src/gallium/drivers/r300/r300_texture.c src/gallium/state_trackers/xorg/xorg_exa.c src/mesa/state_tracker/st_cb_texture.c
This commit is contained in:
commit
c95cbd45c6
|
@ -398,9 +398,9 @@ aaline_create_texture(struct aaline_stage *aaline)
|
|||
texTemp.target = PIPE_TEXTURE_2D;
|
||||
texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
|
||||
texTemp.last_level = MAX_TEXTURE_LEVEL;
|
||||
texTemp.width[0] = 1 << MAX_TEXTURE_LEVEL;
|
||||
texTemp.height[0] = 1 << MAX_TEXTURE_LEVEL;
|
||||
texTemp.depth[0] = 1;
|
||||
texTemp.width0 = 1 << MAX_TEXTURE_LEVEL;
|
||||
texTemp.height0 = 1 << MAX_TEXTURE_LEVEL;
|
||||
texTemp.depth0 = 1;
|
||||
pf_get_block(texTemp.format, &texTemp.block);
|
||||
|
||||
aaline->texture = screen->texture_create(screen, &texTemp);
|
||||
|
@ -413,11 +413,11 @@ aaline_create_texture(struct aaline_stage *aaline)
|
|||
*/
|
||||
for (level = 0; level <= MAX_TEXTURE_LEVEL; level++) {
|
||||
struct pipe_transfer *transfer;
|
||||
const uint size = aaline->texture->width[level];
|
||||
const uint size = u_minify(aaline->texture->width0, level);
|
||||
ubyte *data;
|
||||
uint i, j;
|
||||
|
||||
assert(aaline->texture->width[level] == aaline->texture->height[level]);
|
||||
assert(aaline->texture->width0 == aaline->texture->height0);
|
||||
|
||||
/* This texture is new, no need to flush.
|
||||
*/
|
||||
|
|
|
@ -427,9 +427,9 @@ pstip_create_texture(struct pstip_stage *pstip)
|
|||
texTemp.target = PIPE_TEXTURE_2D;
|
||||
texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
|
||||
texTemp.last_level = 0;
|
||||
texTemp.width[0] = 32;
|
||||
texTemp.height[0] = 32;
|
||||
texTemp.depth[0] = 1;
|
||||
texTemp.width0 = 32;
|
||||
texTemp.height0 = 32;
|
||||
texTemp.depth0 = 1;
|
||||
pf_get_block(texTemp.format, &texTemp.block);
|
||||
|
||||
pstip->texture = screen->texture_create(screen, &texTemp);
|
||||
|
|
|
@ -354,9 +354,9 @@ util_blit_pixels_writemask(struct blit_state *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);
|
||||
|
@ -389,10 +389,10 @@ util_blit_pixels_writemask(struct blit_state *ctx,
|
|||
}
|
||||
else {
|
||||
pipe_texture_reference(&tex, src->texture);
|
||||
s0 = srcX0 / (float)tex->width[0];
|
||||
s1 = srcX1 / (float)tex->width[0];
|
||||
t0 = srcY0 / (float)tex->height[0];
|
||||
t1 = srcY1 / (float)tex->height[0];
|
||||
s0 = srcX0 / (float)tex->width0;
|
||||
s1 = srcX1 / (float)tex->width0;
|
||||
t0 = srcY0 / (float)tex->height0;
|
||||
t1 = srcY1 / (float)tex->height0;
|
||||
}
|
||||
|
||||
|
||||
|
@ -518,13 +518,13 @@ util_blit_pixels_tex(struct blit_state *ctx,
|
|||
assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
|
||||
filter == PIPE_TEX_MIPFILTER_LINEAR);
|
||||
|
||||
assert(tex->width[0] != 0);
|
||||
assert(tex->height[0] != 0);
|
||||
assert(tex->width0 != 0);
|
||||
assert(tex->height0 != 0);
|
||||
|
||||
s0 = srcX0 / (float)tex->width[0];
|
||||
s1 = srcX1 / (float)tex->width[0];
|
||||
t0 = srcY0 / (float)tex->height[0];
|
||||
t1 = srcY1 / (float)tex->height[0];
|
||||
s0 = srcX0 / (float)tex->width0;
|
||||
s1 = srcX1 / (float)tex->width0;
|
||||
t0 = srcY0 / (float)tex->height0;
|
||||
t1 = srcY1 / (float)tex->height0;
|
||||
|
||||
assert(ctx->pipe->screen->is_format_supported(ctx->pipe->screen, dst->format,
|
||||
PIPE_TEXTURE_2D,
|
||||
|
|
|
@ -45,6 +45,7 @@
|
|||
#include "util/u_draw_quad.h"
|
||||
#include "util/u_gen_mipmap.h"
|
||||
#include "util/u_simple_shaders.h"
|
||||
#include "util/u_math.h"
|
||||
|
||||
#include "cso_cache/cso_context.h"
|
||||
|
||||
|
@ -1125,12 +1126,12 @@ make_1d_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);
|
||||
|
@ -1168,12 +1169,12 @@ make_2d_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);
|
||||
|
@ -1213,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);
|
||||
|
@ -1575,8 +1576,8 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
|
|||
* Setup framebuffer / dest surface
|
||||
*/
|
||||
fb.cbufs[0] = surf;
|
||||
fb.width = pt->width[dstLevel];
|
||||
fb.height = pt->height[dstLevel];
|
||||
fb.width = u_minify(pt->width0, dstLevel);
|
||||
fb.height = u_minify(pt->height0, dstLevel);
|
||||
cso_set_framebuffer(ctx->cso, &fb);
|
||||
|
||||
/*
|
||||
|
@ -1597,8 +1598,8 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
|
|||
offset = set_vertex_data(ctx,
|
||||
pt->target,
|
||||
face,
|
||||
(float) pt->width[dstLevel],
|
||||
(float) pt->height[dstLevel]);
|
||||
(float) u_minify(pt->width0, dstLevel),
|
||||
(float) u_minify(pt->height0, dstLevel));
|
||||
|
||||
util_draw_vertex_buffer(ctx->pipe,
|
||||
ctx->vbuf,
|
||||
|
|
|
@ -530,9 +530,9 @@ align(int value, int alignment)
|
|||
}
|
||||
|
||||
static INLINE unsigned
|
||||
minify(unsigned value)
|
||||
u_minify(unsigned value, unsigned levels)
|
||||
{
|
||||
return MAX2(1, value >> 1);
|
||||
return MAX2(1, value >> levels);
|
||||
}
|
||||
|
||||
#ifndef COPY_4V
|
||||
|
|
|
@ -79,9 +79,9 @@ util_create_rgba_surface(struct pipe_screen *screen,
|
|||
templ.target = target;
|
||||
templ.format = format;
|
||||
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(format, &templ.block);
|
||||
templ.tex_usage = usage;
|
||||
|
||||
|
|
|
@ -455,8 +455,8 @@ void vl_compositor_render(struct vl_compositor *compositor,
|
|||
assert(dst_area);
|
||||
assert(picture_type == PIPE_MPEG12_PICTURE_TYPE_FRAME);
|
||||
|
||||
compositor->fb_state.width = dst_surface->width[0];
|
||||
compositor->fb_state.height = dst_surface->height[0];
|
||||
compositor->fb_state.width = dst_surface->width0;
|
||||
compositor->fb_state.height = dst_surface->height0;
|
||||
compositor->fb_state.cbufs[0] = compositor->pipe->screen->get_tex_surface
|
||||
(
|
||||
compositor->pipe->screen,
|
||||
|
@ -504,12 +504,12 @@ void vl_compositor_render(struct vl_compositor *compositor,
|
|||
vs_consts->dst_trans.z = 0;
|
||||
vs_consts->dst_trans.w = 0;
|
||||
|
||||
vs_consts->src_scale.x = src_area->w / (float)src_surface->width[0];
|
||||
vs_consts->src_scale.y = src_area->h / (float)src_surface->height[0];
|
||||
vs_consts->src_scale.x = src_area->w / (float)src_surface->width0;
|
||||
vs_consts->src_scale.y = src_area->h / (float)src_surface->height0;
|
||||
vs_consts->src_scale.z = 1;
|
||||
vs_consts->src_scale.w = 1;
|
||||
vs_consts->src_trans.x = src_area->x / (float)src_surface->width[0];
|
||||
vs_consts->src_trans.y = src_area->y / (float)src_surface->height[0];
|
||||
vs_consts->src_trans.x = src_area->x / (float)src_surface->width0;
|
||||
vs_consts->src_trans.y = src_area->y / (float)src_surface->height0;
|
||||
vs_consts->src_trans.z = 0;
|
||||
vs_consts->src_trans.w = 0;
|
||||
|
||||
|
|
|
@ -681,7 +681,7 @@ xfer_buffers_map(struct vl_mpeg12_mc_renderer *r)
|
|||
(
|
||||
r->pipe->screen, r->textures.all[i],
|
||||
0, 0, 0, PIPE_TRANSFER_WRITE, 0, 0,
|
||||
r->textures.all[i]->width[0], r->textures.all[i]->height[0]
|
||||
r->textures.all[i]->width0, r->textures.all[i]->height0
|
||||
);
|
||||
|
||||
r->texels[i] = r->pipe->screen->transfer_map(r->pipe->screen, r->tex_transfer[i]);
|
||||
|
@ -835,26 +835,26 @@ init_buffers(struct vl_mpeg12_mc_renderer *r)
|
|||
/* TODO: Accomodate HW that can't do this and also for cases when this isn't precise enough */
|
||||
template.format = PIPE_FORMAT_R16_SNORM;
|
||||
template.last_level = 0;
|
||||
template.width[0] = r->pot_buffers ?
|
||||
template.width0 = r->pot_buffers ?
|
||||
util_next_power_of_two(r->picture_width) : r->picture_width;
|
||||
template.height[0] = r->pot_buffers ?
|
||||
template.height0 = r->pot_buffers ?
|
||||
util_next_power_of_two(r->picture_height) : r->picture_height;
|
||||
template.depth[0] = 1;
|
||||
template.depth0 = 1;
|
||||
pf_get_block(template.format, &template.block);
|
||||
template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER | PIPE_TEXTURE_USAGE_DYNAMIC;
|
||||
|
||||
r->textures.individual.y = r->pipe->screen->texture_create(r->pipe->screen, &template);
|
||||
|
||||
if (r->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420) {
|
||||
template.width[0] = r->pot_buffers ?
|
||||
template.width0 = r->pot_buffers ?
|
||||
util_next_power_of_two(r->picture_width / 2) :
|
||||
r->picture_width / 2;
|
||||
template.height[0] = r->pot_buffers ?
|
||||
template.height0 = r->pot_buffers ?
|
||||
util_next_power_of_two(r->picture_height / 2) :
|
||||
r->picture_height / 2;
|
||||
}
|
||||
else if (r->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_422)
|
||||
template.height[0] = r->pot_buffers ?
|
||||
template.height0 = r->pot_buffers ?
|
||||
util_next_power_of_two(r->picture_height / 2) :
|
||||
r->picture_height / 2;
|
||||
|
||||
|
@ -1283,8 +1283,8 @@ flush(struct vl_mpeg12_mc_renderer *r)
|
|||
PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
|
||||
);
|
||||
|
||||
vs_consts->denorm.x = r->surface->width[0];
|
||||
vs_consts->denorm.y = r->surface->height[0];
|
||||
vs_consts->denorm.x = r->surface->width0;
|
||||
vs_consts->denorm.y = r->surface->height0;
|
||||
|
||||
pipe_buffer_unmap(r->pipe->screen, r->vs_const_buf.buffer);
|
||||
|
||||
|
@ -1633,8 +1633,8 @@ vl_mpeg12_mc_renderer_render_macroblocks(struct vl_mpeg12_mc_renderer
|
|||
renderer->past = past;
|
||||
renderer->future = future;
|
||||
renderer->fence = fence;
|
||||
renderer->surface_tex_inv_size.x = 1.0f / surface->width[0];
|
||||
renderer->surface_tex_inv_size.y = 1.0f / surface->height[0];
|
||||
renderer->surface_tex_inv_size.x = 1.0f / surface->width0;
|
||||
renderer->surface_tex_inv_size.y = 1.0f / surface->height0;
|
||||
}
|
||||
|
||||
while (num_macroblocks) {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -231,7 +231,7 @@ i915_update_texture(struct i915_context *i915,
|
|||
{
|
||||
const struct pipe_texture *pt = &tex->base;
|
||||
uint format, pitch;
|
||||
const uint width = pt->width[0], height = pt->height[0], depth = pt->depth[0];
|
||||
const uint width = pt->width0, height = pt->height0, depth = pt->depth0;
|
||||
const uint num_levels = pt->last_level;
|
||||
unsigned max_lod = num_levels * 4;
|
||||
unsigned tiled = MS3_USE_FENCE_REGS;
|
||||
|
|
|
@ -105,10 +105,6 @@ i915_miptree_set_level_info(struct i915_texture *tex,
|
|||
|
||||
assert(level < PIPE_MAX_TEXTURE_LEVELS);
|
||||
|
||||
pt->width[level] = w;
|
||||
pt->height[level] = h;
|
||||
pt->depth[level] = d;
|
||||
|
||||
pt->nblocksx[level] = pf_get_nblocksx(&pt->block, w);
|
||||
pt->nblocksy[level] = pf_get_nblocksy(&pt->block, h);
|
||||
|
||||
|
@ -168,16 +164,16 @@ i915_scanout_layout(struct i915_texture *tex)
|
|||
return FALSE;
|
||||
|
||||
i915_miptree_set_level_info(tex, 0, 1,
|
||||
tex->base.width[0],
|
||||
tex->base.height[0],
|
||||
tex->base.width0,
|
||||
tex->base.height0,
|
||||
1);
|
||||
i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
|
||||
|
||||
if (tex->base.width[0] >= 240) {
|
||||
if (tex->base.width0 >= 240) {
|
||||
tex->stride = power_of_two(tex->base.nblocksx[0] * pt->block.size);
|
||||
tex->total_nblocksy = round_up(tex->base.nblocksy[0], 8);
|
||||
tex->hw_tiled = INTEL_TILE_X;
|
||||
} else if (tex->base.width[0] == 64 && tex->base.height[0] == 64) {
|
||||
} else if (tex->base.width0 == 64 && tex->base.height0 == 64) {
|
||||
tex->stride = power_of_two(tex->base.nblocksx[0] * pt->block.size);
|
||||
tex->total_nblocksy = round_up(tex->base.nblocksy[0], 8);
|
||||
} else {
|
||||
|
@ -185,7 +181,7 @@ i915_scanout_layout(struct i915_texture *tex)
|
|||
}
|
||||
|
||||
debug_printf("%s size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
|
||||
tex->base.width[0], tex->base.height[0], pt->block.size,
|
||||
tex->base.width0, tex->base.height0, pt->block.size,
|
||||
tex->stride, tex->total_nblocksy, tex->stride * tex->total_nblocksy);
|
||||
|
||||
return TRUE;
|
||||
|
@ -203,12 +199,12 @@ i915_display_target_layout(struct i915_texture *tex)
|
|||
return FALSE;
|
||||
|
||||
/* fallback to normal textures for small textures */
|
||||
if (tex->base.width[0] < 240)
|
||||
if (tex->base.width0 < 240)
|
||||
return FALSE;
|
||||
|
||||
i915_miptree_set_level_info(tex, 0, 1,
|
||||
tex->base.width[0],
|
||||
tex->base.height[0],
|
||||
tex->base.width0,
|
||||
tex->base.height0,
|
||||
1);
|
||||
i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
|
||||
|
||||
|
@ -217,7 +213,7 @@ i915_display_target_layout(struct i915_texture *tex)
|
|||
tex->hw_tiled = INTEL_TILE_X;
|
||||
|
||||
debug_printf("%s size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
|
||||
tex->base.width[0], tex->base.height[0], pt->block.size,
|
||||
tex->base.width0, tex->base.height0, pt->block.size,
|
||||
tex->stride, tex->total_nblocksy, tex->stride * tex->total_nblocksy);
|
||||
|
||||
return TRUE;
|
||||
|
@ -228,8 +224,8 @@ i915_miptree_layout_2d(struct i915_texture *tex)
|
|||
{
|
||||
struct pipe_texture *pt = &tex->base;
|
||||
unsigned level;
|
||||
unsigned width = pt->width[0];
|
||||
unsigned height = pt->height[0];
|
||||
unsigned width = pt->width0;
|
||||
unsigned height = pt->height0;
|
||||
unsigned nblocksx = pt->nblocksx[0];
|
||||
unsigned nblocksy = pt->nblocksy[0];
|
||||
|
||||
|
@ -254,8 +250,8 @@ i915_miptree_layout_2d(struct i915_texture *tex)
|
|||
|
||||
tex->total_nblocksy += nblocksy;
|
||||
|
||||
width = minify(width);
|
||||
height = minify(height);
|
||||
width = u_minify(width, 1);
|
||||
height = u_minify(height, 1);
|
||||
nblocksx = pf_get_nblocksx(&pt->block, width);
|
||||
nblocksy = pf_get_nblocksy(&pt->block, height);
|
||||
}
|
||||
|
@ -267,9 +263,9 @@ i915_miptree_layout_3d(struct i915_texture *tex)
|
|||
struct pipe_texture *pt = &tex->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 nblocksx = pt->nblocksx[0];
|
||||
unsigned nblocksy = pt->nblocksy[0];
|
||||
unsigned stack_nblocksy = 0;
|
||||
|
@ -285,36 +281,34 @@ i915_miptree_layout_3d(struct i915_texture *tex)
|
|||
|
||||
stack_nblocksy += MAX2(2, nblocksy);
|
||||
|
||||
width = minify(width);
|
||||
height = minify(height);
|
||||
depth = minify(depth);
|
||||
width = u_minify(width, 1);
|
||||
height = u_minify(height, 1);
|
||||
nblocksx = pf_get_nblocksx(&pt->block, width);
|
||||
nblocksy = pf_get_nblocksy(&pt->block, height);
|
||||
}
|
||||
|
||||
/* Fixup depth image_offsets:
|
||||
*/
|
||||
depth = pt->depth[0];
|
||||
for (level = 0; level <= pt->last_level; level++) {
|
||||
unsigned i;
|
||||
for (i = 0; i < depth; i++)
|
||||
i915_miptree_set_image_offset(tex, level, i, 0, i * stack_nblocksy);
|
||||
|
||||
depth = minify(depth);
|
||||
depth = u_minify(depth, 1);
|
||||
}
|
||||
|
||||
/* Multiply slice size by texture depth for total size. It's
|
||||
* remarkable how wasteful of memory the i915 texture layouts
|
||||
* are. They are largely fixed in the i945.
|
||||
*/
|
||||
tex->total_nblocksy = stack_nblocksy * pt->depth[0];
|
||||
tex->total_nblocksy = stack_nblocksy * pt->depth0;
|
||||
}
|
||||
|
||||
static void
|
||||
i915_miptree_layout_cube(struct i915_texture *tex)
|
||||
{
|
||||
struct pipe_texture *pt = &tex->base;
|
||||
unsigned width = pt->width[0], height = pt->height[0];
|
||||
unsigned width = pt->width0, height = pt->height0;
|
||||
const unsigned nblocks = pt->nblocksx[0];
|
||||
unsigned level;
|
||||
unsigned face;
|
||||
|
@ -383,8 +377,8 @@ i945_miptree_layout_2d(struct i915_texture *tex)
|
|||
unsigned level;
|
||||
unsigned x = 0;
|
||||
unsigned y = 0;
|
||||
unsigned width = pt->width[0];
|
||||
unsigned height = pt->height[0];
|
||||
unsigned width = pt->width0;
|
||||
unsigned height = pt->height0;
|
||||
unsigned nblocksx = pt->nblocksx[0];
|
||||
unsigned nblocksy = pt->nblocksy[0];
|
||||
|
||||
|
@ -407,8 +401,8 @@ i945_miptree_layout_2d(struct i915_texture *tex)
|
|||
*/
|
||||
if (pt->last_level > 0) {
|
||||
unsigned mip1_nblocksx
|
||||
= align(pf_get_nblocksx(&pt->block, minify(width)), align_x)
|
||||
+ pf_get_nblocksx(&pt->block, minify(minify(width)));
|
||||
= align(pf_get_nblocksx(&pt->block, u_minify(width, 1)), align_x)
|
||||
+ pf_get_nblocksx(&pt->block, u_minify(width, 2));
|
||||
|
||||
if (mip1_nblocksx > nblocksx)
|
||||
tex->stride = mip1_nblocksx * pt->block.size;
|
||||
|
@ -439,8 +433,8 @@ i945_miptree_layout_2d(struct i915_texture *tex)
|
|||
y += nblocksy;
|
||||
}
|
||||
|
||||
width = minify(width);
|
||||
height = minify(height);
|
||||
width = u_minify(width, 1);
|
||||
height = u_minify(height, 1);
|
||||
nblocksx = pf_get_nblocksx(&pt->block, width);
|
||||
nblocksy = pf_get_nblocksy(&pt->block, height);
|
||||
}
|
||||
|
@ -450,9 +444,9 @@ static void
|
|||
i945_miptree_layout_3d(struct i915_texture *tex)
|
||||
{
|
||||
struct pipe_texture *pt = &tex->base;
|
||||
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 nblocksx = pt->nblocksx[0];
|
||||
unsigned nblocksy = pt->nblocksy[0];
|
||||
unsigned pack_x_pitch, pack_x_nr;
|
||||
|
@ -495,9 +489,9 @@ i945_miptree_layout_3d(struct i915_texture *tex)
|
|||
pack_y_pitch >>= 1;
|
||||
}
|
||||
|
||||
width = minify(width);
|
||||
height = minify(height);
|
||||
depth = minify(depth);
|
||||
width = u_minify(width, 1);
|
||||
height = u_minify(height, 1);
|
||||
depth = u_minify(depth, 1);
|
||||
nblocksx = pf_get_nblocksx(&pt->block, width);
|
||||
nblocksy = pf_get_nblocksy(&pt->block, height);
|
||||
}
|
||||
|
@ -511,11 +505,11 @@ i945_miptree_layout_cube(struct i915_texture *tex)
|
|||
|
||||
const unsigned nblocks = pt->nblocksx[0];
|
||||
unsigned face;
|
||||
unsigned width = pt->width[0];
|
||||
unsigned height = pt->height[0];
|
||||
unsigned width = pt->width0;
|
||||
unsigned height = pt->height0;
|
||||
|
||||
/*
|
||||
printf("%s %i, %i\n", __FUNCTION__, pt->width[0], pt->height[0]);
|
||||
printf("%s %i, %i\n", __FUNCTION__, pt->width0, pt->height0);
|
||||
*/
|
||||
|
||||
assert(width == height); /* cubemap images are square */
|
||||
|
@ -651,8 +645,8 @@ i915_texture_create(struct pipe_screen *screen,
|
|||
pipe_reference_init(&tex->base.reference, 1);
|
||||
tex->base.screen = screen;
|
||||
|
||||
tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width[0]);
|
||||
tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
|
||||
tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width0);
|
||||
tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height0);
|
||||
|
||||
if (is->is_i945) {
|
||||
if (!i945_miptree_layout(tex))
|
||||
|
@ -667,7 +661,7 @@ i915_texture_create(struct pipe_screen *screen,
|
|||
|
||||
|
||||
/* for scanouts and cursors, cursors arn't scanouts */
|
||||
if (templat->tex_usage & PIPE_TEXTURE_USAGE_PRIMARY && templat->width[0] != 64)
|
||||
if (templat->tex_usage & PIPE_TEXTURE_USAGE_PRIMARY && templat->width0 != 64)
|
||||
buf_usage = INTEL_NEW_SCANOUT;
|
||||
else
|
||||
buf_usage = INTEL_NEW_TEXTURE;
|
||||
|
@ -710,7 +704,7 @@ i915_texture_blanket(struct pipe_screen * screen,
|
|||
/* Only supports one type */
|
||||
if (base->target != PIPE_TEXTURE_2D ||
|
||||
base->last_level != 0 ||
|
||||
base->depth[0] != 1) {
|
||||
base->depth0 != 1) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -724,7 +718,7 @@ i915_texture_blanket(struct pipe_screen * screen,
|
|||
|
||||
tex->stride = stride[0];
|
||||
|
||||
i915_miptree_set_level_info(tex, 0, 1, base->width[0], base->height[0], 1);
|
||||
i915_miptree_set_level_info(tex, 0, 1, base->width0, base->height0, 1);
|
||||
i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
|
||||
|
||||
pipe_buffer_reference(&tex->buffer, buffer);
|
||||
|
@ -788,8 +782,8 @@ i915_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 = offset;
|
||||
ps->usage = flags;
|
||||
}
|
||||
|
@ -919,7 +913,7 @@ i915_texture_blanket_intel(struct pipe_screen *screen,
|
|||
/* Only supports one type */
|
||||
if (base->target != PIPE_TEXTURE_2D ||
|
||||
base->last_level != 0 ||
|
||||
base->depth[0] != 1) {
|
||||
base->depth0 != 1) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -933,7 +927,7 @@ i915_texture_blanket_intel(struct pipe_screen *screen,
|
|||
|
||||
tex->stride = stride;
|
||||
|
||||
i915_miptree_set_level_info(tex, 0, 1, base->width[0], base->height[0], 1);
|
||||
i915_miptree_set_level_info(tex, 0, 1, base->width0, base->height0, 1);
|
||||
i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
|
||||
|
||||
tex->buffer = buffer;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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
|
||||
;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
state->format1 = r300_translate_texformat(pt->format);
|
||||
|
@ -57,17 +57,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,
|
||||
|
@ -105,7 +105,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)
|
||||
|
@ -115,14 +115,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];
|
||||
|
@ -130,7 +124,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;
|
||||
|
@ -139,15 +133,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. */
|
||||
|
@ -207,8 +201,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;
|
||||
|
@ -236,7 +230,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;
|
||||
}
|
||||
|
@ -286,9 +280,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;
|
||||
|
|
|
@ -521,7 +521,7 @@ compute_lambda_1d(const struct sp_sampler_varient *samp,
|
|||
const struct pipe_sampler_state *sampler = samp->sampler;
|
||||
float dsdx = fabsf(s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT]);
|
||||
float dsdy = fabsf(s[QUAD_TOP_LEFT] - s[QUAD_BOTTOM_LEFT]);
|
||||
float rho = MAX2(dsdx, dsdy) * texture->width[0];
|
||||
float rho = MAX2(dsdx, dsdy) * texture->width0;
|
||||
float lambda;
|
||||
|
||||
lambda = util_fast_log2(rho);
|
||||
|
@ -545,8 +545,8 @@ compute_lambda_2d(const struct sp_sampler_varient *samp,
|
|||
float dsdy = fabsf(s[QUAD_TOP_LEFT] - s[QUAD_BOTTOM_LEFT]);
|
||||
float dtdx = fabsf(t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT]);
|
||||
float dtdy = fabsf(t[QUAD_TOP_LEFT] - t[QUAD_BOTTOM_LEFT]);
|
||||
float maxx = MAX2(dsdx, dsdy) * texture->width[0];
|
||||
float maxy = MAX2(dtdx, dtdy) * texture->height[0];
|
||||
float maxx = MAX2(dsdx, dsdy) * texture->width0;
|
||||
float maxy = MAX2(dtdx, dtdy) * texture->height0;
|
||||
float rho = MAX2(maxx, maxy);
|
||||
float lambda;
|
||||
|
||||
|
@ -573,9 +573,9 @@ compute_lambda_3d(const struct sp_sampler_varient *samp,
|
|||
float dtdy = fabsf(t[QUAD_TOP_LEFT] - t[QUAD_BOTTOM_LEFT]);
|
||||
float dpdx = fabsf(p[QUAD_BOTTOM_RIGHT] - p[QUAD_BOTTOM_LEFT]);
|
||||
float dpdy = fabsf(p[QUAD_TOP_LEFT] - p[QUAD_BOTTOM_LEFT]);
|
||||
float maxx = MAX2(dsdx, dsdy) * texture->width[0];
|
||||
float maxy = MAX2(dtdx, dtdy) * texture->height[0];
|
||||
float maxz = MAX2(dpdx, dpdy) * texture->depth[0];
|
||||
float maxx = MAX2(dsdx, dsdy) * texture->width0;
|
||||
float maxy = MAX2(dtdx, dtdy) * texture->height0;
|
||||
float maxz = MAX2(dpdx, dpdy) * texture->depth0;
|
||||
float rho, lambda;
|
||||
|
||||
rho = MAX2(maxx, maxy);
|
||||
|
@ -644,8 +644,8 @@ get_texel_2d(const struct sp_sampler_varient *samp,
|
|||
const struct pipe_texture *texture = samp->texture;
|
||||
unsigned level = addr.bits.level;
|
||||
|
||||
if (x < 0 || x >= (int) texture->width[level] ||
|
||||
y < 0 || y >= (int) texture->height[level]) {
|
||||
if (x < 0 || x >= (int) u_minify(texture->width0, level) ||
|
||||
y < 0 || y >= (int) u_minify(texture->height0, level)) {
|
||||
return samp->sampler->border_color;
|
||||
}
|
||||
else {
|
||||
|
@ -737,9 +737,9 @@ get_texel_3d(const struct sp_sampler_varient *samp,
|
|||
const struct pipe_texture *texture = samp->texture;
|
||||
unsigned level = addr.bits.level;
|
||||
|
||||
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)) {
|
||||
return samp->sampler->border_color;
|
||||
}
|
||||
else {
|
||||
|
@ -925,7 +925,7 @@ img_filter_1d_nearest(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
width = texture->width[level0];
|
||||
width = u_minify(texture->width0, level0);
|
||||
|
||||
assert(width > 0);
|
||||
|
||||
|
@ -961,8 +961,8 @@ img_filter_2d_nearest(struct tgsi_sampler *tgsi_sampler,
|
|||
|
||||
|
||||
level0 = samp->level;
|
||||
width = texture->width[level0];
|
||||
height = texture->height[level0];
|
||||
width = u_minify(texture->width0, level0);
|
||||
height = u_minify(texture->height0, level0);
|
||||
|
||||
assert(width > 0);
|
||||
assert(height > 0);
|
||||
|
@ -1008,8 +1008,8 @@ img_filter_cube_nearest(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
width = texture->width[level0];
|
||||
height = texture->height[level0];
|
||||
width = u_minify(texture->width0, level0);
|
||||
height = u_minify(texture->height0, level0);
|
||||
|
||||
assert(width > 0);
|
||||
assert(height > 0);
|
||||
|
@ -1046,9 +1046,9 @@ img_filter_3d_nearest(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
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);
|
||||
|
@ -1088,7 +1088,7 @@ img_filter_1d_linear(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
width = texture->width[level0];
|
||||
width = u_minify(texture->width0, level0);
|
||||
|
||||
assert(width > 0);
|
||||
|
||||
|
@ -1127,8 +1127,8 @@ img_filter_2d_linear(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
width = texture->width[level0];
|
||||
height = texture->height[level0];
|
||||
width = u_minify(texture->width0, level0);
|
||||
height = u_minify(texture->height0, level0);
|
||||
|
||||
assert(width > 0);
|
||||
assert(height > 0);
|
||||
|
@ -1174,8 +1174,8 @@ img_filter_cube_linear(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
width = texture->width[level0];
|
||||
height = texture->height[level0];
|
||||
width = u_minify(texture->width0, level0);
|
||||
height = u_minify(texture->height0, level0);
|
||||
|
||||
assert(width > 0);
|
||||
assert(height > 0);
|
||||
|
@ -1221,9 +1221,9 @@ img_filter_3d_linear(struct tgsi_sampler *tgsi_sampler,
|
|||
union tex_tile_address addr;
|
||||
|
||||
level0 = samp->level;
|
||||
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);
|
||||
|
||||
addr.value = 0;
|
||||
addr.bits.level = level0;
|
||||
|
@ -1778,8 +1778,8 @@ sp_sampler_varient_bind_texture( struct sp_sampler_varient *samp,
|
|||
|
||||
samp->texture = texture;
|
||||
samp->cache = tex_cache;
|
||||
samp->xpot = util_unsigned_logbase2( texture->width[0] );
|
||||
samp->ypot = util_unsigned_logbase2( texture->height[0] );
|
||||
samp->xpot = util_unsigned_logbase2( texture->width0 );
|
||||
samp->ypot = util_unsigned_logbase2( texture->height0 );
|
||||
samp->level = CLAMP((int) sampler->min_lod, 0, (int) texture->last_level);
|
||||
}
|
||||
|
||||
|
|
|
@ -35,6 +35,7 @@
|
|||
#include "pipe/p_inlines.h"
|
||||
#include "util/u_memory.h"
|
||||
#include "util/u_tile.h"
|
||||
#include "util/u_math.h"
|
||||
#include "sp_context.h"
|
||||
#include "sp_surface.h"
|
||||
#include "sp_texture.h"
|
||||
|
@ -246,8 +247,8 @@ sp_find_cached_tile_tex(struct softpipe_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);
|
||||
|
||||
|
|
|
@ -52,16 +52,17 @@ softpipe_texture_layout(struct pipe_screen *screen,
|
|||
{
|
||||
struct pipe_texture *pt = &spt->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;
|
||||
|
||||
pt->width0 = width;
|
||||
pt->height0 = height;
|
||||
pt->depth0 = depth;
|
||||
|
||||
for (level = 0; level <= pt->last_level; level++) {
|
||||
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);
|
||||
spt->stride[level] = pt->nblocksx[level]*pt->block.size;
|
||||
|
@ -72,9 +73,9 @@ softpipe_texture_layout(struct pipe_screen *screen,
|
|||
((pt->target == PIPE_TEXTURE_CUBE) ? 6 : depth) *
|
||||
spt->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);
|
||||
}
|
||||
|
||||
spt->buffer = screen->buffer_create(screen, 32,
|
||||
|
@ -96,12 +97,12 @@ softpipe_displaytarget_layout(struct pipe_screen *screen,
|
|||
PIPE_BUFFER_USAGE_GPU_READ_WRITE);
|
||||
unsigned tex_usage = spt->base.tex_usage;
|
||||
|
||||
spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width[0]);
|
||||
spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height[0]);
|
||||
spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width0);
|
||||
spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height0);
|
||||
|
||||
spt->buffer = screen->surface_buffer_create( screen,
|
||||
spt->base.width[0],
|
||||
spt->base.height[0],
|
||||
spt->base.width0,
|
||||
spt->base.height0,
|
||||
spt->base.format,
|
||||
usage,
|
||||
tex_usage,
|
||||
|
@ -126,9 +127,9 @@ softpipe_texture_create(struct pipe_screen *screen,
|
|||
pipe_reference_init(&spt->base.reference, 1);
|
||||
spt->base.screen = screen;
|
||||
|
||||
spt->pot = (util_is_power_of_two(template->width[0]) &&
|
||||
util_is_power_of_two(template->height[0]) &&
|
||||
util_is_power_of_two(template->depth[0]));
|
||||
spt->pot = (util_is_power_of_two(template->width0) &&
|
||||
util_is_power_of_two(template->height0) &&
|
||||
util_is_power_of_two(template->depth0));
|
||||
|
||||
if (spt->base.tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
|
||||
PIPE_TEXTURE_USAGE_PRIMARY)) {
|
||||
|
@ -163,7 +164,7 @@ softpipe_texture_blanket(struct pipe_screen * screen,
|
|||
/* Only supports one type */
|
||||
if (base->target != PIPE_TEXTURE_2D ||
|
||||
base->last_level != 0 ||
|
||||
base->depth[0] != 1) {
|
||||
base->depth0 != 1) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -174,8 +175,8 @@ softpipe_texture_blanket(struct pipe_screen * screen,
|
|||
spt->base = *base;
|
||||
pipe_reference_init(&spt->base.reference, 1);
|
||||
spt->base.screen = screen;
|
||||
spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width[0]);
|
||||
spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height[0]);
|
||||
spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width0);
|
||||
spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height0);
|
||||
spt->stride[0] = stride[0];
|
||||
|
||||
pipe_buffer_reference(&spt->buffer, buffer);
|
||||
|
@ -213,8 +214,8 @@ softpipe_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 = spt->level_offset[level];
|
||||
ps->usage = usage;
|
||||
|
||||
|
@ -434,9 +435,9 @@ softpipe_video_surface_create(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;
|
||||
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;
|
||||
|
||||
|
|
|
@ -83,15 +83,15 @@ void trace_dump_template(const struct pipe_texture *templat)
|
|||
trace_dump_member(format, templat, format);
|
||||
|
||||
trace_dump_member_begin("width");
|
||||
trace_dump_array(uint, templat->width, 1);
|
||||
trace_dump_uint(templat->width0);
|
||||
trace_dump_member_end();
|
||||
|
||||
trace_dump_member_begin("height");
|
||||
trace_dump_array(uint, templat->height, 1);
|
||||
trace_dump_uint(templat->height0);
|
||||
trace_dump_member_end();
|
||||
|
||||
trace_dump_member_begin("depth");
|
||||
trace_dump_array(uint, templat->depth, 1);
|
||||
trace_dump_uint(templat->depth0);
|
||||
trace_dump_member_end();
|
||||
|
||||
trace_dump_member_begin("block");
|
||||
|
|
|
@ -200,9 +200,9 @@ trace_rbug_texture_info(struct trace_rbug *tr_rbug, struct rbug_header *header,
|
|||
t = tr_tex->texture;
|
||||
rbug_send_texture_info_reply(tr_rbug->con, serial,
|
||||
t->target, t->format,
|
||||
t->width, t->last_level + 1,
|
||||
t->height, t->last_level + 1,
|
||||
t->depth, t->last_level + 1,
|
||||
&t->width0, 1,
|
||||
&t->height0, 1,
|
||||
&t->depth0, 1,
|
||||
t->block.width, t->block.height, t->block.size,
|
||||
t->last_level,
|
||||
t->nr_samples,
|
||||
|
|
|
@ -343,9 +343,9 @@ struct pipe_texture
|
|||
enum pipe_texture_target target; /**< PIPE_TEXTURE_x */
|
||||
enum pipe_format format; /**< PIPE_FORMAT_x */
|
||||
|
||||
unsigned width[PIPE_MAX_TEXTURE_LEVELS];
|
||||
unsigned height[PIPE_MAX_TEXTURE_LEVELS];
|
||||
unsigned depth[PIPE_MAX_TEXTURE_LEVELS];
|
||||
unsigned width0;
|
||||
unsigned height0;
|
||||
unsigned depth0;
|
||||
|
||||
struct pipe_format_block block;
|
||||
unsigned nblocksx[PIPE_MAX_TEXTURE_LEVELS]; /**< allocated width in blocks */
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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 */
|
||||
|
|
|
@ -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)) {
|
||||
|
|
|
@ -439,8 +439,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);
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -109,9 +109,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;
|
||||
|
|
|
@ -284,7 +284,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 ((exa->accel || priv->flags) &&
|
||||
(!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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -167,9 +167,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;
|
||||
|
||||
|
@ -183,18 +183,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);
|
||||
}
|
||||
|
||||
|
@ -321,8 +321,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,
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -40,6 +40,7 @@
|
|||
#include "pipe/p_inlines.h"
|
||||
#include "cso_cache/cso_context.h"
|
||||
#include "util/u_rect.h"
|
||||
#include "util/u_math.h"
|
||||
|
||||
|
||||
|
||||
|
@ -64,8 +65,8 @@ update_renderbuffer_surface(struct st_context *st,
|
|||
GLuint level;
|
||||
/* find matching mipmap level size */
|
||||
for (level = 0; level <= texture->last_level; level++) {
|
||||
if (texture->width[level] == rtt_width &&
|
||||
texture->height[level] == rtt_height) {
|
||||
if (u_minify(texture->width0, level) == rtt_width &&
|
||||
u_minify(texture->height0, level) == rtt_height) {
|
||||
|
||||
pipe_surface_reference(&strb->surface, NULL);
|
||||
|
||||
|
|
|
@ -145,7 +145,7 @@ load_color_map_texture(GLcontext *ctx, struct pipe_texture *pt)
|
|||
const GLuint gSize = ctx->PixelMaps.GtoG.Size;
|
||||
const GLuint bSize = ctx->PixelMaps.BtoB.Size;
|
||||
const GLuint aSize = ctx->PixelMaps.AtoA.Size;
|
||||
const uint texSize = pt->width[0];
|
||||
const uint texSize = pt->width0;
|
||||
uint *dest;
|
||||
uint i, j;
|
||||
|
||||
|
|
|
@ -601,8 +601,8 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
|
|||
y1 = y + height * ctx->Pixel.ZoomY;
|
||||
|
||||
draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,
|
||||
(GLfloat) width / pt->width[0],
|
||||
(GLfloat) height / pt->height[0]);
|
||||
(GLfloat) width / pt->width0,
|
||||
(GLfloat) height / pt->height0);
|
||||
|
||||
/* restore state */
|
||||
cso_restore_rasterizer(cso);
|
||||
|
|
|
@ -128,9 +128,9 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
|
|||
template.target = PIPE_TEXTURE_2D;
|
||||
template.format = format;
|
||||
pf_get_block(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.nr_samples = rb->NumSamples;
|
||||
if (pf_is_depth_stencil(format)) {
|
||||
|
@ -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 );
|
||||
|
||||
|
|
|
@ -243,7 +243,7 @@ st_fast_readpixels(GLcontext *ctx, struct st_renderbuffer *strb,
|
|||
GLint row, col, dy, dstStride;
|
||||
|
||||
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
|
||||
y = strb->texture->height[0] - y - height;
|
||||
y = strb->texture->height0 - y - height;
|
||||
}
|
||||
|
||||
trans = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture,
|
||||
|
|
|
@ -406,9 +406,9 @@ compress_with_blit(GLcontext * ctx,
|
|||
templ.target = PIPE_TEXTURE_2D;
|
||||
templ.format = st_mesa_format_to_pipe_format(mesa_format);
|
||||
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;
|
||||
templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
|
||||
src_tex = screen->texture_create(screen, &templ);
|
||||
|
@ -1761,9 +1761,9 @@ st_finalize_texture(GLcontext *ctx,
|
|||
if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
|
||||
stObj->pt->format != fmt ||
|
||||
stObj->pt->last_level < stObj->lastLevel ||
|
||||
stObj->pt->width[0] != firstImage->base.Width2 ||
|
||||
stObj->pt->height[0] != firstImage->base.Height2 ||
|
||||
stObj->pt->depth[0] != firstImage->base.Depth2 ||
|
||||
stObj->pt->width0 != firstImage->base.Width2 ||
|
||||
stObj->pt->height0 != firstImage->base.Height2 ||
|
||||
stObj->pt->depth0 != firstImage->base.Depth2 ||
|
||||
stObj->pt->block.size != blockSize)
|
||||
{
|
||||
pipe_texture_reference(&stObj->pt, NULL);
|
||||
|
|
|
@ -38,6 +38,7 @@
|
|||
#include "pipe/p_defines.h"
|
||||
#include "pipe/p_inlines.h"
|
||||
#include "util/u_gen_mipmap.h"
|
||||
#include "util/u_math.h"
|
||||
|
||||
#include "cso_cache/cso_cache.h"
|
||||
#include "cso_cache/cso_context.h"
|
||||
|
@ -133,14 +134,14 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
|
|||
srcTrans = st_cond_flush_get_tex_transfer(st_context(ctx), 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 = st_cond_flush_get_tex_transfer(st_context(ctx), 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));
|
||||
|
||||
srcData = (ubyte *) screen->transfer_map(screen, srcTrans);
|
||||
dstData = (ubyte *) screen->transfer_map(screen, dstTrans);
|
||||
|
@ -150,10 +151,14 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
|
|||
|
||||
_mesa_generate_mipmap_level(target, datatype, comps,
|
||||
0 /*border*/,
|
||||
pt->width[srcLevel], pt->height[srcLevel], pt->depth[srcLevel],
|
||||
u_minify(pt->width0, srcLevel),
|
||||
u_minify(pt->height0, srcLevel),
|
||||
u_minify(pt->depth0, srcLevel),
|
||||
srcData,
|
||||
srcStride, /* stride in texels */
|
||||
pt->width[dstLevel], pt->height[dstLevel], pt->depth[dstLevel],
|
||||
u_minify(pt->width0, dstLevel),
|
||||
u_minify(pt->height0, dstLevel),
|
||||
u_minify(pt->depth0, dstLevel),
|
||||
dstData,
|
||||
dstStride); /* stride in texels */
|
||||
|
||||
|
@ -232,9 +237,9 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
|
|||
oldTex->target,
|
||||
oldTex->format,
|
||||
lastLevel,
|
||||
oldTex->width[0],
|
||||
oldTex->height[0],
|
||||
oldTex->depth[0],
|
||||
oldTex->width0,
|
||||
oldTex->height0,
|
||||
oldTex->depth0,
|
||||
oldTex->tex_usage);
|
||||
|
||||
/* The texture isn't in a "complete" state yet so set the expected
|
||||
|
@ -269,9 +274,9 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
|
|||
= _mesa_get_tex_image(ctx, texObj, target, srcLevel);
|
||||
struct gl_texture_image *dstImage;
|
||||
struct st_texture_image *stImage;
|
||||
uint dstWidth = pt->width[dstLevel];
|
||||
uint dstHeight = pt->height[dstLevel];
|
||||
uint dstDepth = pt->depth[dstLevel];
|
||||
uint dstWidth = u_minify(pt->width0, dstLevel);
|
||||
uint dstHeight = u_minify(pt->height0, dstLevel);
|
||||
uint dstDepth = u_minify(pt->depth0, dstLevel);
|
||||
uint border = srcImage->Border;
|
||||
|
||||
dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);
|
||||
|
|
|
@ -44,6 +44,7 @@
|
|||
#include "pipe/p_defines.h"
|
||||
#include "pipe/p_inlines.h"
|
||||
#include "util/u_rect.h"
|
||||
#include "util/u_math.h"
|
||||
|
||||
|
||||
#define DBG if(0) printf
|
||||
|
@ -100,9 +101,9 @@ st_texture_create(struct st_context *st,
|
|||
pt.target = target;
|
||||
pt.format = format;
|
||||
pt.last_level = last_level;
|
||||
pt.width[0] = width0;
|
||||
pt.height[0] = height0;
|
||||
pt.depth[0] = depth0;
|
||||
pt.width0 = width0;
|
||||
pt.height0 = height0;
|
||||
pt.depth0 = depth0;
|
||||
pf_get_block(format, &pt.block);
|
||||
pt.tex_usage = usage;
|
||||
|
||||
|
@ -135,9 +136,9 @@ st_texture_match_image(const struct pipe_texture *pt,
|
|||
/* Test if this image's size matches what's expected in the
|
||||
* established texture.
|
||||
*/
|
||||
if (image->Width != pt->width[level] ||
|
||||
image->Height != pt->height[level] ||
|
||||
image->Depth != pt->depth[level])
|
||||
if (image->Width != u_minify(pt->width0, level) ||
|
||||
image->Height != u_minify(pt->height0, level) ||
|
||||
image->Depth != u_minify(pt->depth0, level))
|
||||
return GL_FALSE;
|
||||
|
||||
return GL_TRUE;
|
||||
|
@ -265,7 +266,7 @@ st_texture_image_data(struct st_context *st,
|
|||
{
|
||||
struct pipe_context *pipe = st->pipe;
|
||||
struct pipe_screen *screen = pipe->screen;
|
||||
GLuint depth = dst->depth[level];
|
||||
GLuint depth = u_minify(dst->depth0, level);
|
||||
GLuint i;
|
||||
const GLubyte *srcUB = src;
|
||||
struct pipe_transfer *dst_transfer;
|
||||
|
@ -275,15 +276,16 @@ st_texture_image_data(struct st_context *st,
|
|||
for (i = 0; i < depth; i++) {
|
||||
dst_transfer = st_no_flush_get_tex_transfer(st, dst, face, level, i,
|
||||
PIPE_TRANSFER_WRITE, 0, 0,
|
||||
dst->width[level],
|
||||
dst->height[level]);
|
||||
u_minify(dst->width0, level),
|
||||
u_minify(dst->height0, level));
|
||||
|
||||
st_surface_data(pipe, dst_transfer,
|
||||
0, 0, /* dstx, dsty */
|
||||
srcUB,
|
||||
src_row_stride,
|
||||
0, 0, /* source x, y */
|
||||
dst->width[level], dst->height[level]); /* width, height */
|
||||
u_minify(dst->width0, level),
|
||||
u_minify(dst->height0, level)); /* width, height */
|
||||
|
||||
screen->tex_transfer_destroy(dst_transfer);
|
||||
|
||||
|
@ -301,9 +303,9 @@ st_texture_image_copy(struct pipe_context *pipe,
|
|||
GLuint face)
|
||||
{
|
||||
struct pipe_screen *screen = pipe->screen;
|
||||
GLuint width = dst->width[dstLevel];
|
||||
GLuint height = dst->height[dstLevel];
|
||||
GLuint depth = dst->depth[dstLevel];
|
||||
GLuint width = u_minify(dst->width0, dstLevel);
|
||||
GLuint height = u_minify(dst->height0, dstLevel);
|
||||
GLuint depth = u_minify(dst->depth0, dstLevel);
|
||||
struct pipe_surface *src_surface;
|
||||
struct pipe_surface *dst_surface;
|
||||
GLuint i;
|
||||
|
@ -313,13 +315,13 @@ st_texture_image_copy(struct pipe_context *pipe,
|
|||
|
||||
/* find src texture level of needed size */
|
||||
for (srcLevel = 0; srcLevel <= src->last_level; srcLevel++) {
|
||||
if (src->width[srcLevel] == width &&
|
||||
src->height[srcLevel] == height) {
|
||||
if (u_minify(src->width0, srcLevel) == width &&
|
||||
u_minify(src->height0, srcLevel) == height) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert(src->width[srcLevel] == width);
|
||||
assert(src->height[srcLevel] == height);
|
||||
assert(u_minify(src->width0, srcLevel) == width);
|
||||
assert(u_minify(src->height0, srcLevel) == height);
|
||||
|
||||
#if 0
|
||||
{
|
||||
|
|
Loading…
Reference in New Issue