199 lines
6.1 KiB
C
199 lines
6.1 KiB
C
|
/*
|
||
|
* Copyright 2010 Jerome Glisse <glisse@freedesktop.org>
|
||
|
*
|
||
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
||
|
* copy of this software and associated documentation files (the "Software"),
|
||
|
* to deal in the Software without restriction, including without limitation
|
||
|
* on the rights to use, copy, modify, merge, publish, distribute, sub
|
||
|
* license, and/or sell copies of the Software, and to permit persons to whom
|
||
|
* the Software is furnished to do so, subject to the following conditions:
|
||
|
*
|
||
|
* The above copyright notice and this permission notice (including the next
|
||
|
* paragraph) shall be included in all copies or substantial portions of the
|
||
|
* Software.
|
||
|
*
|
||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
||
|
* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
|
||
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||
|
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
*
|
||
|
* Authors:
|
||
|
* Jerome Glisse
|
||
|
* Corbin Simpson
|
||
|
*/
|
||
|
#include <pipe/p_screen.h>
|
||
|
#include <util/u_format.h>
|
||
|
#include <util/u_math.h>
|
||
|
#include <util/u_inlines.h>
|
||
|
#include <util/u_memory.h>
|
||
|
#include "r600_screen.h"
|
||
|
#include "r600_texture.h"
|
||
|
|
||
|
unsigned long r600_texture_get_offset(struct r600_texture *rtex, unsigned level, unsigned zslice, unsigned face)
|
||
|
{
|
||
|
unsigned long offset = rtex->offset[level];
|
||
|
|
||
|
switch (rtex->tex.target) {
|
||
|
case PIPE_TEXTURE_3D:
|
||
|
assert(face == 0);
|
||
|
return offset + zslice * rtex->layer_size[level];
|
||
|
case PIPE_TEXTURE_CUBE:
|
||
|
assert(zslice == 0);
|
||
|
return offset + face * rtex->layer_size[level];
|
||
|
default:
|
||
|
assert(zslice == 0 && face == 0);
|
||
|
return offset;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void r600_setup_miptree(struct r600_screen *rscreen, struct r600_texture *rtex)
|
||
|
{
|
||
|
struct pipe_texture *ptex = &rtex->tex;
|
||
|
unsigned long w, h, stride, size, layer_size, i, offset;
|
||
|
|
||
|
for (i = 0, offset = 0; i <= ptex->last_level; i++) {
|
||
|
w = u_minify(ptex->width0, i);
|
||
|
h = u_minify(ptex->height0, i);
|
||
|
stride = align(util_format_get_stride(ptex->format, w), 32);
|
||
|
layer_size = stride * h;
|
||
|
if (ptex->target == PIPE_TEXTURE_CUBE)
|
||
|
size = layer_size * 6;
|
||
|
else
|
||
|
size = layer_size * u_minify(ptex->depth0, i);
|
||
|
rtex->offset[i] = offset;
|
||
|
rtex->layer_size[i] = layer_size;
|
||
|
rtex->pitch[i] = stride / util_format_get_blocksize(ptex->format);
|
||
|
rtex->stride[i] = stride;
|
||
|
offset += align(size, 32);
|
||
|
}
|
||
|
rtex->size = offset;
|
||
|
}
|
||
|
|
||
|
static struct pipe_texture *r600_texture_create(struct pipe_screen *screen, const struct pipe_texture *template)
|
||
|
{
|
||
|
struct r600_texture *rtex = CALLOC_STRUCT(r600_texture);
|
||
|
struct r600_screen *rscreen = r600_screen(screen);
|
||
|
|
||
|
if (!rtex) {
|
||
|
return NULL;
|
||
|
}
|
||
|
rtex->tex = *template;
|
||
|
pipe_reference_init(&rtex->tex.reference, 1);
|
||
|
rtex->tex.screen = screen;
|
||
|
r600_setup_miptree(rscreen, rtex);
|
||
|
rtex->buffer = screen->buffer_create(screen, 4096, PIPE_BUFFER_USAGE_PIXEL, rtex->size);
|
||
|
if (!rtex->buffer) {
|
||
|
FREE(rtex);
|
||
|
return NULL;
|
||
|
}
|
||
|
return (struct pipe_texture*)&rtex->tex;
|
||
|
}
|
||
|
|
||
|
static void r600_texture_destroy(struct pipe_texture *ptex)
|
||
|
{
|
||
|
struct r600_texture *rtex = (struct r600_texture*)ptex;
|
||
|
|
||
|
pipe_buffer_reference(&rtex->buffer, NULL);
|
||
|
FREE(rtex);
|
||
|
}
|
||
|
|
||
|
static struct pipe_surface *r600_get_tex_surface(struct pipe_screen *screen,
|
||
|
struct pipe_texture *texture,
|
||
|
unsigned face, unsigned level,
|
||
|
unsigned zslice, unsigned flags)
|
||
|
{
|
||
|
struct r600_texture *rtex = (struct r600_texture*)texture;
|
||
|
struct pipe_surface *surface = CALLOC_STRUCT(pipe_surface);
|
||
|
unsigned long offset;
|
||
|
|
||
|
if (surface == NULL)
|
||
|
return NULL;
|
||
|
offset = r600_texture_get_offset(rtex, level, zslice, face);
|
||
|
pipe_reference_init(&surface->reference, 1);
|
||
|
pipe_texture_reference(&surface->texture, texture);
|
||
|
surface->format = texture->format;
|
||
|
surface->width = u_minify(texture->width0, level);
|
||
|
surface->height = u_minify(texture->height0, level);
|
||
|
surface->offset = offset;
|
||
|
surface->usage = flags;
|
||
|
surface->zslice = zslice;
|
||
|
surface->texture = texture;
|
||
|
surface->face = face;
|
||
|
surface->level = level;
|
||
|
return surface;
|
||
|
}
|
||
|
|
||
|
static void r600_tex_surface_destroy(struct pipe_surface *surface)
|
||
|
{
|
||
|
pipe_texture_reference(&surface->texture, NULL);
|
||
|
FREE(surface);
|
||
|
}
|
||
|
|
||
|
static struct pipe_texture *r600_texture_blanket(struct pipe_screen *screen,
|
||
|
const struct pipe_texture *base,
|
||
|
const unsigned *stride,
|
||
|
struct pipe_buffer *buffer)
|
||
|
{
|
||
|
struct r600_texture *rtex;
|
||
|
|
||
|
/* Support only 2D textures without mipmaps */
|
||
|
if (base->target != PIPE_TEXTURE_2D || base->depth0 != 1 || base->last_level != 0)
|
||
|
return NULL;
|
||
|
rtex = CALLOC_STRUCT(r600_texture);
|
||
|
if (rtex == NULL)
|
||
|
return NULL;
|
||
|
rtex->tex = *base;
|
||
|
pipe_reference_init(&rtex->tex.reference, 1);
|
||
|
rtex->tex.screen = screen;
|
||
|
rtex->stride_override = *stride;
|
||
|
rtex->pitch[0] = *stride / util_format_get_blocksize(base->format);
|
||
|
rtex->stride[0] = *stride;
|
||
|
rtex->offset[0] = 0;
|
||
|
rtex->size = align(rtex->stride[0] * base->height0, 32);
|
||
|
pipe_buffer_reference(&rtex->buffer, buffer);
|
||
|
return &rtex->tex;
|
||
|
}
|
||
|
|
||
|
static struct pipe_video_surface *r600_video_surface_create(struct pipe_screen *screen,
|
||
|
enum pipe_video_chroma_format chroma_format,
|
||
|
unsigned width, unsigned height)
|
||
|
{
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
static void r600_video_surface_destroy(struct pipe_video_surface *vsfc)
|
||
|
{
|
||
|
FREE(vsfc);
|
||
|
}
|
||
|
|
||
|
void r600_init_screen_texture_functions(struct pipe_screen *screen)
|
||
|
{
|
||
|
screen->texture_create = r600_texture_create;
|
||
|
screen->texture_destroy = r600_texture_destroy;
|
||
|
screen->get_tex_surface = r600_get_tex_surface;
|
||
|
screen->tex_surface_destroy = r600_tex_surface_destroy;
|
||
|
screen->texture_blanket = r600_texture_blanket;
|
||
|
screen->video_surface_create = r600_video_surface_create;
|
||
|
screen->video_surface_destroy= r600_video_surface_destroy;
|
||
|
}
|
||
|
|
||
|
boolean r600_get_texture_buffer(struct pipe_screen *screen,
|
||
|
struct pipe_texture *texture,
|
||
|
struct pipe_buffer **buffer,
|
||
|
unsigned *stride)
|
||
|
{
|
||
|
struct r600_texture *rtex = (struct r600_texture*)texture;
|
||
|
|
||
|
if (rtex == NULL) {
|
||
|
return FALSE;
|
||
|
}
|
||
|
pipe_buffer_reference(buffer, rtex->buffer);
|
||
|
if (stride) {
|
||
|
*stride = rtex->stride[0];
|
||
|
}
|
||
|
return TRUE;
|
||
|
}
|