static void r300_set_sampler_textures(struct pipe_context* pipe,
unsigned count,
struct pipe_texture** texture)
{
struct r300_context* r300 = r300_context(pipe);
int i;
/* XXX magic num */
if (count > 8) {
return;
}
r300->context.flush(&r300->context, 0, NULL);
for (i = 0; i < count; i++) {
if (r300->textures[i] != (struct r300_texture*)texture[i]) {
pipe_texture_reference((struct pipe_texture**)&r300->textures[i],
texture[i]);
r300->dirty_state |= (R300_NEW_TEXTURE << i);
}
}
for (i = count; i < 8; i++) {
if (r300->textures[i]) {
pipe_texture_reference((struct pipe_texture**)&r300->textures[i],
NULL);
r300->dirty_state |= (R300_NEW_TEXTURE << i);
}
}
r300->texture_count = count;
}
void
st_context_destroy(struct st_context *st_ctx)
{
unsigned i;
if(st_ctx) {
struct st_device *st_dev = st_ctx->st_dev;
if(st_ctx->cso) {
cso_delete_vertex_shader(st_ctx->cso, st_ctx->vs);
cso_delete_fragment_shader(st_ctx->cso, st_ctx->fs);
cso_destroy_context(st_ctx->cso);
}
if(st_ctx->pipe)
st_ctx->pipe->destroy(st_ctx->pipe);
for(i = 0; i < PIPE_MAX_SAMPLERS; ++i)
pipe_texture_reference(&st_ctx->sampler_textures[i], NULL);
pipe_texture_reference(&st_ctx->default_texture, NULL);
FREE(st_ctx);
st_device_reference(&st_dev, NULL);
}
}
/** Undo surface-to-texture binding */
int
st_release_teximage(struct st_framebuffer *stfb, uint surfIndex,
int target, int format, int level)
{
GET_CURRENT_CONTEXT(ctx);
struct st_context *st = ctx->st;
struct st_renderbuffer *strb;
assert(surfIndex <= ST_SURFACE_DEPTH);
strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
if (!strb->texture_save || !strb->surface_save) {
/* Error! */
return 0;
}
st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
/* free tex surface, restore original */
pipe_surface_reference(&strb->surface, strb->surface_save);
pipe_texture_reference(&strb->texture, strb->texture_save);
pipe_surface_reference(&strb->surface_save, NULL);
pipe_texture_reference(&strb->texture_save, NULL);
st->dirty.st |= ST_NEW_FRAMEBUFFER;
return 1;
}
static void llvmpipe_destroy( struct pipe_context *pipe )
{
struct llvmpipe_context *llvmpipe = llvmpipe_context( pipe );
uint i;
lp_print_counters();
/* This will also destroy llvmpipe->setup:
*/
if (llvmpipe->draw)
draw_destroy( llvmpipe->draw );
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
pipe_surface_reference(&llvmpipe->framebuffer.cbufs[i], NULL);
}
pipe_surface_reference(&llvmpipe->framebuffer.zsbuf, NULL);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&llvmpipe->texture[i], NULL);
}
for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
pipe_texture_reference(&llvmpipe->vertex_textures[i], NULL);
}
for (i = 0; i < Elements(llvmpipe->constants); i++) {
if (llvmpipe->constants[i]) {
pipe_buffer_reference(&llvmpipe->constants[i], NULL);
}
}
align_free( llvmpipe );
}
static void i915_set_sampler_textures(struct pipe_context *pipe,
unsigned num,
struct pipe_texture **texture)
{
struct i915_context *i915 = i915_context(pipe);
uint i;
assert(num <= PIPE_MAX_SAMPLERS);
/* Check for no-op */
if (num == i915->num_textures &&
!memcmp(i915->texture, texture, num * sizeof(struct pipe_texture *)))
return;
/* Fixes wrong texture in texobj with VBUF */
draw_flush(i915->draw);
for (i = 0; i < num; i++)
pipe_texture_reference((struct pipe_texture **) &i915->texture[i],
texture[i]);
for (i = num; i < i915->num_textures; i++)
pipe_texture_reference((struct pipe_texture **) &i915->texture[i],
NULL);
i915->num_textures = num;
i915->dirty |= I915_NEW_TEXTURE;
}
/** Redirect rendering into stfb's surface to a texture image */
int
st_bind_teximage(struct st_framebuffer *stfb, uint surfIndex,
int target, int format, int level)
{
GET_CURRENT_CONTEXT(ctx);
struct st_context *st = ctx->st;
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
const GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
struct st_texture_image *stImage;
struct st_renderbuffer *strb;
GLint face = 0, slice = 0;
assert(surfIndex <= ST_SURFACE_DEPTH);
strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
if (strb->texture_save || strb->surface_save) {
/* Error! */
return 0;
}
if (target == ST_TEXTURE_2D) {
texObj = texUnit->CurrentTex[TEXTURE_2D_INDEX];
texImage = _mesa_get_tex_image(ctx, texObj, GL_TEXTURE_2D, level);
stImage = st_texture_image(texImage);
}
else {
/* unsupported target */
return 0;
}
st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
/* save the renderbuffer's surface/texture info */
pipe_texture_reference(&strb->texture_save, strb->texture);
pipe_surface_reference(&strb->surface_save, strb->surface);
/* plug in new surface/texture info */
pipe_texture_reference(&strb->texture, stImage->pt);
strb->surface = screen->get_tex_surface(screen, strb->texture,
face, level, slice,
(PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_GPU_WRITE));
st->dirty.st |= ST_NEW_FRAMEBUFFER;
return 1;
}
static INLINE void
nv50_set_sampler_texture(struct pipe_context *pipe, unsigned type,
unsigned nr, struct pipe_texture **pt)
{
struct nv50_context *nv50 = nv50_context(pipe);
unsigned i;
for (i = 0; i < nr; i++)
pipe_texture_reference((void *)&nv50->miptree[type][i], pt[i]);
for (i = nr; i < nv50->miptree_nr[type]; i++)
pipe_texture_reference((void *)&nv50->miptree[type][i], NULL);
nv50->miptree_nr[type] = nr;
nv50->dirty |= NV50_NEW_TEXTURE;
}
void
llvmpipe_set_vertex_sampler_textures(struct pipe_context *pipe,
unsigned num_textures,
struct pipe_texture **textures)
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
uint i;
assert(num_textures <= PIPE_MAX_VERTEX_SAMPLERS);
/* Check for no-op */
if (num_textures == llvmpipe->num_vertex_textures &&
!memcmp(llvmpipe->vertex_textures, textures, num_textures * sizeof(struct pipe_texture *))) {
return;
}
draw_flush(llvmpipe->draw);
for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
struct pipe_texture *tex = i < num_textures ? textures[i] : NULL;
pipe_texture_reference(&llvmpipe->vertex_textures[i], tex);
}
llvmpipe->num_vertex_textures = num_textures;
llvmpipe->dirty |= LP_NEW_TEXTURE;
}
static struct pipe_surface *
dri_surface_from_handle(struct drm_api *api, struct pipe_screen *pscreen,
unsigned handle, enum pipe_format format,
unsigned width, unsigned height, unsigned pitch)
{
struct pipe_surface *ps = NULL;
struct pipe_texture *pt = NULL;
struct pipe_texture tmpl;
memset(&tmpl, 0, sizeof(tmpl));
tmpl.tex_usage = PIPE_TEXTURE_USAGE_PRIMARY;
tmpl.target = PIPE_TEXTURE_2D;
tmpl.last_level = 0;
tmpl.depth[0] = 1;
tmpl.format = format;
tmpl.width[0] = width;
tmpl.height[0] = height;
pf_get_block(tmpl.format, &tmpl.block);
pt = api->texture_from_shared_handle(api, pscreen, &tmpl,
"front buffer", pitch, handle);
if (!pt)
return NULL;
ps = pscreen->get_tex_surface(pscreen, pt, 0, 0, 0,
PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_GPU_WRITE);
/* we don't need the texture from this point on */
pipe_texture_reference(&pt, NULL);
return ps;
}
void st_set_framebuffer_surface(struct st_framebuffer *stfb,
uint surfIndex, struct pipe_surface *surf)
{
struct st_renderbuffer *rb = stfb->strb;
/* unreference existing surfaces */
pipe_surface_reference( &rb->surface, NULL );
pipe_texture_reference( &rb->texture, NULL );
/* reference new ones */
pipe_surface_reference( &rb->surface, surf );
pipe_texture_reference( &rb->texture, surf->texture );
rb->width = surf->width;
rb->height = surf->height;
}
void
softpipe_set_sampler_textures(struct pipe_context *pipe,
unsigned num, struct pipe_texture **texture)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
uint i;
assert(num <= PIPE_MAX_SAMPLERS);
/* Check for no-op */
if (num == softpipe->num_textures &&
!memcmp(softpipe->texture, texture, num * sizeof(struct pipe_texture *)))
return;
draw_flush(softpipe->draw);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
struct pipe_texture *tex = i < num ? texture[i] : NULL;
pipe_texture_reference(&softpipe->texture[i], tex);
sp_tex_tile_cache_set_texture(softpipe->tex_cache[i], tex);
}
softpipe->num_textures = num;
softpipe->dirty |= SP_NEW_TEXTURE;
}
struct pipe_transfer *
trace_transfer_create(struct trace_texture *tr_tex,
struct pipe_transfer *transfer)
{
struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
struct trace_transfer *tr_trans;
if(!transfer)
goto error;
assert(transfer->texture == tr_tex->texture);
tr_trans = CALLOC_STRUCT(trace_transfer);
if(!tr_trans)
goto error;
memcpy(&tr_trans->base, transfer, sizeof(struct pipe_transfer));
tr_trans->base.texture = NULL;
pipe_texture_reference(&tr_trans->base.texture, &tr_tex->base);
tr_trans->transfer = transfer;
assert(tr_trans->base.texture == &tr_tex->base);
trace_screen_add_to_list(tr_scr, transfers, tr_trans);
return &tr_trans->base;
error:
transfer->texture->screen->tex_transfer_destroy(transfer);
return NULL;
}
struct pipe_texture *
trace_texture_create(struct trace_screen *tr_scr,
struct pipe_texture *texture)
{
struct trace_texture *tr_tex;
if(!texture)
goto error;
assert(texture->screen == tr_scr->screen);
tr_tex = CALLOC_STRUCT(trace_texture);
if(!tr_tex)
goto error;
memcpy(&tr_tex->base, texture, sizeof(struct pipe_texture));
pipe_reference_init(&tr_tex->base.reference, 1);
tr_tex->base.screen = &tr_scr->base;
tr_tex->texture = texture;
trace_screen_add_to_list(tr_scr, textures, tr_tex);
return &tr_tex->base;
error:
pipe_texture_reference(&texture, NULL);
return NULL;
}
struct pipe_surface *
trace_surface_create(struct trace_texture *tr_tex,
struct pipe_surface *surface)
{
struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
struct trace_surface *tr_surf;
if(!surface)
goto error;
assert(surface->texture == tr_tex->texture);
tr_surf = CALLOC_STRUCT(trace_surface);
if(!tr_surf)
goto error;
memcpy(&tr_surf->base, surface, sizeof(struct pipe_surface));
pipe_reference_init(&tr_surf->base.reference, 1);
tr_surf->base.texture = NULL;
pipe_texture_reference(&tr_surf->base.texture, &tr_tex->base);
tr_surf->surface = surface;
trace_screen_add_to_list(tr_scr, surfaces, tr_surf);
return &tr_surf->base;
error:
pipe_surface_reference(&surface, NULL);
return NULL;
}
void svga_cleanup_tss_binding(struct svga_context *svga)
{
int i;
unsigned count = MAX2( svga->curr.num_textures,
svga->state.hw_draw.num_views );
for (i = 0; i < count; i++) {
struct svga_hw_view_state *view = &svga->state.hw_draw.views[i];
svga_sampler_view_reference(&view->v, NULL);
pipe_texture_reference( &svga->curr.texture[i], NULL );
pipe_texture_reference( &view->texture, NULL );
view->dirty = 1;
}
}
static void
cell_set_sampler_textures(struct pipe_context *pipe,
unsigned num, struct pipe_texture **texture)
{
struct cell_context *cell = cell_context(pipe);
uint i, changed = 0x0;
assert(num <= CELL_MAX_SAMPLERS);
for (i = 0; i < CELL_MAX_SAMPLERS; i++) {
struct cell_texture *new_tex = cell_texture(i < num ? texture[i] : NULL);
struct cell_texture *old_tex = cell->texture[i];
if (old_tex != new_tex) {
pipe_texture_reference((struct pipe_texture **) &cell->texture[i],
(struct pipe_texture *) new_tex);
changed |= (1 << i);
}
}
cell->num_textures = num;
if (changed) {
cell->dirty |= CELL_NEW_TEXTURE;
cell->dirty_textures |= changed;
}
}
static void
update_textures(struct st_context *st)
{
struct gl_vertex_program *vprog = st->ctx->VertexProgram._Current;
struct gl_fragment_program *fprog = st->ctx->FragmentProgram._Current;
const GLbitfield samplersUsed = (vprog->Base.SamplersUsed |
fprog->Base.SamplersUsed);
GLuint su;
st->state.num_textures = 0;
/* loop over sampler units (aka tex image units) */
for (su = 0; su < st->ctx->Const.MaxTextureImageUnits; su++) {
struct pipe_texture *pt = NULL;
if (samplersUsed & (1 << su)) {
struct gl_texture_object *texObj;
struct st_texture_object *stObj;
GLboolean flush, retval;
GLuint texUnit;
if (fprog->Base.SamplersUsed & (1 << su))
texUnit = fprog->Base.SamplerUnits[su];
else
texUnit = vprog->Base.SamplerUnits[su];
texObj = st->ctx->Texture.Unit[texUnit]._Current;
if (!texObj) {
texObj = st_get_default_texture(st);
}
stObj = st_texture_object(texObj);
retval = st_finalize_texture(st->ctx, st->pipe, texObj, &flush);
if (!retval) {
/* out of mem */
continue;
}
st->state.num_textures = su + 1;
pt = st_get_stobj_texture(stObj);
}
/*
if (pt) {
printf("%s su=%u non-null\n", __FUNCTION__, su);
}
else {
printf("%s su=%u null\n", __FUNCTION__, su);
}
*/
pipe_texture_reference(&st->state.sampler_texture[su], pt);
}
cso_set_sampler_textures(st->cso_context,
st->state.num_textures,
st->state.sampler_texture);
}
static struct pipe_surface *
nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
unsigned face, unsigned level, unsigned zslice,
unsigned flags)
{
struct nv50_miptree *mt = nv50_miptree(pt);
struct nv50_miptree_level *lvl = &mt->level[level];
struct pipe_surface *ps;
unsigned img = 0;
if (pt->target == PIPE_TEXTURE_CUBE)
img = face;
ps = CALLOC_STRUCT(pipe_surface);
if (!ps)
return NULL;
pipe_texture_reference(&ps->texture, pt);
ps->format = pt->format;
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;
ps->level = level;
ps->zslice = zslice;
ps->offset = lvl->image_offset[img];
if (pt->target == PIPE_TEXTURE_3D) {
unsigned nb_h = util_format_get_nblocksy(pt->format, ps->height);
ps->offset += get_zslice_offset(lvl->tile_mode, zslice,
lvl->pitch, nb_h);
}
return ps;
}
static struct pipe_transfer*
r300_get_tex_transfer(struct pipe_screen *screen,
struct pipe_texture *texture,
unsigned face, unsigned level, unsigned zslice,
enum pipe_transfer_usage usage, unsigned x, unsigned y,
unsigned w, unsigned h)
{
struct r300_texture *tex = (struct r300_texture *)texture;
struct r300_transfer *trans;
struct r300_screen *rscreen = r300_screen(screen);
unsigned offset;
offset = r300_texture_get_offset(tex, level, zslice, face); /* in bytes */
trans = CALLOC_STRUCT(r300_transfer);
if (trans) {
pipe_texture_reference(&trans->transfer.texture, texture);
trans->transfer.x = x;
trans->transfer.y = y;
trans->transfer.width = w;
trans->transfer.height = h;
trans->transfer.stride = r300_texture_get_stride(rscreen, tex, level);
trans->transfer.usage = usage;
trans->transfer.zslice = zslice;
trans->transfer.face = face;
trans->offset = offset;
}
return &trans->transfer;
}
static void svga_set_sampler_textures(struct pipe_context *pipe,
unsigned num,
struct pipe_texture **texture)
{
struct svga_context *svga = svga_context(pipe);
unsigned flag_1d = 0;
unsigned flag_srgb = 0;
uint i;
assert(num <= PIPE_MAX_SAMPLERS);
/* Check for no-op */
if (num == svga->curr.num_textures &&
!memcmp(svga->curr.texture, texture, num * sizeof(struct pipe_texture *))) {
if (0) debug_printf("texture noop\n");
return;
}
for (i = 0; i < num; i++) {
pipe_texture_reference(&svga->curr.texture[i],
texture[i]);
if (!texture[i])
continue;
if (texture[i]->format == PIPE_FORMAT_A8R8G8B8_SRGB)
flag_srgb |= 1 << i;
if (texture[i]->target == PIPE_TEXTURE_1D)
flag_1d |= 1 << i;
}
for (i = num; i < svga->curr.num_textures; i++)
pipe_texture_reference(&svga->curr.texture[i],
NULL);
svga->curr.num_textures = num;
svga->dirty |= SVGA_NEW_TEXTURE_BINDING;
if (flag_srgb != svga->curr.tex_flags.flag_srgb ||
flag_1d != svga->curr.tex_flags.flag_1d)
{
svga->dirty |= SVGA_NEW_TEXTURE_FLAGS;
svga->curr.tex_flags.flag_1d = flag_1d;
svga->curr.tex_flags.flag_srgb = flag_srgb;
}
}
void st_resize_framebuffer(struct st_framebuffer *stfb,
uint width, uint height)
{
struct vg_context *ctx = vg_current_context();
struct st_renderbuffer *strb = stfb->strb;
struct pipe_framebuffer_state *state;
if (!ctx)
return;
state = &ctx->state.g3d.fb;
/* If this is a noop, exit early and don't do the clear, etc below.
*/
if (strb->width == width &&
strb->height == height &&
state->zsbuf)
return;
if (strb->width != width || strb->height != height)
st_renderbuffer_alloc_storage(ctx, strb,
width, height);
if (stfb->dsrb->width != width || stfb->dsrb->height != height)
st_renderbuffer_alloc_storage(ctx, stfb->dsrb,
width, height);
{
VGuint i;
memset(state, 0, sizeof(struct pipe_framebuffer_state));
state->width = width;
state->height = height;
state->nr_cbufs = 1;
state->cbufs[0] = strb->surface;
for (i = 1; i < PIPE_MAX_COLOR_BUFS; ++i)
state->cbufs[i] = 0;
state->zsbuf = stfb->dsrb->surface;
cso_set_framebuffer(ctx->cso_context, state);
}
ctx->state.dirty |= VIEWPORT_DIRTY;
ctx->state.dirty |= DEPTH_STENCIL_DIRTY;/*to reset the scissors*/
ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_DEPTHSTENCIL,
NULL, 0.0, 0);
/* we need all the other state already set */
setup_new_alpha_mask(ctx, stfb, width, height);
pipe_texture_reference( &stfb->blend_texture, NULL );
stfb->blend_texture = create_texture(ctx->pipe, PIPE_FORMAT_A8R8G8B8_UNORM,
width, height);
}
void image_destroy(struct vg_image *img)
{
struct vg_context *ctx = vg_current_context();
vg_context_remove_object(ctx, VG_OBJECT_IMAGE, img);
if (img->parent) {
/* remove img from the parent child array */
int idx;
struct vg_image **array =
(struct vg_image **)img->parent->children_array->data;
for (idx = 0; idx < img->parent->children_array->num_elements; ++idx) {
struct vg_image *child = array[idx];
if (child == img) {
break;
}
}
debug_assert(idx < img->parent->children_array->num_elements);
array_remove_element(img->parent->children_array, idx);
}
if (img->children_array && img->children_array->num_elements) {
/* reparent the children */
VGint i;
struct vg_image *parent = img->parent;
struct vg_image **children =
(struct vg_image **)img->children_array->data;
if (!parent) {
VGint min_x = children[0]->x;
parent = children[0];
for (i = 1; i < img->children_array->num_elements; ++i) {
struct vg_image *child = children[i];
if (child->x < min_x) {
parent = child;
}
}
}
for (i = 0; i < img->children_array->num_elements; ++i) {
struct vg_image *child = children[i];
if (child != parent) {
child->parent = parent;
if (!parent->children_array) {
parent->children_array = array_create(
sizeof(struct vg_image*));
}
array_append_data(parent->children_array,
&child, 1);
} else
child->parent = NULL;
}
array_destroy(img->children_array);
}
pipe_texture_reference(&img->texture, NULL);
free(img);
}
static void
nv50_miptree_surface_del(struct pipe_surface *ps)
{
struct nv50_surface *s = nv50_surface(ps);
pipe_texture_reference(&ps->texture, NULL);
FREE(s);
}
static struct pipe_surface *
softpipe_get_tex_surface(struct pipe_screen *screen,
struct pipe_texture *pt,
unsigned face, unsigned level, unsigned zslice,
unsigned usage)
{
struct softpipe_texture *spt = softpipe_texture(pt);
struct pipe_surface *ps;
assert(level <= pt->last_level);
ps = CALLOC_STRUCT(pipe_surface);
if (ps) {
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->offset = spt->level_offset[level];
ps->usage = usage;
/* Because we are softpipe, anything that the state tracker
* thought was going to be done with the GPU will actually get
* done with the CPU. Let's adjust the flags to take that into
* account.
*/
if (ps->usage & PIPE_BUFFER_USAGE_GPU_WRITE) {
/* GPU_WRITE means "render" and that can involve reads (blending) */
ps->usage |= PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_CPU_READ;
}
if (ps->usage & PIPE_BUFFER_USAGE_GPU_READ)
ps->usage |= PIPE_BUFFER_USAGE_CPU_READ;
if (ps->usage & (PIPE_BUFFER_USAGE_CPU_WRITE |
PIPE_BUFFER_USAGE_GPU_WRITE)) {
/* Mark the surface as dirty. The tile cache will look for this. */
spt->modified = TRUE;
}
ps->face = face;
ps->level = level;
ps->zslice = zslice;
if (pt->target == PIPE_TEXTURE_CUBE) {
ps->offset += face * pt->nblocksy[level] * spt->stride[level];
}
else if (pt->target == PIPE_TEXTURE_3D) {
ps->offset += zslice * pt->nblocksy[level] * spt->stride[level];
}
else {
assert(face == 0);
assert(zslice == 0);
}
}
return ps;
}
void
trace_texture_destroy(struct trace_texture *tr_tex)
{
struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
trace_screen_remove_from_list(tr_scr, textures, tr_tex);
pipe_texture_reference(&tr_tex->texture, NULL);
FREE(tr_tex);
}
static void
softpipe_destroy( struct pipe_context *pipe )
{
struct softpipe_context *softpipe = softpipe_context( pipe );
uint i;
if (softpipe->draw)
draw_destroy( softpipe->draw );
softpipe->quad.shade->destroy( softpipe->quad.shade );
softpipe->quad.depth_test->destroy( softpipe->quad.depth_test );
softpipe->quad.blend->destroy( softpipe->quad.blend );
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
sp_destroy_tile_cache(softpipe->cbuf_cache[i]);
pipe_surface_reference(&softpipe->framebuffer.cbufs[i], NULL);
}
sp_destroy_tile_cache(softpipe->zsbuf_cache);
pipe_surface_reference(&softpipe->framebuffer.zsbuf, NULL);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
sp_destroy_tex_tile_cache(softpipe->tex_cache[i]);
pipe_texture_reference(&softpipe->texture[i], NULL);
}
for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
sp_destroy_tex_tile_cache(softpipe->vertex_tex_cache[i]);
pipe_texture_reference(&softpipe->vertex_textures[i], NULL);
}
for (i = 0; i < PIPE_SHADER_TYPES; i++) {
uint j;
for (j = 0; j < PIPE_MAX_CONSTANT_BUFFERS; j++) {
if (softpipe->constants[i][j]) {
pipe_buffer_reference(&softpipe->constants[i][j], NULL);
}
}
}
FREE( softpipe );
}
static void
aaline_set_sampler_textures(struct pipe_context *pipe,
unsigned num, struct pipe_texture **texture)
{
struct aaline_stage *aaline = aaline_stage_from_pipe(pipe);
uint i;
/* save current */
for (i = 0; i < num; i++) {
pipe_texture_reference(&aaline->state.texture[i], texture[i]);
}
for ( ; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&aaline->state.texture[i], NULL);
}
aaline->num_textures = num;
/* pass-through */
aaline->driver_set_sampler_textures(aaline->pipe, num, texture);
}
/**
* Bind a pipe surface to a texture object. After the call,
* the texture object is marked dirty and will be (re-)validated.
*
* If this is the first surface bound, the texture object is said to
* switch from normal to surface based. It will be cleared first in
* this case.
*
* \param ps pipe surface to be unbound
* \param target texture target
* \param level image level
* \param format internal format of the texture
*/
int
st_bind_texture_surface(struct pipe_surface *ps, int target, int level,
enum pipe_format format)
{
GET_CURRENT_CONTEXT(ctx);
const GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
struct st_texture_object *stObj;
struct st_texture_image *stImage;
GLenum internalFormat;
switch (target) {
case ST_TEXTURE_2D:
target = GL_TEXTURE_2D;
break;
case ST_TEXTURE_RECT:
target = GL_TEXTURE_RECTANGLE_ARB;
break;
default:
return 0;
}
/* map pipe format to base format for now */
if (pf_get_component_bits(format, PIPE_FORMAT_COMP_A) > 0)
internalFormat = GL_RGBA;
else
internalFormat = GL_RGB;
texObj = _mesa_select_tex_object(ctx, texUnit, target);
_mesa_lock_texture(ctx, texObj);
stObj = st_texture_object(texObj);
/* switch to surface based */
if (!stObj->surface_based) {
_mesa_clear_texture_object(ctx, texObj);
stObj->surface_based = GL_TRUE;
}
texImage = _mesa_get_tex_image(ctx, texObj, target, level);
stImage = st_texture_image(texImage);
_mesa_init_teximage_fields(ctx, target, texImage,
ps->width, ps->height, 1, 0, internalFormat);
texImage->TexFormat = st_ChooseTextureFormat(ctx, internalFormat,
GL_RGBA, GL_UNSIGNED_BYTE);
_mesa_set_fetch_functions(texImage, 2);
pipe_texture_reference(&stImage->pt, ps->texture);
_mesa_dirty_texobj(ctx, texObj, GL_TRUE);
_mesa_unlock_texture(ctx, texObj);
return 1;
}
static void
softpipe_tex_transfer_destroy(struct pipe_transfer *transfer)
{
/* Effectively do the texture_update work here - if texture images
* needed post-processing to put them into hardware layout, this is
* where it would happen. For softpipe, nothing to do.
*/
assert (transfer->texture);
pipe_texture_reference(&transfer->texture, NULL);
FREE(transfer);
}
void
trace_surface_destroy(struct trace_surface *tr_surf)
{
struct trace_screen *tr_scr = trace_screen(tr_surf->base.texture->screen);
trace_screen_remove_from_list(tr_scr, surfaces, tr_surf);
pipe_texture_reference(&tr_surf->base.texture, NULL);
pipe_surface_reference(&tr_surf->surface, NULL);
FREE(tr_surf);
}