st_texture.c revision 8cd0873d319cefce74164147c9855e81f051d1e1 
1/**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28#include <stdio.h>
29
30#include "st_context.h"
31#include "st_format.h"
32#include "st_texture.h"
33#include "st_cb_fbo.h"
34#include "main/enums.h"
35
36#include "pipe/p_state.h"
37#include "pipe/p_context.h"
38#include "pipe/p_defines.h"
39#include "util/u_inlines.h"
40#include "util/u_format.h"
41#include "util/u_rect.h"
42#include "util/u_math.h"
43
44
45#define DBG if(0) printf
46
47
48/**
49 * Allocate a new pipe_resource object
50 * width0, height0, depth0 are the dimensions of the level 0 image
51 * (the highest resolution).  last_level indicates how many mipmap levels
52 * to allocate storage for.  For non-mipmapped textures, this will be zero.
53 */
54struct pipe_resource *
55st_texture_create(struct st_context *st,
56                  enum pipe_texture_target target,
57		  enum pipe_format format,
58		  GLuint last_level,
59		  GLuint width0,
60		  GLuint height0,
61		  GLuint depth0,
62                  GLuint layers,
63                  GLuint bind )
64{
65   struct pipe_resource pt, *newtex;
66   struct pipe_screen *screen = st->pipe->screen;
67
68   assert(target < PIPE_MAX_TEXTURE_TYPES);
69   assert(width0 > 0);
70   assert(height0 > 0);
71   assert(depth0 > 0);
72   if (target == PIPE_TEXTURE_CUBE)
73      assert(layers == 6);
74
75   DBG("%s target %d format %s last_level %d\n", __FUNCTION__,
76       (int) target, util_format_name(format), last_level);
77
78   assert(format);
79   assert(screen->is_format_supported(screen, format, target, 0,
80                                      PIPE_BIND_SAMPLER_VIEW));
81
82   memset(&pt, 0, sizeof(pt));
83   pt.target = target;
84   pt.format = format;
85   pt.last_level = last_level;
86   pt.width0 = width0;
87   pt.height0 = height0;
88   pt.depth0 = depth0;
89   pt.array_size = (target == PIPE_TEXTURE_CUBE ? 6 : layers);
90   pt.usage = PIPE_USAGE_DEFAULT;
91   pt.bind = bind;
92   pt.flags = 0;
93
94   newtex = screen->resource_create(screen, &pt);
95
96   assert(!newtex || pipe_is_referenced(&newtex->reference));
97
98   return newtex;
99}
100
101
102/**
103 * In OpenGL the number of 1D array texture layers is the "height" and
104 * the number of 2D array texture layers is the "depth".  In Gallium the
105 * number of layers in an array texture is a separate 'array_size' field.
106 * This function converts dimensions from the former to the later.
107 */
108void
109st_gl_texture_dims_to_pipe_dims(GLenum texture,
110                                GLuint widthIn,
111                                GLuint heightIn,
112                                GLuint depthIn,
113                                GLuint *widthOut,
114                                GLuint *heightOut,
115                                GLuint *depthOut,
116                                GLuint *layersOut)
117{
118   switch (texture) {
119   case GL_TEXTURE_1D:
120      assert(heightIn == 1);
121      assert(depthIn == 1);
122      *widthOut = widthIn;
123      *heightOut = 1;
124      *depthOut = 1;
125      *layersOut = 1;
126      break;
127   case GL_TEXTURE_1D_ARRAY:
128      assert(depthIn == 1);
129      *widthOut = widthIn;
130      *heightOut = 1;
131      *depthOut = 1;
132      *layersOut = heightIn;
133      break;
134   case GL_TEXTURE_2D:
135   case GL_TEXTURE_RECTANGLE:
136   case GL_TEXTURE_EXTERNAL_OES:
137      assert(depthIn == 1);
138      *widthOut = widthIn;
139      *heightOut = heightIn;
140      *depthOut = 1;
141      *layersOut = 1;
142      break;
143   case GL_TEXTURE_CUBE_MAP:
144      assert(depthIn == 1);
145      *widthOut = widthIn;
146      *heightOut = heightIn;
147      *depthOut = 1;
148      *layersOut = 6;
149      break;
150   case GL_TEXTURE_2D_ARRAY:
151      *widthOut = widthIn;
152      *heightOut = heightIn;
153      *depthOut = 1;
154      *layersOut = depthIn;
155      break;
156   default:
157      assert(0 && "Unexpected texture in st_gl_texture_dims_to_pipe_dims()");
158      /* fall-through */
159   case GL_TEXTURE_3D:
160      *widthOut = widthIn;
161      *heightOut = heightIn;
162      *depthOut = depthIn;
163      *layersOut = 1;
164      break;
165   }
166}
167
168
169/**
170 * Check if a texture image can be pulled into a unified mipmap texture.
171 */
172GLboolean
173st_texture_match_image(const struct pipe_resource *pt,
174                       const struct gl_texture_image *image)
175{
176   GLuint ptWidth, ptHeight, ptDepth, ptLayers;
177
178   /* Images with borders are never pulled into mipmap textures.
179    */
180   if (image->Border)
181      return GL_FALSE;
182
183   /* Check if this image's format matches the established texture's format.
184    */
185   if (st_mesa_format_to_pipe_format(image->TexFormat) != pt->format)
186      return GL_FALSE;
187
188   st_gl_texture_dims_to_pipe_dims(image->TexObject->Target,
189                                   image->Width, image->Height, image->Depth,
190                                   &ptWidth, &ptHeight, &ptDepth, &ptLayers);
191
192   /* Test if this image's size matches what's expected in the
193    * established texture.
194    */
195   if (ptWidth != u_minify(pt->width0, image->Level) ||
196       ptHeight != u_minify(pt->height0, image->Level) ||
197       ptDepth != u_minify(pt->depth0, image->Level) ||
198       ptLayers != pt->array_size)
199      return GL_FALSE;
200
201   return GL_TRUE;
202}
203
204
205/**
206 * Map a texture image and return the address for a particular 2D face/slice/
207 * layer.  The stImage indicates the cube face and mipmap level.  The slice
208 * of the 3D texture is passed in 'zoffset'.
209 * \param usage  one of the PIPE_TRANSFER_x values
210 * \param x, y, w, h  the region of interest of the 2D image.
211 * \return address of mapping or NULL if any error
212 */
213GLubyte *
214st_texture_image_map(struct st_context *st, struct st_texture_image *stImage,
215                     GLuint zoffset, enum pipe_transfer_usage usage,
216                     GLuint x, GLuint y, GLuint w, GLuint h)
217{
218   struct pipe_context *pipe = st->pipe;
219   struct pipe_resource *pt = stImage->pt;
220
221   DBG("%s \n", __FUNCTION__);
222
223   stImage->transfer = pipe_get_transfer(st->pipe, pt, stImage->base.Level,
224                                         stImage->base.Face + zoffset,
225                                         usage, x, y, w, h);
226
227   if (stImage->transfer)
228      return pipe_transfer_map(pipe, stImage->transfer);
229   else
230      return NULL;
231}
232
233
234void
235st_texture_image_unmap(struct st_context *st,
236                       struct st_texture_image *stImage)
237{
238   struct pipe_context *pipe = st->pipe;
239
240   DBG("%s\n", __FUNCTION__);
241
242   pipe_transfer_unmap(pipe, stImage->transfer);
243
244   pipe->transfer_destroy(pipe, stImage->transfer);
245   stImage->transfer = NULL;
246}
247
248
249
250/**
251 * Upload data to a rectangular sub-region.  Lots of choices how to do this:
252 *
253 * - memcpy by span to current destination
254 * - upload data as new buffer and blit
255 *
256 * Currently always memcpy.
257 */
258static void
259st_surface_data(struct pipe_context *pipe,
260		struct pipe_transfer *dst,
261		unsigned dstx, unsigned dsty,
262		const void *src, unsigned src_stride,
263		unsigned srcx, unsigned srcy, unsigned width, unsigned height)
264{
265   void *map = pipe_transfer_map(pipe, dst);
266
267   assert(dst->resource);
268   util_copy_rect(map,
269                  dst->resource->format,
270                  dst->stride,
271                  dstx, dsty,
272                  width, height,
273                  src, src_stride,
274                  srcx, srcy);
275
276   pipe_transfer_unmap(pipe, dst);
277}
278
279
280/* Upload data for a particular image.
281 */
282void
283st_texture_image_data(struct st_context *st,
284                      struct pipe_resource *dst,
285                      GLuint face,
286                      GLuint level,
287                      void *src,
288                      GLuint src_row_stride, GLuint src_image_stride)
289{
290   struct pipe_context *pipe = st->pipe;
291   GLuint i;
292   const GLubyte *srcUB = src;
293   struct pipe_transfer *dst_transfer;
294   GLuint layers;
295
296   if (dst->target == PIPE_TEXTURE_1D_ARRAY ||
297       dst->target == PIPE_TEXTURE_2D_ARRAY)
298      layers = dst->array_size;
299   else
300      layers = u_minify(dst->depth0, level);
301
302   DBG("%s\n", __FUNCTION__);
303
304   for (i = 0; i < layers; i++) {
305      dst_transfer = pipe_get_transfer(st->pipe, dst, level, face + i,
306                                       PIPE_TRANSFER_WRITE, 0, 0,
307                                       u_minify(dst->width0, level),
308                                       u_minify(dst->height0, level));
309
310      st_surface_data(pipe, dst_transfer,
311		      0, 0,                             /* dstx, dsty */
312		      srcUB,
313		      src_row_stride,
314		      0, 0,                             /* source x, y */
315		      u_minify(dst->width0, level),
316                      u_minify(dst->height0, level));    /* width, height */
317
318      pipe->transfer_destroy(pipe, dst_transfer);
319
320      srcUB += src_image_stride;
321   }
322}
323
324
325/**
326 * For debug only: get/print center pixel in the src resource.
327 */
328static void
329print_center_pixel(struct pipe_context *pipe, struct pipe_resource *src)
330{
331   struct pipe_transfer *xfer;
332   struct pipe_box region;
333   ubyte *map;
334
335   region.x = src->width0 / 2;
336   region.y = src->height0 / 2;
337   region.z = 0;
338   region.width = 1;
339   region.height = 1;
340   region.depth = 1;
341
342   xfer = pipe->get_transfer(pipe, src, 0, PIPE_TRANSFER_READ, &region);
343   map = pipe->transfer_map(pipe, xfer);
344
345   printf("center pixel: %d %d %d %d\n", map[0], map[1], map[2], map[3]);
346
347   pipe->transfer_unmap(pipe, xfer);
348   pipe->transfer_destroy(pipe, xfer);
349}
350
351
352/**
353 * Copy the image at level=0 in 'src' to the 'dst' resource at 'dstLevel'.
354 * This is used to copy mipmap images from one texture buffer to another.
355 * This typically happens when our initial guess at the total texture size
356 * is incorrect (see the guess_and_alloc_texture() function).
357 */
358void
359st_texture_image_copy(struct pipe_context *pipe,
360                      struct pipe_resource *dst, GLuint dstLevel,
361                      struct pipe_resource *src, GLuint srcLevel,
362                      GLuint face)
363{
364   GLuint width = u_minify(dst->width0, dstLevel);
365   GLuint height = u_minify(dst->height0, dstLevel);
366   GLuint depth = u_minify(dst->depth0, dstLevel);
367   struct pipe_box src_box;
368   GLuint i;
369
370   if (u_minify(src->width0, srcLevel) != width ||
371       u_minify(src->height0, srcLevel) != height ||
372       u_minify(src->depth0, srcLevel) != depth) {
373      /* The source image size doesn't match the destination image size.
374       * This can happen in some degenerate situations such as rendering to a
375       * cube map face which was set up with mismatched texture sizes.
376       */
377      return;
378   }
379
380   src_box.x = 0;
381   src_box.y = 0;
382   src_box.width = width;
383   src_box.height = height;
384   src_box.depth = 1;
385   /* Loop over 3D image slices */
386   /* could (and probably should) use "true" 3d box here -
387      but drivers can't quite handle it yet */
388   for (i = face; i < face + depth; i++) {
389      src_box.z = i;
390
391      if (0)  {
392         print_center_pixel(pipe, src);
393      }
394
395      pipe->resource_copy_region(pipe,
396                                 dst,
397                                 dstLevel,
398                                 0, 0, i,/* destX, Y, Z */
399                                 src,
400                                 srcLevel,
401                                 &src_box);
402   }
403}
404
405
406struct pipe_resource *
407st_create_color_map_texture(struct gl_context *ctx)
408{
409   struct st_context *st = st_context(ctx);
410   struct pipe_context *pipe = st->pipe;
411   struct pipe_resource *pt;
412   enum pipe_format format;
413   const uint texSize = 256; /* simple, and usually perfect */
414
415   /* find an RGBA texture format */
416   format = st_choose_format(pipe->screen, GL_RGBA, GL_NONE, GL_NONE,
417                             PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
418
419   /* create texture for color map/table */
420   pt = st_texture_create(st, PIPE_TEXTURE_2D, format, 0,
421                          texSize, texSize, 1, 1, PIPE_BIND_SAMPLER_VIEW);
422   return pt;
423}
424
425