st_cb_texture.c revision 38db9a4e262f01a82f55c89605bbc687e2ee99e3 
1/**************************************************************************
2 *
3 * Copyright 2007 VMware, Inc.
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 VMWARE 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#include "main/bufferobj.h"
30#include "main/enums.h"
31#include "main/fbobject.h"
32#include "main/formats.h"
33#include "main/format_utils.h"
34#include "main/glformats.h"
35#include "main/image.h"
36#include "main/imports.h"
37#include "main/macros.h"
38#include "main/mipmap.h"
39#include "main/pack.h"
40#include "main/pbo.h"
41#include "main/pixeltransfer.h"
42#include "main/texcompress.h"
43#include "main/texcompress_etc.h"
44#include "main/texgetimage.h"
45#include "main/teximage.h"
46#include "main/texobj.h"
47#include "main/texstore.h"
48
49#include "state_tracker/st_debug.h"
50#include "state_tracker/st_context.h"
51#include "state_tracker/st_cb_fbo.h"
52#include "state_tracker/st_cb_flush.h"
53#include "state_tracker/st_cb_texture.h"
54#include "state_tracker/st_cb_bufferobjects.h"
55#include "state_tracker/st_format.h"
56#include "state_tracker/st_texture.h"
57#include "state_tracker/st_gen_mipmap.h"
58#include "state_tracker/st_atom.h"
59
60#include "pipe/p_context.h"
61#include "pipe/p_defines.h"
62#include "util/u_inlines.h"
63#include "util/u_upload_mgr.h"
64#include "pipe/p_shader_tokens.h"
65#include "util/u_tile.h"
66#include "util/u_format.h"
67#include "util/u_surface.h"
68#include "util/u_sampler.h"
69#include "util/u_math.h"
70#include "util/u_box.h"
71#include "util/u_simple_shaders.h"
72#include "cso_cache/cso_context.h"
73#include "tgsi/tgsi_ureg.h"
74
75#define DBG if (0) printf
76
77
78enum pipe_texture_target
79gl_target_to_pipe(GLenum target)
80{
81   switch (target) {
82   case GL_TEXTURE_1D:
83   case GL_PROXY_TEXTURE_1D:
84      return PIPE_TEXTURE_1D;
85   case GL_TEXTURE_2D:
86   case GL_PROXY_TEXTURE_2D:
87   case GL_TEXTURE_EXTERNAL_OES:
88   case GL_TEXTURE_2D_MULTISAMPLE:
89   case GL_PROXY_TEXTURE_2D_MULTISAMPLE:
90      return PIPE_TEXTURE_2D;
91   case GL_TEXTURE_RECTANGLE_NV:
92   case GL_PROXY_TEXTURE_RECTANGLE_NV:
93      return PIPE_TEXTURE_RECT;
94   case GL_TEXTURE_3D:
95   case GL_PROXY_TEXTURE_3D:
96      return PIPE_TEXTURE_3D;
97   case GL_TEXTURE_CUBE_MAP_ARB:
98   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
99   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
100   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
101   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
102   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
103   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
104   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
105      return PIPE_TEXTURE_CUBE;
106   case GL_TEXTURE_1D_ARRAY_EXT:
107   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
108      return PIPE_TEXTURE_1D_ARRAY;
109   case GL_TEXTURE_2D_ARRAY_EXT:
110   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
111   case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
112   case GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY:
113      return PIPE_TEXTURE_2D_ARRAY;
114   case GL_TEXTURE_BUFFER:
115      return PIPE_BUFFER;
116   case GL_TEXTURE_CUBE_MAP_ARRAY:
117   case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY:
118      return PIPE_TEXTURE_CUBE_ARRAY;
119   default:
120      assert(0);
121      return 0;
122   }
123}
124
125
126/** called via ctx->Driver.NewTextureImage() */
127static struct gl_texture_image *
128st_NewTextureImage(struct gl_context * ctx)
129{
130   DBG("%s\n", __func__);
131   (void) ctx;
132   return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image);
133}
134
135
136/** called via ctx->Driver.DeleteTextureImage() */
137static void
138st_DeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img)
139{
140   /* nothing special (yet) for st_texture_image */
141   _mesa_delete_texture_image(ctx, img);
142}
143
144
145/** called via ctx->Driver.NewTextureObject() */
146static struct gl_texture_object *
147st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target)
148{
149   struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object);
150
151   DBG("%s\n", __func__);
152   _mesa_initialize_texture_object(ctx, &obj->base, name, target);
153
154   return &obj->base;
155}
156
157/** called via ctx->Driver.DeleteTextureObject() */
158static void
159st_DeleteTextureObject(struct gl_context *ctx,
160                       struct gl_texture_object *texObj)
161{
162   struct st_context *st = st_context(ctx);
163   struct st_texture_object *stObj = st_texture_object(texObj);
164
165   pipe_resource_reference(&stObj->pt, NULL);
166   st_texture_release_all_sampler_views(st, stObj);
167   st_texture_free_sampler_views(stObj);
168   _mesa_delete_texture_object(ctx, texObj);
169}
170
171
172/** called via ctx->Driver.FreeTextureImageBuffer() */
173static void
174st_FreeTextureImageBuffer(struct gl_context *ctx,
175                          struct gl_texture_image *texImage)
176{
177   struct st_texture_image *stImage = st_texture_image(texImage);
178
179   DBG("%s\n", __func__);
180
181   if (stImage->pt) {
182      pipe_resource_reference(&stImage->pt, NULL);
183   }
184
185   free(stImage->transfer);
186   stImage->transfer = NULL;
187   stImage->num_transfers = 0;
188}
189
190
191/** called via ctx->Driver.MapTextureImage() */
192static void
193st_MapTextureImage(struct gl_context *ctx,
194                   struct gl_texture_image *texImage,
195                   GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h,
196                   GLbitfield mode,
197                   GLubyte **mapOut, GLint *rowStrideOut)
198{
199   struct st_context *st = st_context(ctx);
200   struct st_texture_image *stImage = st_texture_image(texImage);
201   unsigned pipeMode;
202   GLubyte *map;
203   struct pipe_transfer *transfer;
204
205   pipeMode = 0x0;
206   if (mode & GL_MAP_READ_BIT)
207      pipeMode |= PIPE_TRANSFER_READ;
208   if (mode & GL_MAP_WRITE_BIT)
209      pipeMode |= PIPE_TRANSFER_WRITE;
210   if (mode & GL_MAP_INVALIDATE_RANGE_BIT)
211      pipeMode |= PIPE_TRANSFER_DISCARD_RANGE;
212
213   map = st_texture_image_map(st, stImage, pipeMode, x, y, slice, w, h, 1,
214                              &transfer);
215   if (map) {
216      if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
217          (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) {
218         /* ETC isn't supported by gallium and it's represented
219          * by uncompressed formats. Only write transfers with precompressed
220          * data are supported by ES3, which makes this really simple.
221          *
222          * Just create a temporary storage where the ETC texture will
223          * be stored. It will be decompressed in the Unmap function.
224          */
225         unsigned z = transfer->box.z;
226         struct st_texture_image_transfer *itransfer = &stImage->transfer[z];
227
228         itransfer->temp_data =
229            malloc(_mesa_format_image_size(texImage->TexFormat, w, h, 1));
230         itransfer->temp_stride =
231            _mesa_format_row_stride(texImage->TexFormat, w);
232         itransfer->map = map;
233
234         *mapOut = itransfer->temp_data;
235         *rowStrideOut = itransfer->temp_stride;
236      }
237      else {
238         /* supported mapping */
239         *mapOut = map;
240         *rowStrideOut = transfer->stride;
241      }
242   }
243   else {
244      *mapOut = NULL;
245      *rowStrideOut = 0;
246   }
247}
248
249
250/** called via ctx->Driver.UnmapTextureImage() */
251static void
252st_UnmapTextureImage(struct gl_context *ctx,
253                     struct gl_texture_image *texImage,
254                     GLuint slice)
255{
256   struct st_context *st = st_context(ctx);
257   struct st_texture_image *stImage  = st_texture_image(texImage);
258
259   if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
260       (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) {
261      /* Decompress the ETC texture to the mapped one. */
262      unsigned z = slice + stImage->base.Face;
263      struct st_texture_image_transfer *itransfer = &stImage->transfer[z];
264      struct pipe_transfer *transfer = itransfer->transfer;
265
266      assert(z == transfer->box.z);
267
268      if (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8) {
269         _mesa_etc1_unpack_rgba8888(itransfer->map, transfer->stride,
270                                    itransfer->temp_data,
271                                    itransfer->temp_stride,
272                                    transfer->box.width, transfer->box.height);
273      }
274      else {
275         _mesa_unpack_etc2_format(itransfer->map, transfer->stride,
276                                  itransfer->temp_data, itransfer->temp_stride,
277                                  transfer->box.width, transfer->box.height,
278                                  texImage->TexFormat);
279      }
280
281      free(itransfer->temp_data);
282      itransfer->temp_data = NULL;
283      itransfer->temp_stride = 0;
284      itransfer->map = 0;
285   }
286
287   st_texture_image_unmap(st, stImage, slice);
288}
289
290
291/**
292 * Return default texture resource binding bitmask for the given format.
293 */
294static GLuint
295default_bindings(struct st_context *st, enum pipe_format format)
296{
297   struct pipe_screen *screen = st->pipe->screen;
298   const unsigned target = PIPE_TEXTURE_2D;
299   unsigned bindings;
300
301   if (util_format_is_depth_or_stencil(format))
302      bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DEPTH_STENCIL;
303   else
304      bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
305
306   if (screen->is_format_supported(screen, format, target, 0, bindings))
307      return bindings;
308   else {
309      /* Try non-sRGB. */
310      format = util_format_linear(format);
311
312      if (screen->is_format_supported(screen, format, target, 0, bindings))
313         return bindings;
314      else
315         return PIPE_BIND_SAMPLER_VIEW;
316   }
317}
318
319
320/**
321 * Given the size of a mipmap image, try to compute the size of the level=0
322 * mipmap image.
323 *
324 * Note that this isn't always accurate for odd-sized, non-POW textures.
325 * For example, if level=1 and width=40 then the level=0 width may be 80 or 81.
326 *
327 * \return GL_TRUE for success, GL_FALSE for failure
328 */
329static GLboolean
330guess_base_level_size(GLenum target,
331                      GLuint width, GLuint height, GLuint depth, GLuint level,
332                      GLuint *width0, GLuint *height0, GLuint *depth0)
333{
334   assert(width >= 1);
335   assert(height >= 1);
336   assert(depth >= 1);
337
338   if (level > 0) {
339      /* Guess the size of the base level.
340       * Depending on the image's size, we can't always make a guess here.
341       */
342      switch (target) {
343      case GL_TEXTURE_1D:
344      case GL_TEXTURE_1D_ARRAY:
345         width <<= level;
346         break;
347
348      case GL_TEXTURE_2D:
349      case GL_TEXTURE_2D_ARRAY:
350         /* We can't make a good guess here, because the base level dimensions
351          * can be non-square.
352          */
353         if (width == 1 || height == 1) {
354            return GL_FALSE;
355         }
356         width <<= level;
357         height <<= level;
358         break;
359
360      case GL_TEXTURE_CUBE_MAP:
361      case GL_TEXTURE_CUBE_MAP_ARRAY:
362         width <<= level;
363         height <<= level;
364         break;
365
366      case GL_TEXTURE_3D:
367         /* We can't make a good guess here, because the base level dimensions
368          * can be non-cube.
369          */
370         if (width == 1 || height == 1 || depth == 1) {
371            return GL_FALSE;
372         }
373         width <<= level;
374         height <<= level;
375         depth <<= level;
376         break;
377
378      case GL_TEXTURE_RECTANGLE:
379         break;
380
381      default:
382         assert(0);
383      }
384   }
385
386   *width0 = width;
387   *height0 = height;
388   *depth0 = depth;
389
390   return GL_TRUE;
391}
392
393
394/**
395 * Try to determine whether we should allocate memory for a full texture
396 * mipmap.  The problem is when we get a glTexImage(level=0) call, we
397 * can't immediately know if other mipmap levels are coming next.  Here
398 * we try to guess whether to allocate memory for a mipmap or just the
399 * 0th level.
400 *
401 * If we guess incorrectly here we'll later reallocate the right amount of
402 * memory either in st_AllocTextureImageBuffer() or st_finalize_texture().
403 *
404 * \param stObj  the texture object we're going to allocate memory for.
405 * \param stImage  describes the incoming image which we need to store.
406 */
407static boolean
408allocate_full_mipmap(const struct st_texture_object *stObj,
409                     const struct st_texture_image *stImage)
410{
411   switch (stObj->base.Target) {
412   case GL_TEXTURE_RECTANGLE_NV:
413   case GL_TEXTURE_BUFFER:
414   case GL_TEXTURE_EXTERNAL_OES:
415   case GL_TEXTURE_2D_MULTISAMPLE:
416   case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
417      /* these texture types cannot be mipmapped */
418      return FALSE;
419   }
420
421   if (stImage->base.Level > 0 || stObj->base.GenerateMipmap)
422      return TRUE;
423
424   if (stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
425       stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT)
426      /* depth/stencil textures are seldom mipmapped */
427      return FALSE;
428
429   if (stObj->base.BaseLevel == 0 && stObj->base.MaxLevel == 0)
430      return FALSE;
431
432   if (stObj->base.Sampler.MinFilter == GL_NEAREST ||
433       stObj->base.Sampler.MinFilter == GL_LINEAR)
434      /* not a mipmap minification filter */
435      return FALSE;
436
437   if (stObj->base.Target == GL_TEXTURE_3D)
438      /* 3D textures are seldom mipmapped */
439      return FALSE;
440
441   return TRUE;
442}
443
444
445/**
446 * Try to allocate a pipe_resource object for the given st_texture_object.
447 *
448 * We use the given st_texture_image as a clue to determine the size of the
449 * mipmap image at level=0.
450 *
451 * \return GL_TRUE for success, GL_FALSE if out of memory.
452 */
453static GLboolean
454guess_and_alloc_texture(struct st_context *st,
455			struct st_texture_object *stObj,
456			const struct st_texture_image *stImage)
457{
458   GLuint lastLevel, width, height, depth;
459   GLuint bindings;
460   GLuint ptWidth, ptHeight, ptDepth, ptLayers;
461   enum pipe_format fmt;
462
463   DBG("%s\n", __func__);
464
465   assert(!stObj->pt);
466
467   if (!guess_base_level_size(stObj->base.Target,
468                              stImage->base.Width2,
469                              stImage->base.Height2,
470                              stImage->base.Depth2,
471                              stImage->base.Level,
472                              &width, &height, &depth)) {
473      /* we can't determine the image size at level=0 */
474      stObj->width0 = stObj->height0 = stObj->depth0 = 0;
475      /* this is not an out of memory error */
476      return GL_TRUE;
477   }
478
479   /* At this point, (width x height x depth) is the expected size of
480    * the level=0 mipmap image.
481    */
482
483   /* Guess a reasonable value for lastLevel.  With OpenGL we have no
484    * idea how many mipmap levels will be in a texture until we start
485    * to render with it.  Make an educated guess here but be prepared
486    * to re-allocating a texture buffer with space for more (or fewer)
487    * mipmap levels later.
488    */
489   if (allocate_full_mipmap(stObj, stImage)) {
490      /* alloc space for a full mipmap */
491      lastLevel = _mesa_get_tex_max_num_levels(stObj->base.Target,
492                                               width, height, depth) - 1;
493   }
494   else {
495      /* only alloc space for a single mipmap level */
496      lastLevel = 0;
497   }
498
499   /* Save the level=0 dimensions */
500   stObj->width0 = width;
501   stObj->height0 = height;
502   stObj->depth0 = depth;
503
504   fmt = st_mesa_format_to_pipe_format(st, stImage->base.TexFormat);
505
506   bindings = default_bindings(st, fmt);
507
508   st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
509                                   width, height, depth,
510                                   &ptWidth, &ptHeight, &ptDepth, &ptLayers);
511
512   stObj->pt = st_texture_create(st,
513                                 gl_target_to_pipe(stObj->base.Target),
514                                 fmt,
515                                 lastLevel,
516                                 ptWidth,
517                                 ptHeight,
518                                 ptDepth,
519                                 ptLayers, 0,
520                                 bindings);
521
522   stObj->lastLevel = lastLevel;
523
524   DBG("%s returning %d\n", __func__, (stObj->pt != NULL));
525
526   return stObj->pt != NULL;
527}
528
529
530/**
531 * Called via ctx->Driver.AllocTextureImageBuffer().
532 * If the texture object/buffer already has space for the indicated image,
533 * we're done.  Otherwise, allocate memory for the new texture image.
534 */
535static GLboolean
536st_AllocTextureImageBuffer(struct gl_context *ctx,
537                           struct gl_texture_image *texImage)
538{
539   struct st_context *st = st_context(ctx);
540   struct st_texture_image *stImage = st_texture_image(texImage);
541   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
542   const GLuint level = texImage->Level;
543   GLuint width = texImage->Width;
544   GLuint height = texImage->Height;
545   GLuint depth = texImage->Depth;
546
547   DBG("%s\n", __func__);
548
549   assert(!stImage->pt); /* xxx this might be wrong */
550
551   /* Look if the parent texture object has space for this image */
552   if (stObj->pt &&
553       level <= stObj->pt->last_level &&
554       st_texture_match_image(st, stObj->pt, texImage)) {
555      /* this image will fit in the existing texture object's memory */
556      pipe_resource_reference(&stImage->pt, stObj->pt);
557      return GL_TRUE;
558   }
559
560   /* The parent texture object does not have space for this image */
561
562   pipe_resource_reference(&stObj->pt, NULL);
563   st_texture_release_all_sampler_views(st, stObj);
564
565   if (!guess_and_alloc_texture(st, stObj, stImage)) {
566      /* Probably out of memory.
567       * Try flushing any pending rendering, then retry.
568       */
569      st_finish(st);
570      if (!guess_and_alloc_texture(st, stObj, stImage)) {
571         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
572         return GL_FALSE;
573      }
574   }
575
576   if (stObj->pt &&
577       st_texture_match_image(st, stObj->pt, texImage)) {
578      /* The image will live in the object's mipmap memory */
579      pipe_resource_reference(&stImage->pt, stObj->pt);
580      assert(stImage->pt);
581      return GL_TRUE;
582   }
583   else {
584      /* Create a new, temporary texture/resource/buffer to hold this
585       * one texture image.  Note that when we later access this image
586       * (either for mapping or copying) we'll want to always specify
587       * mipmap level=0, even if the image represents some other mipmap
588       * level.
589       */
590      enum pipe_format format =
591         st_mesa_format_to_pipe_format(st, texImage->TexFormat);
592      GLuint bindings = default_bindings(st, format);
593      GLuint ptWidth, ptHeight, ptDepth, ptLayers;
594
595      st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
596                                      width, height, depth,
597                                      &ptWidth, &ptHeight, &ptDepth, &ptLayers);
598
599      stImage->pt = st_texture_create(st,
600                                      gl_target_to_pipe(stObj->base.Target),
601                                      format,
602                                      0, /* lastLevel */
603                                      ptWidth,
604                                      ptHeight,
605                                      ptDepth,
606                                      ptLayers, 0,
607                                      bindings);
608      return stImage->pt != NULL;
609   }
610}
611
612
613/**
614 * Preparation prior to glTexImage.  Basically check the 'surface_based'
615 * field and switch to a "normal" tex image if necessary.
616 */
617static void
618prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage,
619              GLenum format, GLenum type)
620{
621   struct gl_texture_object *texObj = texImage->TexObject;
622   struct st_texture_object *stObj = st_texture_object(texObj);
623
624   /* switch to "normal" */
625   if (stObj->surface_based) {
626      const GLenum target = texObj->Target;
627      const GLuint level = texImage->Level;
628      mesa_format texFormat;
629
630      _mesa_clear_texture_object(ctx, texObj);
631      pipe_resource_reference(&stObj->pt, NULL);
632
633      /* oops, need to init this image again */
634      texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
635                                              texImage->InternalFormat, format,
636                                              type);
637
638      _mesa_init_teximage_fields(ctx, texImage,
639                                 texImage->Width, texImage->Height,
640                                 texImage->Depth, texImage->Border,
641                                 texImage->InternalFormat, texFormat);
642
643      stObj->surface_based = GL_FALSE;
644   }
645}
646
647
648/**
649 * Return a writemask for the gallium blit. The parameters can be base
650 * formats or "format" from glDrawPixels/glTexImage/glGetTexImage.
651 */
652unsigned
653st_get_blit_mask(GLenum srcFormat, GLenum dstFormat)
654{
655   switch (dstFormat) {
656   case GL_DEPTH_STENCIL:
657      switch (srcFormat) {
658      case GL_DEPTH_STENCIL:
659         return PIPE_MASK_ZS;
660      case GL_DEPTH_COMPONENT:
661         return PIPE_MASK_Z;
662      case GL_STENCIL_INDEX:
663         return PIPE_MASK_S;
664      default:
665         assert(0);
666         return 0;
667      }
668
669   case GL_DEPTH_COMPONENT:
670      switch (srcFormat) {
671      case GL_DEPTH_STENCIL:
672      case GL_DEPTH_COMPONENT:
673         return PIPE_MASK_Z;
674      default:
675         assert(0);
676         return 0;
677      }
678
679   case GL_STENCIL_INDEX:
680      switch (srcFormat) {
681      case GL_STENCIL_INDEX:
682         return PIPE_MASK_S;
683      default:
684         assert(0);
685         return 0;
686      }
687
688   default:
689      return PIPE_MASK_RGBA;
690   }
691}
692
693void
694st_init_pbo_upload(struct st_context *st)
695{
696   struct pipe_context *pipe = st->pipe;
697   struct pipe_screen *screen = pipe->screen;
698
699   st->pbo_upload.enabled =
700      screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS) &&
701      screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT) >= 1 &&
702      screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS);
703   if (!st->pbo_upload.enabled)
704      return;
705
706   st->pbo_upload.rgba_only =
707      screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY);
708
709   if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {
710      if (screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT)) {
711         st->pbo_upload.upload_layers = true;
712      } else if (screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES) >= 3) {
713         st->pbo_upload.upload_layers = true;
714         st->pbo_upload.use_gs = true;
715      }
716   }
717
718   /* Blend state */
719   memset(&st->pbo_upload.blend, 0, sizeof(struct pipe_blend_state));
720   st->pbo_upload.blend.rt[0].colormask = PIPE_MASK_RGBA;
721
722   /* Rasterizer state */
723   memset(&st->pbo_upload.raster, 0, sizeof(struct pipe_rasterizer_state));
724   st->pbo_upload.raster.half_pixel_center = 1;
725}
726
727void
728st_destroy_pbo_upload(struct st_context *st)
729{
730   if (st->pbo_upload.fs) {
731      cso_delete_fragment_shader(st->cso_context, st->pbo_upload.fs);
732      st->pbo_upload.fs = NULL;
733   }
734
735   if (st->pbo_upload.gs) {
736      cso_delete_geometry_shader(st->cso_context, st->pbo_upload.gs);
737      st->pbo_upload.gs = NULL;
738   }
739
740   if (st->pbo_upload.vs) {
741      cso_delete_vertex_shader(st->cso_context, st->pbo_upload.vs);
742      st->pbo_upload.vs = NULL;
743   }
744}
745
746/**
747 * Converts format to a format with the same components, types
748 * and sizes, but with the components in RGBA order.
749 */
750static enum pipe_format
751unswizzle_format(enum pipe_format format)
752{
753   switch (format)
754   {
755   case PIPE_FORMAT_B8G8R8A8_UNORM:
756   case PIPE_FORMAT_A8R8G8B8_UNORM:
757   case PIPE_FORMAT_A8B8G8R8_UNORM:
758      return PIPE_FORMAT_R8G8B8A8_UNORM;
759
760   case PIPE_FORMAT_B10G10R10A2_UNORM:
761      return PIPE_FORMAT_R10G10B10A2_UNORM;
762
763   case PIPE_FORMAT_B10G10R10A2_SNORM:
764      return PIPE_FORMAT_R10G10B10A2_SNORM;
765
766   case PIPE_FORMAT_B10G10R10A2_UINT:
767      return PIPE_FORMAT_R10G10B10A2_UINT;
768
769   default:
770      return format;
771   }
772}
773
774/**
775 * Converts PIPE_FORMAT_A* to PIPE_FORMAT_R*.
776 */
777static enum pipe_format
778alpha_to_red(enum pipe_format format)
779{
780   switch (format)
781   {
782   case PIPE_FORMAT_A8_UNORM:
783      return PIPE_FORMAT_R8_UNORM;
784   case PIPE_FORMAT_A8_SNORM:
785      return PIPE_FORMAT_R8_SNORM;
786   case PIPE_FORMAT_A8_UINT:
787      return PIPE_FORMAT_R8_UINT;
788   case PIPE_FORMAT_A8_SINT:
789      return PIPE_FORMAT_R8_SINT;
790
791   case PIPE_FORMAT_A16_UNORM:
792      return PIPE_FORMAT_R16_UNORM;
793   case PIPE_FORMAT_A16_SNORM:
794      return PIPE_FORMAT_R16_SNORM;
795   case PIPE_FORMAT_A16_UINT:
796      return PIPE_FORMAT_R16_UINT;
797   case PIPE_FORMAT_A16_SINT:
798      return PIPE_FORMAT_R16_SINT;
799   case PIPE_FORMAT_A16_FLOAT:
800      return PIPE_FORMAT_R16_FLOAT;
801
802   case PIPE_FORMAT_A32_UINT:
803      return PIPE_FORMAT_R32_UINT;
804   case PIPE_FORMAT_A32_SINT:
805      return PIPE_FORMAT_R32_SINT;
806   case PIPE_FORMAT_A32_FLOAT:
807      return PIPE_FORMAT_R32_FLOAT;
808
809   default:
810      return format;
811   }
812}
813
814/**
815 * Converts PIPE_FORMAT_R*A* to PIPE_FORMAT_R*G*.
816 */
817static enum pipe_format
818red_alpha_to_red_green(enum pipe_format format)
819{
820   switch (format)
821   {
822   case PIPE_FORMAT_R8A8_UNORM:
823      return PIPE_FORMAT_R8G8_UNORM;
824   case PIPE_FORMAT_R8A8_SNORM:
825      return PIPE_FORMAT_R8G8_SNORM;
826   case PIPE_FORMAT_R8A8_UINT:
827      return PIPE_FORMAT_R8G8_UINT;
828   case PIPE_FORMAT_R8A8_SINT:
829      return PIPE_FORMAT_R8G8_SINT;
830
831   case PIPE_FORMAT_R16A16_UNORM:
832      return PIPE_FORMAT_R16G16_UNORM;
833   case PIPE_FORMAT_R16A16_SNORM:
834      return PIPE_FORMAT_R16G16_SNORM;
835   case PIPE_FORMAT_R16A16_UINT:
836      return PIPE_FORMAT_R16G16_UINT;
837   case PIPE_FORMAT_R16A16_SINT:
838      return PIPE_FORMAT_R16G16_SINT;
839   case PIPE_FORMAT_R16A16_FLOAT:
840      return PIPE_FORMAT_R16G16_FLOAT;
841
842   case PIPE_FORMAT_R32A32_UINT:
843      return PIPE_FORMAT_R32G32_UINT;
844   case PIPE_FORMAT_R32A32_SINT:
845      return PIPE_FORMAT_R32G32_SINT;
846   case PIPE_FORMAT_R32A32_FLOAT:
847      return PIPE_FORMAT_R32G32_FLOAT;
848
849   default:
850       return format;
851   }
852}
853
854/**
855 * Converts PIPE_FORMAT_L*A* to PIPE_FORMAT_R*G*.
856 */
857static enum pipe_format
858luminance_alpha_to_red_green(enum pipe_format format)
859{
860   switch (format)
861   {
862   case PIPE_FORMAT_L8A8_UNORM:
863      return PIPE_FORMAT_R8G8_UNORM;
864   case PIPE_FORMAT_L8A8_SNORM:
865      return PIPE_FORMAT_R8G8_SNORM;
866   case PIPE_FORMAT_L8A8_UINT:
867      return PIPE_FORMAT_R8G8_UINT;
868   case PIPE_FORMAT_L8A8_SINT:
869      return PIPE_FORMAT_R8G8_SINT;
870
871   case PIPE_FORMAT_L16A16_UNORM:
872      return PIPE_FORMAT_R16G16_UNORM;
873   case PIPE_FORMAT_L16A16_SNORM:
874      return PIPE_FORMAT_R16G16_SNORM;
875   case PIPE_FORMAT_L16A16_UINT:
876      return PIPE_FORMAT_R16G16_UINT;
877   case PIPE_FORMAT_L16A16_SINT:
878      return PIPE_FORMAT_R16G16_SINT;
879   case PIPE_FORMAT_L16A16_FLOAT:
880      return PIPE_FORMAT_R16G16_FLOAT;
881
882   case PIPE_FORMAT_L32A32_UINT:
883      return PIPE_FORMAT_R32G32_UINT;
884   case PIPE_FORMAT_L32A32_SINT:
885      return PIPE_FORMAT_R32G32_SINT;
886   case PIPE_FORMAT_L32A32_FLOAT:
887      return PIPE_FORMAT_R32G32_FLOAT;
888
889   default:
890       return format;
891   }
892}
893
894/**
895 * Returns true if format is a PIPE_FORMAT_A* format, and false otherwise.
896 */
897static bool
898format_is_alpha(enum pipe_format format)
899{
900   const struct util_format_description *desc = util_format_description(format);
901
902   if (desc->nr_channels == 1 &&
903       desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_0 &&
904       desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_0 &&
905       desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_0 &&
906       desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_X)
907      return true;
908
909   return false;
910}
911
912/**
913 * Returns true if format is a PIPE_FORMAT_R* format, and false otherwise.
914 */
915static bool
916format_is_red(enum pipe_format format)
917{
918   const struct util_format_description *desc = util_format_description(format);
919
920   if (desc->nr_channels == 1 &&
921       desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
922       desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_0 &&
923       desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_0 &&
924       desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1)
925      return true;
926
927   return false;
928}
929
930
931/**
932 * Returns true if format is a PIPE_FORMAT_L* format, and false otherwise.
933 */
934static bool
935format_is_luminance(enum pipe_format format)
936{
937   const struct util_format_description *desc = util_format_description(format);
938
939   if (desc->nr_channels == 1 &&
940       desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
941       desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X &&
942       desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X &&
943       desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1)
944      return true;
945
946   return false;
947}
948
949/**
950 * Returns true if format is a PIPE_FORMAT_R*A* format, and false otherwise.
951 */
952static bool
953format_is_red_alpha(enum pipe_format format)
954{
955   const struct util_format_description *desc = util_format_description(format);
956
957   if (desc->nr_channels == 2 &&
958       desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
959       desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_0 &&
960       desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_0 &&
961       desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_Y)
962      return true;
963
964   return false;
965}
966
967static bool
968format_is_swizzled_rgba(enum pipe_format format)
969{
970    const struct util_format_description *desc = util_format_description(format);
971
972    if ((desc->swizzle[0] == TGSI_SWIZZLE_X || desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_0) &&
973        (desc->swizzle[1] == TGSI_SWIZZLE_Y || desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_0) &&
974        (desc->swizzle[2] == TGSI_SWIZZLE_Z || desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_0) &&
975        (desc->swizzle[3] == TGSI_SWIZZLE_W || desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1))
976       return false;
977
978    return true;
979}
980
981struct format_table
982{
983   unsigned char swizzle[4];
984   enum pipe_format format;
985};
986
987static const struct format_table table_8888_unorm[] = {
988   { { 0, 1, 2, 3 }, PIPE_FORMAT_R8G8B8A8_UNORM },
989   { { 2, 1, 0, 3 }, PIPE_FORMAT_B8G8R8A8_UNORM },
990   { { 3, 0, 1, 2 }, PIPE_FORMAT_A8R8G8B8_UNORM },
991   { { 3, 2, 1, 0 }, PIPE_FORMAT_A8B8G8R8_UNORM }
992};
993
994static const struct format_table table_1010102_unorm[] = {
995   { { 0, 1, 2, 3 }, PIPE_FORMAT_R10G10B10A2_UNORM },
996   { { 2, 1, 0, 3 }, PIPE_FORMAT_B10G10R10A2_UNORM }
997};
998
999static const struct format_table table_1010102_snorm[] = {
1000   { { 0, 1, 2, 3 }, PIPE_FORMAT_R10G10B10A2_SNORM },
1001   { { 2, 1, 0, 3 }, PIPE_FORMAT_B10G10R10A2_SNORM }
1002};
1003
1004static const struct format_table table_1010102_uint[] = {
1005   { { 0, 1, 2, 3 }, PIPE_FORMAT_R10G10B10A2_UINT },
1006   { { 2, 1, 0, 3 }, PIPE_FORMAT_B10G10R10A2_UINT }
1007};
1008
1009static enum pipe_format
1010swizzle_format(enum pipe_format format, const int * const swizzle)
1011{
1012   unsigned i;
1013
1014   switch (format) {
1015   case PIPE_FORMAT_R8G8B8A8_UNORM:
1016   case PIPE_FORMAT_B8G8R8A8_UNORM:
1017   case PIPE_FORMAT_A8R8G8B8_UNORM:
1018   case PIPE_FORMAT_A8B8G8R8_UNORM:
1019      for (i = 0; i < ARRAY_SIZE(table_8888_unorm); i++) {
1020         if (swizzle[0] == table_8888_unorm[i].swizzle[0] &&
1021             swizzle[1] == table_8888_unorm[i].swizzle[1] &&
1022             swizzle[2] == table_8888_unorm[i].swizzle[2] &&
1023             swizzle[3] == table_8888_unorm[i].swizzle[3])
1024            return table_8888_unorm[i].format;
1025      }
1026      break;
1027
1028   case PIPE_FORMAT_R10G10B10A2_UNORM:
1029   case PIPE_FORMAT_B10G10R10A2_UNORM:
1030      for (i = 0; i < ARRAY_SIZE(table_1010102_unorm); i++) {
1031         if (swizzle[0] == table_1010102_unorm[i].swizzle[0] &&
1032             swizzle[1] == table_1010102_unorm[i].swizzle[1] &&
1033             swizzle[2] == table_1010102_unorm[i].swizzle[2] &&
1034             swizzle[3] == table_1010102_unorm[i].swizzle[3])
1035            return table_1010102_unorm[i].format;
1036      }
1037      break;
1038
1039   case PIPE_FORMAT_R10G10B10A2_SNORM:
1040   case PIPE_FORMAT_B10G10R10A2_SNORM:
1041      for (i = 0; i < ARRAY_SIZE(table_1010102_snorm); i++) {
1042         if (swizzle[0] == table_1010102_snorm[i].swizzle[0] &&
1043             swizzle[1] == table_1010102_snorm[i].swizzle[1] &&
1044             swizzle[2] == table_1010102_snorm[i].swizzle[2] &&
1045             swizzle[3] == table_1010102_snorm[i].swizzle[3])
1046            return table_1010102_snorm[i].format;
1047      }
1048      break;
1049
1050   case PIPE_FORMAT_R10G10B10A2_UINT:
1051   case PIPE_FORMAT_B10G10R10A2_UINT:
1052      for (i = 0; i < ARRAY_SIZE(table_1010102_uint); i++) {
1053         if (swizzle[0] == table_1010102_uint[i].swizzle[0] &&
1054             swizzle[1] == table_1010102_uint[i].swizzle[1] &&
1055             swizzle[2] == table_1010102_uint[i].swizzle[2] &&
1056             swizzle[3] == table_1010102_uint[i].swizzle[3])
1057            return table_1010102_uint[i].format;
1058      }
1059      break;
1060
1061   default:
1062      break;
1063   }
1064
1065   return PIPE_FORMAT_NONE;
1066}
1067
1068static bool
1069reinterpret_formats(enum pipe_format *src_format, enum pipe_format *dst_format)
1070{
1071   enum pipe_format src = *src_format;
1072   enum pipe_format dst = *dst_format;
1073
1074   /* Note: dst_format has already been transformed from luminance/intensity
1075    *       to red when this function is called.  The source format will never
1076    *       be an intensity format, because GL_INTENSITY is not a legal value
1077    *       for the format parameter in glTex(Sub)Image(). */
1078
1079   if (format_is_alpha(src)) {
1080      if (!format_is_alpha(dst))
1081         return false;
1082
1083      src = alpha_to_red(src);
1084      dst = alpha_to_red(dst);
1085   } else if (format_is_luminance(src)) {
1086      if (!format_is_red(dst) && !format_is_red_alpha(dst))
1087         return false;
1088
1089      src = util_format_luminance_to_red(src);
1090   } else if (util_format_is_luminance_alpha(src)) {
1091      src = luminance_alpha_to_red_green(src);
1092
1093      if (format_is_red_alpha(dst)) {
1094         dst = red_alpha_to_red_green(dst);
1095      } else if (!format_is_red(dst))
1096         return false;
1097   } else if (format_is_swizzled_rgba(src)) {
1098      const struct util_format_description *src_desc = util_format_description(src);
1099      const struct util_format_description *dst_desc = util_format_description(dst);
1100      int swizzle[4];
1101      unsigned i;
1102
1103      /* Make sure the format is an RGBA and not an RGBX format */
1104      if (src_desc->nr_channels != 4 || src_desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1)
1105         return false;
1106
1107      if (dst_desc->nr_channels != 4 || dst_desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1)
1108         return false;
1109
1110      for (i = 0; i < 4; i++)
1111         swizzle[i] = dst_desc->swizzle[src_desc->swizzle[i]];
1112
1113      dst = swizzle_format(dst, swizzle);
1114      if (dst == PIPE_FORMAT_NONE)
1115         return false;
1116
1117      src = unswizzle_format(src);
1118   }
1119
1120   *src_format = src;
1121   *dst_format = dst;
1122   return true;
1123}
1124
1125static void *
1126create_pbo_upload_vs(struct st_context *st)
1127{
1128   struct ureg_program *ureg;
1129   struct ureg_src in_pos;
1130   struct ureg_src in_instanceid;
1131   struct ureg_dst out_pos;
1132   struct ureg_dst out_layer;
1133
1134   ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
1135   if (!ureg)
1136      return NULL;
1137
1138   in_pos = ureg_DECL_vs_input(ureg, TGSI_SEMANTIC_POSITION);
1139
1140   out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
1141
1142   if (st->pbo_upload.upload_layers) {
1143      in_instanceid = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_INSTANCEID, 0);
1144
1145      if (!st->pbo_upload.use_gs)
1146         out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);
1147   }
1148
1149   /* out_pos = in_pos */
1150   ureg_MOV(ureg, out_pos, in_pos);
1151
1152   if (st->pbo_upload.upload_layers) {
1153      if (st->pbo_upload.use_gs) {
1154         /* out_pos.z = i2f(gl_InstanceID) */
1155         ureg_I2F(ureg, ureg_writemask(out_pos, TGSI_WRITEMASK_Z),
1156                        ureg_scalar(in_instanceid, TGSI_SWIZZLE_X));
1157      } else {
1158         /* out_layer = gl_InstanceID */
1159         ureg_MOV(ureg, out_layer, in_instanceid);
1160      }
1161   }
1162
1163   ureg_END(ureg);
1164
1165   return ureg_create_shader_and_destroy(ureg, st->pipe);
1166}
1167
1168static void *
1169create_pbo_upload_gs(struct st_context *st)
1170{
1171   static const int zero = 0;
1172   struct ureg_program *ureg;
1173   struct ureg_dst out_pos;
1174   struct ureg_dst out_layer;
1175   struct ureg_src in_pos;
1176   struct ureg_src imm;
1177   unsigned i;
1178
1179   ureg = ureg_create(TGSI_PROCESSOR_GEOMETRY);
1180   if (!ureg)
1181      return NULL;
1182
1183   ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, PIPE_PRIM_TRIANGLES);
1184   ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, PIPE_PRIM_TRIANGLE_STRIP);
1185   ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES, 3);
1186
1187   out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
1188   out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);
1189
1190   in_pos = ureg_DECL_input(ureg, TGSI_SEMANTIC_POSITION, 0, 0, 1);
1191
1192   imm = ureg_DECL_immediate_int(ureg, &zero, 1);
1193
1194   for (i = 0; i < 3; ++i) {
1195      struct ureg_src in_pos_vertex = ureg_src_dimension(in_pos, i);
1196
1197      /* out_pos = in_pos[i] */
1198      ureg_MOV(ureg, out_pos, in_pos_vertex);
1199
1200      /* out_layer.x = f2i(in_pos[i].z) */
1201      ureg_F2I(ureg, ureg_writemask(out_layer, TGSI_WRITEMASK_X),
1202                     ureg_scalar(in_pos_vertex, TGSI_SWIZZLE_Z));
1203
1204      ureg_EMIT(ureg, ureg_scalar(imm, TGSI_SWIZZLE_X));
1205   }
1206
1207   ureg_END(ureg);
1208
1209   return ureg_create_shader_and_destroy(ureg, st->pipe);
1210}
1211
1212static void *
1213create_pbo_upload_fs(struct st_context *st)
1214{
1215   struct pipe_context *pipe = st->pipe;
1216   struct pipe_screen *screen = pipe->screen;
1217   struct ureg_program *ureg;
1218   struct ureg_dst out;
1219   struct ureg_src sampler;
1220   struct ureg_src pos;
1221   struct ureg_src layer;
1222   struct ureg_src const0;
1223   struct ureg_dst temp0;
1224
1225   ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
1226   if (!ureg)
1227      return NULL;
1228
1229   out     = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
1230   sampler = ureg_DECL_sampler(ureg, 0);
1231   if (screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL)) {
1232      pos = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_POSITION, 0);
1233   } else {
1234      pos = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_POSITION, 0,
1235                               TGSI_INTERPOLATE_LINEAR);
1236   }
1237   if (st->pbo_upload.upload_layers) {
1238      layer = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_LAYER, 0,
1239                                       TGSI_INTERPOLATE_CONSTANT);
1240   }
1241   const0  = ureg_DECL_constant(ureg, 0);
1242   temp0   = ureg_DECL_temporary(ureg);
1243
1244   /* Note: const0 = [ -xoffset + skip_pixels, -yoffset, stride, image_height ] */
1245
1246   /* temp0.xy = f2i(temp0.xy) */
1247   ureg_F2I(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
1248                  ureg_swizzle(pos,
1249                               TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
1250                               TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y));
1251
1252   /* temp0.xy = temp0.xy + const0.xy */
1253   ureg_UADD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
1254                   ureg_swizzle(ureg_src(temp0),
1255                                TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
1256                                TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y),
1257                   ureg_swizzle(const0,
1258                                TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
1259                                TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y));
1260
1261   /* temp0.x = const0.z * temp0.y + temp0.x */
1262   ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
1263                   ureg_scalar(const0, TGSI_SWIZZLE_Z),
1264                   ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_Y),
1265                   ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
1266
1267   if (st->pbo_upload.upload_layers) {
1268      /* temp0.x = const0.w * layer + temp0.x */
1269      ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
1270                      ureg_scalar(const0, TGSI_SWIZZLE_W),
1271                      ureg_scalar(layer, TGSI_SWIZZLE_X),
1272                      ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
1273   }
1274
1275   /* out = txf(sampler, temp0.x) */
1276   ureg_TXF(ureg, out, TGSI_TEXTURE_BUFFER,
1277                  ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X),
1278                  sampler);
1279
1280   ureg_release_temporary(ureg, temp0);
1281
1282   ureg_END(ureg);
1283
1284   return ureg_create_shader_and_destroy(ureg, pipe);
1285}
1286
1287static bool
1288try_pbo_upload_common(struct gl_context *ctx,
1289                      struct pipe_surface *surface,
1290                      int xoffset, int yoffset,
1291                      unsigned upload_width, unsigned upload_height,
1292                      struct pipe_resource *buffer,
1293                      enum pipe_format src_format,
1294                      intptr_t buf_offset,
1295                      unsigned bytes_per_pixel,
1296                      unsigned stride,
1297                      unsigned image_height)
1298{
1299   struct st_context *st = st_context(ctx);
1300   struct cso_context *cso = st->cso_context;
1301   struct pipe_context *pipe = st->pipe;
1302   unsigned depth = surface->u.tex.last_layer - surface->u.tex.first_layer + 1;
1303   unsigned skip_pixels = 0;
1304   bool success = false;
1305
1306   /* Check alignment. */
1307   {
1308      unsigned ofs = (buf_offset * bytes_per_pixel) % ctx->Const.TextureBufferOffsetAlignment;
1309      if (ofs != 0) {
1310         if (ofs % bytes_per_pixel != 0)
1311            return false;
1312
1313         skip_pixels = ofs / bytes_per_pixel;
1314         buf_offset -= skip_pixels;
1315      }
1316   }
1317
1318   /* Create the shaders */
1319   if (!st->pbo_upload.vs) {
1320      st->pbo_upload.vs = create_pbo_upload_vs(st);
1321      if (!st->pbo_upload.vs)
1322         return false;
1323   }
1324
1325   if (depth != 1 && st->pbo_upload.use_gs && !st->pbo_upload.gs) {
1326      st->pbo_upload.gs = create_pbo_upload_gs(st);
1327      if (!st->pbo_upload.gs)
1328         return false;
1329   }
1330
1331   if (!st->pbo_upload.fs) {
1332      st->pbo_upload.fs = create_pbo_upload_fs(st);
1333      if (!st->pbo_upload.fs)
1334         return false;
1335   }
1336
1337   cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
1338                        CSO_BIT_VERTEX_ELEMENTS |
1339                        CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
1340                        CSO_BIT_FRAMEBUFFER |
1341                        CSO_BIT_VIEWPORT |
1342                        CSO_BIT_BLEND |
1343                        CSO_BIT_RASTERIZER |
1344                        CSO_BIT_VERTEX_SHADER |
1345                        CSO_BIT_GEOMETRY_SHADER |
1346                        CSO_BIT_TESSCTRL_SHADER |
1347                        CSO_BIT_TESSEVAL_SHADER |
1348                        CSO_BIT_FRAGMENT_SHADER |
1349                        CSO_BIT_STREAM_OUTPUTS));
1350   cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
1351
1352
1353   /* Set up the sampler_view */
1354   {
1355      unsigned first_element = buf_offset;
1356      unsigned last_element = buf_offset + skip_pixels + upload_width - 1
1357         + (upload_height - 1 + (depth - 1) * image_height) * stride;
1358      struct pipe_sampler_view templ;
1359      struct pipe_sampler_view *sampler_view;
1360
1361      /* This should be ensured by Mesa before calling our callbacks */
1362      assert((last_element + 1) * bytes_per_pixel <= buffer->width0);
1363
1364      if (last_element - first_element > ctx->Const.MaxTextureBufferSize - 1)
1365         goto fail;
1366
1367      memset(&templ, 0, sizeof(templ));
1368      templ.format = src_format;
1369      templ.u.buf.first_element = first_element;
1370      templ.u.buf.last_element = last_element;
1371      templ.swizzle_r = PIPE_SWIZZLE_RED;
1372      templ.swizzle_g = PIPE_SWIZZLE_GREEN;
1373      templ.swizzle_b = PIPE_SWIZZLE_BLUE;
1374      templ.swizzle_a = PIPE_SWIZZLE_ALPHA;
1375
1376      sampler_view = pipe->create_sampler_view(pipe, buffer, &templ);
1377      if (sampler_view == NULL)
1378         goto fail;
1379
1380      cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view);
1381
1382      pipe_sampler_view_reference(&sampler_view, NULL);
1383   }
1384
1385   /* Upload vertices */
1386   {
1387      struct pipe_vertex_buffer vbo;
1388      struct pipe_vertex_element velem;
1389
1390      float x0 = (float) xoffset / surface->width * 2.0f - 1.0f;
1391      float y0 = (float) yoffset / surface->height * 2.0f - 1.0f;
1392      float x1 = (float) (xoffset + upload_width) / surface->width * 2.0f - 1.0f;
1393      float y1 = (float) (yoffset + upload_height) / surface->height * 2.0f - 1.0f;
1394
1395      float *verts = NULL;
1396
1397      vbo.user_buffer = NULL;
1398      vbo.buffer = NULL;
1399      vbo.stride = 2 * sizeof(float);
1400
1401      u_upload_alloc(st->uploader, 0, 8 * sizeof(float), 4,
1402                     &vbo.buffer_offset, &vbo.buffer, (void **) &verts);
1403      if (!verts)
1404         goto fail;
1405
1406      verts[0] = x0;
1407      verts[1] = y0;
1408      verts[2] = x0;
1409      verts[3] = y1;
1410      verts[4] = x1;
1411      verts[5] = y0;
1412      verts[6] = x1;
1413      verts[7] = y1;
1414
1415      u_upload_unmap(st->uploader);
1416
1417      velem.src_offset = 0;
1418      velem.instance_divisor = 0;
1419      velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
1420      velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
1421
1422      cso_set_vertex_elements(cso, 1, &velem);
1423
1424      cso_set_vertex_buffers(cso, velem.vertex_buffer_index, 1, &vbo);
1425
1426      pipe_resource_reference(&vbo.buffer, NULL);
1427   }
1428
1429   /* Upload constants */
1430   {
1431      struct pipe_constant_buffer cb;
1432
1433      struct {
1434         int32_t xoffset;
1435         int32_t yoffset;
1436         int32_t stride;
1437         int32_t image_size;
1438      } constants;
1439
1440      constants.xoffset = -xoffset + skip_pixels;
1441      constants.yoffset = -yoffset;
1442      constants.stride = stride;
1443      constants.image_size = stride * image_height;
1444
1445      if (st->constbuf_uploader) {
1446         cb.buffer = NULL;
1447         cb.user_buffer = NULL;
1448         u_upload_data(st->constbuf_uploader, 0, sizeof(constants),
1449                       st->ctx->Const.UniformBufferOffsetAlignment,
1450                       &constants, &cb.buffer_offset, &cb.buffer);
1451         if (!cb.buffer)
1452            goto fail;
1453
1454         u_upload_unmap(st->constbuf_uploader);
1455      } else {
1456         cb.buffer = NULL;
1457         cb.user_buffer = &constants;
1458         cb.buffer_offset = 0;
1459      }
1460      cb.buffer_size = sizeof(constants);
1461
1462      cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
1463
1464      pipe_resource_reference(&cb.buffer, NULL);
1465   }
1466
1467   /* Framebuffer_state */
1468   {
1469      struct pipe_framebuffer_state fb;
1470      memset(&fb, 0, sizeof(fb));
1471      fb.width = surface->width;
1472      fb.height = surface->height;
1473      fb.nr_cbufs = 1;
1474      pipe_surface_reference(&fb.cbufs[0], surface);
1475
1476      cso_set_framebuffer(cso, &fb);
1477
1478      pipe_surface_reference(&fb.cbufs[0], NULL);
1479   }
1480
1481   /* Viewport state */
1482   {
1483      struct pipe_viewport_state vp;
1484      vp.scale[0] = 0.5f * surface->width;
1485      vp.scale[1] = 0.5f * surface->height;
1486      vp.scale[2] = 1.0f;
1487      vp.translate[0] = 0.5f * surface->width;
1488      vp.translate[1] = 0.5f * surface->height;
1489      vp.translate[2] = 0.0f;
1490
1491      cso_set_viewport(cso, &vp);
1492   }
1493
1494   /* Blend state */
1495   cso_set_blend(cso, &st->pbo_upload.blend);
1496
1497   /* Rasterizer state */
1498   cso_set_rasterizer(cso, &st->pbo_upload.raster);
1499
1500   /* Set up the shaders */
1501   cso_set_vertex_shader_handle(cso, st->pbo_upload.vs);
1502
1503   cso_set_geometry_shader_handle(cso, depth != 1 ? st->pbo_upload.gs : NULL);
1504
1505   cso_set_tessctrl_shader_handle(cso, NULL);
1506
1507   cso_set_tesseval_shader_handle(cso, NULL);
1508
1509   cso_set_fragment_shader_handle(cso, st->pbo_upload.fs);
1510
1511   /* Disable stream output */
1512   cso_set_stream_outputs(cso, 0, NULL, 0);
1513
1514   if (depth == 1) {
1515      cso_draw_arrays(cso, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
1516   } else {
1517      cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_STRIP,
1518                                0, 4, 0, depth);
1519   }
1520
1521   success = true;
1522
1523fail:
1524   cso_restore_state(cso);
1525   cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
1526
1527   return success;
1528}
1529
1530static bool
1531try_pbo_upload(struct gl_context *ctx, GLuint dims,
1532               struct gl_texture_image *texImage,
1533               GLenum format, GLenum type,
1534               enum pipe_format dst_format,
1535               GLint xoffset, GLint yoffset, GLint zoffset,
1536               GLint width, GLint height, GLint depth,
1537               const void *pixels,
1538               const struct gl_pixelstore_attrib *unpack)
1539{
1540   struct st_context *st = st_context(ctx);
1541   struct st_texture_image *stImage = st_texture_image(texImage);
1542   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1543   struct pipe_resource *texture = stImage->pt;
1544   struct pipe_context *pipe = st->pipe;
1545   struct pipe_screen *screen = pipe->screen;
1546   struct pipe_surface *surface = NULL;
1547   enum pipe_format src_format;
1548   const struct util_format_description *desc;
1549   GLenum gl_target = texImage->TexObject->Target;
1550   intptr_t buf_offset;
1551   unsigned bytes_per_pixel;
1552   unsigned stride, image_height;
1553   bool success;
1554
1555   if (!st->pbo_upload.enabled)
1556      return false;
1557
1558   /* From now on, we need the gallium representation of dimensions. */
1559   if (gl_target == GL_TEXTURE_1D_ARRAY) {
1560      depth = height;
1561      height = 1;
1562      zoffset = yoffset;
1563      yoffset = 0;
1564      image_height = 1;
1565   } else {
1566      image_height = unpack->ImageHeight > 0 ? unpack->ImageHeight : height;
1567   }
1568
1569   if (depth != 1 && !st->pbo_upload.upload_layers)
1570      return false;
1571
1572   /* Choose the source format. Initially, we do so without checking driver
1573    * support at all because of the remapping we later perform and because
1574    * at least the Radeon driver actually supports some formats for texture
1575    * buffers which it doesn't support for regular textures. */
1576   src_format = st_choose_matching_format(st, 0, format, type, unpack->SwapBytes);
1577   if (!src_format) {
1578      return false;
1579   }
1580
1581   src_format = util_format_linear(src_format);
1582   desc = util_format_description(src_format);
1583
1584   if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
1585      return false;
1586
1587   if (desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB)
1588      return false;
1589
1590   if (st->pbo_upload.rgba_only) {
1591      enum pipe_format orig_dst_format = dst_format;
1592
1593      if (!reinterpret_formats(&src_format, &dst_format)) {
1594         return false;
1595      }
1596
1597      if (dst_format != orig_dst_format &&
1598          !screen->is_format_supported(screen, dst_format, PIPE_TEXTURE_2D, 0,
1599                                       PIPE_BIND_RENDER_TARGET)) {
1600         return false;
1601      }
1602   }
1603
1604   if (!src_format ||
1605       !screen->is_format_supported(screen, src_format, PIPE_BUFFER, 0,
1606                                    PIPE_BIND_SAMPLER_VIEW)) {
1607      return false;
1608   }
1609
1610   /* Check if the offset satisfies the alignment requirements */
1611   buf_offset = (intptr_t) pixels;
1612   bytes_per_pixel = desc->block.bits / 8;
1613
1614   if (buf_offset % bytes_per_pixel) {
1615      return false;
1616   }
1617
1618   /* Convert to texels */
1619   buf_offset = buf_offset / bytes_per_pixel;
1620
1621   /* Compute the stride, taking unpack->Alignment into account */
1622   {
1623       unsigned pixels_per_row = unpack->RowLength > 0 ?
1624                           unpack->RowLength : width;
1625       unsigned bytes_per_row = pixels_per_row * bytes_per_pixel;
1626       unsigned remainder = bytes_per_row % unpack->Alignment;
1627       unsigned offset_rows;
1628
1629       if (remainder > 0)
1630          bytes_per_row += (unpack->Alignment - remainder);
1631
1632       if (bytes_per_row % bytes_per_pixel) {
1633          return false;
1634       }
1635
1636       stride = bytes_per_row / bytes_per_pixel;
1637
1638       offset_rows = unpack->SkipRows;
1639       if (dims == 3)
1640          offset_rows += image_height * unpack->SkipImages;
1641
1642       buf_offset += unpack->SkipPixels + stride * offset_rows;
1643   }
1644
1645   /* Set up the surface */
1646   {
1647      unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
1648      unsigned max_layer = util_max_layer(texture, level);
1649
1650      zoffset += texImage->Face + texImage->TexObject->MinLayer;
1651
1652      struct pipe_surface templ;
1653      memset(&templ, 0, sizeof(templ));
1654      templ.format = dst_format;
1655      templ.u.tex.level = level;
1656      templ.u.tex.first_layer = MIN2(zoffset, max_layer);
1657      templ.u.tex.last_layer = MIN2(zoffset + depth - 1, max_layer);
1658
1659      surface = pipe->create_surface(pipe, texture, &templ);
1660      if (!surface)
1661         return false;
1662   }
1663
1664   success = try_pbo_upload_common(ctx,  surface,
1665                                   xoffset, yoffset, width, height,
1666                                   st_buffer_object(unpack->BufferObj)->buffer,
1667                                   src_format,
1668                                   buf_offset,
1669                                   bytes_per_pixel, stride, image_height);
1670
1671   pipe_surface_reference(&surface, NULL);
1672
1673   return success;
1674}
1675
1676static void
1677st_TexSubImage(struct gl_context *ctx, GLuint dims,
1678               struct gl_texture_image *texImage,
1679               GLint xoffset, GLint yoffset, GLint zoffset,
1680               GLint width, GLint height, GLint depth,
1681               GLenum format, GLenum type, const void *pixels,
1682               const struct gl_pixelstore_attrib *unpack)
1683{
1684   struct st_context *st = st_context(ctx);
1685   struct st_texture_image *stImage = st_texture_image(texImage);
1686   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1687   struct pipe_context *pipe = st->pipe;
1688   struct pipe_screen *screen = pipe->screen;
1689   struct pipe_resource *dst = stImage->pt;
1690   struct pipe_resource *src = NULL;
1691   struct pipe_resource src_templ;
1692   struct pipe_transfer *transfer;
1693   struct pipe_blit_info blit;
1694   enum pipe_format src_format, dst_format;
1695   mesa_format mesa_src_format;
1696   GLenum gl_target = texImage->TexObject->Target;
1697   unsigned bind;
1698   GLubyte *map;
1699
1700   assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
1701          texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
1702
1703   if (!st->prefer_blit_based_texture_transfer) {
1704      goto fallback;
1705   }
1706
1707   if (!dst) {
1708      goto fallback;
1709   }
1710
1711   /* XXX Fallback for depth-stencil formats due to an incomplete stencil
1712    * blit implementation in some drivers. */
1713   if (format == GL_DEPTH_STENCIL) {
1714      goto fallback;
1715   }
1716
1717   /* If the base internal format and the texture format don't match,
1718    * we can't use blit-based TexSubImage. */
1719   if (texImage->_BaseFormat !=
1720       _mesa_get_format_base_format(texImage->TexFormat)) {
1721      goto fallback;
1722   }
1723
1724
1725   /* See if the destination format is supported. */
1726   if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
1727      bind = PIPE_BIND_DEPTH_STENCIL;
1728   else
1729      bind = PIPE_BIND_RENDER_TARGET;
1730
1731   /* For luminance and intensity, only the red channel is stored
1732    * in the destination. */
1733   dst_format = util_format_linear(dst->format);
1734   dst_format = util_format_luminance_to_red(dst_format);
1735   dst_format = util_format_intensity_to_red(dst_format);
1736
1737   if (!dst_format ||
1738       !screen->is_format_supported(screen, dst_format, dst->target,
1739                                    dst->nr_samples, bind)) {
1740      goto fallback;
1741   }
1742
1743   if (_mesa_is_bufferobj(unpack->BufferObj)) {
1744      if (try_pbo_upload(ctx, dims, texImage, format, type, dst_format,
1745                         xoffset, yoffset, zoffset,
1746                         width, height, depth, pixels, unpack))
1747         return;
1748   }
1749
1750   /* See if the texture format already matches the format and type,
1751    * in which case the memcpy-based fast path will likely be used and
1752    * we don't have to blit. */
1753   if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
1754                                            type, unpack->SwapBytes, NULL)) {
1755      goto fallback;
1756   }
1757
1758   /* Choose the source format. */
1759   src_format = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
1760                                          format, type, unpack->SwapBytes);
1761   if (!src_format) {
1762      goto fallback;
1763   }
1764
1765   mesa_src_format = st_pipe_format_to_mesa_format(src_format);
1766
1767   /* There is no reason to do this if we cannot use memcpy for the temporary
1768    * source texture at least. This also takes transfer ops into account,
1769    * etc. */
1770   if (!_mesa_texstore_can_use_memcpy(ctx,
1771                             _mesa_get_format_base_format(mesa_src_format),
1772                             mesa_src_format, format, type, unpack)) {
1773      goto fallback;
1774   }
1775
1776   /* TexSubImage only sets a single cubemap face. */
1777   if (gl_target == GL_TEXTURE_CUBE_MAP) {
1778      gl_target = GL_TEXTURE_2D;
1779   }
1780   /* TexSubImage can specify subsets of cube map array faces
1781    * so we need to upload via 2D array instead */
1782   if (gl_target == GL_TEXTURE_CUBE_MAP_ARRAY) {
1783      gl_target = GL_TEXTURE_2D_ARRAY;
1784   }
1785
1786   /* Initialize the source texture description. */
1787   memset(&src_templ, 0, sizeof(src_templ));
1788   src_templ.target = gl_target_to_pipe(gl_target);
1789   src_templ.format = src_format;
1790   src_templ.bind = PIPE_BIND_SAMPLER_VIEW;
1791   src_templ.usage = PIPE_USAGE_STAGING;
1792
1793   st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
1794                                   &src_templ.width0, &src_templ.height0,
1795                                   &src_templ.depth0, &src_templ.array_size);
1796
1797   /* Check for NPOT texture support. */
1798   if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
1799       (!util_is_power_of_two(src_templ.width0) ||
1800        !util_is_power_of_two(src_templ.height0) ||
1801        !util_is_power_of_two(src_templ.depth0))) {
1802      goto fallback;
1803   }
1804
1805   /* Create the source texture. */
1806   src = screen->resource_create(screen, &src_templ);
1807   if (!src) {
1808      goto fallback;
1809   }
1810
1811   /* Map source pixels. */
1812   pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
1813                                        format, type, pixels, unpack,
1814                                        "glTexSubImage");
1815   if (!pixels) {
1816      /* This is a GL error. */
1817      pipe_resource_reference(&src, NULL);
1818      return;
1819   }
1820
1821   /* From now on, we need the gallium representation of dimensions. */
1822   if (gl_target == GL_TEXTURE_1D_ARRAY) {
1823      zoffset = yoffset;
1824      yoffset = 0;
1825      depth = height;
1826      height = 1;
1827   }
1828
1829   map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0,
1830                              width, height, depth, &transfer);
1831   if (!map) {
1832      _mesa_unmap_teximage_pbo(ctx, unpack);
1833      pipe_resource_reference(&src, NULL);
1834      goto fallback;
1835   }
1836
1837   /* Upload pixels (just memcpy). */
1838   {
1839      const uint bytesPerRow = width * util_format_get_blocksize(src_format);
1840      GLuint row, slice;
1841
1842      for (slice = 0; slice < (unsigned) depth; slice++) {
1843         if (gl_target == GL_TEXTURE_1D_ARRAY) {
1844            /* 1D array textures.
1845             * We need to convert gallium coords to GL coords.
1846             */
1847            GLvoid *src = _mesa_image_address2d(unpack, pixels,
1848                                                width, depth, format,
1849                                                type, slice, 0);
1850            memcpy(map, src, bytesPerRow);
1851         }
1852         else {
1853            ubyte *slice_map = map;
1854
1855            for (row = 0; row < (unsigned) height; row++) {
1856               GLvoid *src = _mesa_image_address(dims, unpack, pixels,
1857                                                 width, height, format,
1858                                                 type, slice, row, 0);
1859               memcpy(slice_map, src, bytesPerRow);
1860               slice_map += transfer->stride;
1861            }
1862         }
1863         map += transfer->layer_stride;
1864      }
1865   }
1866
1867   pipe_transfer_unmap(pipe, transfer);
1868   _mesa_unmap_teximage_pbo(ctx, unpack);
1869
1870   /* Blit. */
1871   memset(&blit, 0, sizeof(blit));
1872   blit.src.resource = src;
1873   blit.src.level = 0;
1874   blit.src.format = src_format;
1875   blit.dst.resource = dst;
1876   blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
1877   blit.dst.format = dst_format;
1878   blit.src.box.x = blit.src.box.y = blit.src.box.z = 0;
1879   blit.dst.box.x = xoffset;
1880   blit.dst.box.y = yoffset;
1881   blit.dst.box.z = zoffset + texImage->Face + texImage->TexObject->MinLayer;
1882   blit.src.box.width = blit.dst.box.width = width;
1883   blit.src.box.height = blit.dst.box.height = height;
1884   blit.src.box.depth = blit.dst.box.depth = depth;
1885   blit.mask = st_get_blit_mask(format, texImage->_BaseFormat);
1886   blit.filter = PIPE_TEX_FILTER_NEAREST;
1887   blit.scissor_enable = FALSE;
1888
1889   st->pipe->blit(st->pipe, &blit);
1890
1891   pipe_resource_reference(&src, NULL);
1892   return;
1893
1894fallback:
1895   _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset,
1896                           width, height, depth, format, type, pixels,
1897                           unpack);
1898}
1899
1900static void
1901st_TexImage(struct gl_context * ctx, GLuint dims,
1902            struct gl_texture_image *texImage,
1903            GLenum format, GLenum type, const void *pixels,
1904            const struct gl_pixelstore_attrib *unpack)
1905{
1906   assert(dims == 1 || dims == 2 || dims == 3);
1907
1908   prep_teximage(ctx, texImage, format, type);
1909
1910   if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
1911      return;
1912
1913   /* allocate storage for texture data */
1914   if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
1915      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
1916      return;
1917   }
1918
1919   st_TexSubImage(ctx, dims, texImage, 0, 0, 0,
1920                  texImage->Width, texImage->Height, texImage->Depth,
1921                  format, type, pixels, unpack);
1922}
1923
1924
1925static void
1926st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
1927                         struct gl_texture_image *texImage,
1928                         GLint x, GLint y, GLint z,
1929                         GLsizei w, GLsizei h, GLsizei d,
1930                         GLenum format, GLsizei imageSize, const GLvoid *data)
1931{
1932   struct st_context *st = st_context(ctx);
1933   struct st_texture_image *stImage = st_texture_image(texImage);
1934   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1935   struct pipe_resource *texture = stImage->pt;
1936   struct pipe_context *pipe = st->pipe;
1937   struct pipe_screen *screen = pipe->screen;
1938   struct pipe_resource *dst = stImage->pt;
1939   struct pipe_surface *surface = NULL;
1940   struct compressed_pixelstore store;
1941   enum pipe_format copy_format;
1942   unsigned bytes_per_block;
1943   unsigned bw, bh;
1944   intptr_t buf_offset;
1945   bool success = false;
1946
1947   /* Check basic pre-conditions for PBO upload */
1948   if (!st->prefer_blit_based_texture_transfer) {
1949      goto fallback;
1950   }
1951
1952   if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj))
1953      goto fallback;
1954
1955   if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
1956       (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) {
1957      /* ETC isn't supported and is represented by uncompressed formats. */
1958      goto fallback;
1959   }
1960
1961   if (!dst) {
1962      goto fallback;
1963   }
1964
1965   if (!st->pbo_upload.enabled ||
1966       !screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) {
1967      goto fallback;
1968   }
1969
1970   /* Choose the pipe format for the upload. */
1971   bytes_per_block = util_format_get_blocksize(dst->format);
1972   bw = util_format_get_blockwidth(dst->format);
1973   bh = util_format_get_blockheight(dst->format);
1974
1975   switch (bytes_per_block) {
1976   case 8:
1977      copy_format = PIPE_FORMAT_R16G16B16A16_UINT;
1978      break;
1979   case 16:
1980      copy_format = PIPE_FORMAT_R32G32B32A32_UINT;
1981      break;
1982   default:
1983      goto fallback;
1984   }
1985
1986   if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0,
1987                                    PIPE_BIND_SAMPLER_VIEW)) {
1988      goto fallback;
1989   }
1990
1991   if (!screen->is_format_supported(screen, copy_format, dst->target,
1992                                    dst->nr_samples, PIPE_BIND_RENDER_TARGET)) {
1993      goto fallback;
1994   }
1995
1996   /* Interpret the pixelstore settings. */
1997   _mesa_compute_compressed_pixelstore(dims, texImage->TexFormat, w, h, d,
1998                                       &ctx->Unpack, &store);
1999   assert(store.CopyBytesPerRow % bytes_per_block == 0);
2000   assert(store.SkipBytes % bytes_per_block == 0);
2001
2002   /* Compute the offset into the buffer */
2003   buf_offset = (intptr_t)data + store.SkipBytes;
2004
2005   if (buf_offset % bytes_per_block) {
2006      goto fallback;
2007   }
2008
2009   buf_offset = buf_offset / bytes_per_block;
2010
2011   /* Set up the surface. */
2012   {
2013      unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
2014      unsigned max_layer = util_max_layer(texture, level);
2015
2016      z += texImage->Face + texImage->TexObject->MinLayer;
2017
2018      struct pipe_surface templ;
2019      memset(&templ, 0, sizeof(templ));
2020      templ.format = copy_format;
2021      templ.u.tex.level = level;
2022      templ.u.tex.first_layer = MIN2(z, max_layer);
2023      templ.u.tex.last_layer = MIN2(z + d - 1, max_layer);
2024
2025      surface = pipe->create_surface(pipe, texture, &templ);
2026      if (!surface)
2027         goto fallback;
2028   }
2029
2030   success = try_pbo_upload_common(ctx, surface,
2031                                   x / bw, y / bh,
2032                                   store.CopyBytesPerRow / bytes_per_block,
2033                                   store.CopyRowsPerSlice,
2034                                   st_buffer_object(ctx->Unpack.BufferObj)->buffer,
2035                                   copy_format,
2036                                   buf_offset,
2037                                   bytes_per_block,
2038                                   store.TotalBytesPerRow / bytes_per_block,
2039                                   store.TotalRowsPerSlice);
2040
2041   pipe_surface_reference(&surface, NULL);
2042
2043   if (success)
2044      return;
2045
2046fallback:
2047   _mesa_store_compressed_texsubimage(ctx, dims, texImage,
2048                                      x, y, z, w, h, d,
2049                                      format, imageSize, data);
2050}
2051
2052static void
2053st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
2054                      struct gl_texture_image *texImage,
2055                      GLsizei imageSize, const GLvoid *data)
2056{
2057   prep_teximage(ctx, texImage, GL_NONE, GL_NONE);
2058
2059   /* only 2D and 3D compressed images are supported at this time */
2060   if (dims == 1) {
2061      _mesa_problem(ctx, "Unexpected glCompressedTexImage1D call");
2062      return;
2063   }
2064
2065   /* This is pretty simple, because unlike the general texstore path we don't
2066    * have to worry about the usual image unpacking or image transfer
2067    * operations.
2068    */
2069   assert(texImage);
2070   assert(texImage->Width > 0);
2071   assert(texImage->Height > 0);
2072   assert(texImage->Depth > 0);
2073
2074   /* allocate storage for texture data */
2075   if (!st_AllocTextureImageBuffer(ctx, texImage)) {
2076      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims);
2077      return;
2078   }
2079
2080   st_CompressedTexSubImage(ctx, dims, texImage,
2081                            0, 0, 0,
2082                            texImage->Width, texImage->Height, texImage->Depth,
2083                            texImage->TexFormat,
2084                            imageSize, data);
2085}
2086
2087
2088
2089
2090/**
2091 * Called via ctx->Driver.GetTexSubImage()
2092 *
2093 * This uses a blit to copy the texture to a texture format which matches
2094 * the format and type combo and then a fast read-back is done using memcpy.
2095 * We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is
2096 * a format which matches the swizzling.
2097 *
2098 * If such a format isn't available, it falls back to _mesa_GetTexImage_sw.
2099 *
2100 * NOTE: Drivers usually do a blit to convert between tiled and linear
2101 *       texture layouts during texture uploads/downloads, so the blit
2102 *       we do here should be free in such cases.
2103 */
2104static void
2105st_GetTexSubImage(struct gl_context * ctx,
2106                  GLint xoffset, GLint yoffset, GLint zoffset,
2107                  GLsizei width, GLsizei height, GLint depth,
2108                  GLenum format, GLenum type, GLvoid * pixels,
2109                  struct gl_texture_image *texImage)
2110{
2111   struct st_context *st = st_context(ctx);
2112   struct pipe_context *pipe = st->pipe;
2113   struct pipe_screen *screen = pipe->screen;
2114   struct st_texture_image *stImage = st_texture_image(texImage);
2115   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
2116   struct pipe_resource *src = stObj->pt;
2117   struct pipe_resource *dst = NULL;
2118   struct pipe_resource dst_templ;
2119   enum pipe_format dst_format, src_format;
2120   mesa_format mesa_format;
2121   GLenum gl_target = texImage->TexObject->Target;
2122   enum pipe_texture_target pipe_target;
2123   struct pipe_blit_info blit;
2124   unsigned bind = PIPE_BIND_TRANSFER_READ;
2125   struct pipe_transfer *tex_xfer;
2126   ubyte *map = NULL;
2127   boolean done = FALSE;
2128
2129   assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
2130          texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
2131
2132   if (!st->prefer_blit_based_texture_transfer &&
2133       !_mesa_is_format_compressed(texImage->TexFormat)) {
2134      /* Try to avoid the fallback if we're doing texture decompression here */
2135      goto fallback;
2136   }
2137
2138   if (!stImage->pt || !src) {
2139      goto fallback;
2140   }
2141
2142   /* XXX Fallback to _mesa_GetTexImage_sw for depth-stencil formats
2143    * due to an incomplete stencil blit implementation in some drivers. */
2144   if (format == GL_DEPTH_STENCIL || format == GL_STENCIL_INDEX) {
2145      goto fallback;
2146   }
2147
2148   /* If the base internal format and the texture format don't match, we have
2149    * to fall back to _mesa_GetTexImage_sw. */
2150   if (texImage->_BaseFormat !=
2151       _mesa_get_format_base_format(texImage->TexFormat)) {
2152      goto fallback;
2153   }
2154
2155   /* See if the texture format already matches the format and type,
2156    * in which case the memcpy-based fast path will be used. */
2157   if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
2158                                            type, ctx->Pack.SwapBytes, NULL)) {
2159      goto fallback;
2160   }
2161
2162   /* Convert the source format to what is expected by GetTexImage
2163    * and see if it's supported.
2164    *
2165    * This only applies to glGetTexImage:
2166    * - Luminance must be returned as (L,0,0,1).
2167    * - Luminance alpha must be returned as (L,0,0,A).
2168    * - Intensity must be returned as (I,0,0,1)
2169    */
2170   if (stObj->surface_based)
2171      src_format = util_format_linear(stObj->surface_format);
2172   else
2173      src_format = util_format_linear(src->format);
2174   src_format = util_format_luminance_to_red(src_format);
2175   src_format = util_format_intensity_to_red(src_format);
2176
2177   if (!src_format ||
2178       !screen->is_format_supported(screen, src_format, src->target,
2179                                    src->nr_samples,
2180                                    PIPE_BIND_SAMPLER_VIEW)) {
2181      goto fallback;
2182   }
2183
2184   if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
2185      bind |= PIPE_BIND_DEPTH_STENCIL;
2186   else
2187      bind |= PIPE_BIND_RENDER_TARGET;
2188
2189   /* GetTexImage only returns a single face for cubemaps. */
2190   if (gl_target == GL_TEXTURE_CUBE_MAP) {
2191      gl_target = GL_TEXTURE_2D;
2192   }
2193   pipe_target = gl_target_to_pipe(gl_target);
2194
2195   /* Choose the destination format by finding the best match
2196    * for the format+type combo. */
2197   dst_format = st_choose_matching_format(st, bind, format, type,
2198					  ctx->Pack.SwapBytes);
2199
2200   if (dst_format == PIPE_FORMAT_NONE) {
2201      GLenum dst_glformat;
2202
2203      /* Fall back to _mesa_GetTexImage_sw except for compressed formats,
2204       * where decompression with a blit is always preferred. */
2205      if (!util_format_is_compressed(src->format)) {
2206         goto fallback;
2207      }
2208
2209      /* Set the appropriate format for the decompressed texture.
2210       * Luminance and sRGB formats shouldn't appear here.*/
2211      switch (src_format) {
2212      case PIPE_FORMAT_DXT1_RGB:
2213      case PIPE_FORMAT_DXT1_RGBA:
2214      case PIPE_FORMAT_DXT3_RGBA:
2215      case PIPE_FORMAT_DXT5_RGBA:
2216      case PIPE_FORMAT_RGTC1_UNORM:
2217      case PIPE_FORMAT_RGTC2_UNORM:
2218      case PIPE_FORMAT_ETC1_RGB8:
2219      case PIPE_FORMAT_BPTC_RGBA_UNORM:
2220         dst_glformat = GL_RGBA8;
2221         break;
2222      case PIPE_FORMAT_RGTC1_SNORM:
2223      case PIPE_FORMAT_RGTC2_SNORM:
2224         if (!ctx->Extensions.EXT_texture_snorm)
2225            goto fallback;
2226         dst_glformat = GL_RGBA8_SNORM;
2227         break;
2228      case PIPE_FORMAT_BPTC_RGB_FLOAT:
2229      case PIPE_FORMAT_BPTC_RGB_UFLOAT:
2230         if (!ctx->Extensions.ARB_texture_float)
2231            goto fallback;
2232         dst_glformat = GL_RGBA32F;
2233         break;
2234      default:
2235         assert(0);
2236         goto fallback;
2237      }
2238
2239      dst_format = st_choose_format(st, dst_glformat, format, type,
2240                                    pipe_target, 0, bind, FALSE);
2241
2242      if (dst_format == PIPE_FORMAT_NONE) {
2243         /* unable to get an rgba format!?! */
2244         goto fallback;
2245      }
2246   }
2247
2248   /* create the destination texture of size (width X height X depth) */
2249   memset(&dst_templ, 0, sizeof(dst_templ));
2250   dst_templ.target = pipe_target;
2251   dst_templ.format = dst_format;
2252   dst_templ.bind = bind;
2253   dst_templ.usage = PIPE_USAGE_STAGING;
2254
2255   st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
2256                                   &dst_templ.width0, &dst_templ.height0,
2257                                   &dst_templ.depth0, &dst_templ.array_size);
2258
2259   dst = screen->resource_create(screen, &dst_templ);
2260   if (!dst) {
2261      goto fallback;
2262   }
2263
2264   /* From now on, we need the gallium representation of dimensions. */
2265   if (gl_target == GL_TEXTURE_1D_ARRAY) {
2266      zoffset = yoffset;
2267      yoffset = 0;
2268      depth = height;
2269      height = 1;
2270   }
2271
2272   assert(texImage->Face == 0 ||
2273          texImage->TexObject->MinLayer == 0 ||
2274          zoffset == 0);
2275
2276   memset(&blit, 0, sizeof(blit));
2277   blit.src.resource = src;
2278   blit.src.level = texImage->Level + texImage->TexObject->MinLevel;
2279   blit.src.format = src_format;
2280   blit.dst.resource = dst;
2281   blit.dst.level = 0;
2282   blit.dst.format = dst->format;
2283   blit.src.box.x = xoffset;
2284   blit.dst.box.x = 0;
2285   blit.src.box.y = yoffset;
2286   blit.dst.box.y = 0;
2287   blit.src.box.z = texImage->Face + texImage->TexObject->MinLayer + zoffset;
2288   blit.dst.box.z = 0;
2289   blit.src.box.width = blit.dst.box.width = width;
2290   blit.src.box.height = blit.dst.box.height = height;
2291   blit.src.box.depth = blit.dst.box.depth = depth;
2292   blit.mask = st_get_blit_mask(texImage->_BaseFormat, format);
2293   blit.filter = PIPE_TEX_FILTER_NEAREST;
2294   blit.scissor_enable = FALSE;
2295
2296   /* blit/render/decompress */
2297   st->pipe->blit(st->pipe, &blit);
2298
2299   pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
2300
2301   map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ,
2302                              0, 0, 0, width, height, depth, &tex_xfer);
2303   if (!map) {
2304      goto end;
2305   }
2306
2307   mesa_format = st_pipe_format_to_mesa_format(dst_format);
2308
2309   /* copy/pack data into user buffer */
2310   if (_mesa_format_matches_format_and_type(mesa_format, format, type,
2311                                            ctx->Pack.SwapBytes, NULL)) {
2312      /* memcpy */
2313      const uint bytesPerRow = width * util_format_get_blocksize(dst_format);
2314      GLuint row, slice;
2315
2316      for (slice = 0; slice < depth; slice++) {
2317         if (gl_target == GL_TEXTURE_1D_ARRAY) {
2318            /* 1D array textures.
2319             * We need to convert gallium coords to GL coords.
2320             */
2321            GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2322                                                 width, depth, format,
2323                                                 type, 0, slice, 0);
2324            memcpy(dest, map, bytesPerRow);
2325         }
2326         else {
2327            ubyte *slice_map = map;
2328
2329            for (row = 0; row < height; row++) {
2330               GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2331                                                    width, height, format,
2332                                                    type, slice, row, 0);
2333               memcpy(dest, slice_map, bytesPerRow);
2334               slice_map += tex_xfer->stride;
2335            }
2336         }
2337         map += tex_xfer->layer_stride;
2338      }
2339   }
2340   else {
2341      /* format translation via floats */
2342      GLuint row, slice;
2343      GLfloat *rgba;
2344      uint32_t dstMesaFormat;
2345      int dstStride, srcStride;
2346
2347      assert(util_format_is_compressed(src->format));
2348
2349      rgba = malloc(width * 4 * sizeof(GLfloat));
2350      if (!rgba) {
2351         goto end;
2352      }
2353
2354      if (ST_DEBUG & DEBUG_FALLBACK)
2355         debug_printf("%s: fallback format translation\n", __func__);
2356
2357      dstMesaFormat = _mesa_format_from_format_and_type(format, type);
2358      dstStride = _mesa_image_row_stride(&ctx->Pack, width, format, type);
2359      srcStride = 4 * width * sizeof(GLfloat);
2360      for (slice = 0; slice < depth; slice++) {
2361         if (gl_target == GL_TEXTURE_1D_ARRAY) {
2362            /* 1D array textures.
2363             * We need to convert gallium coords to GL coords.
2364             */
2365            GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2366                                                 width, depth, format,
2367                                                 type, 0, slice, 0);
2368
2369            /* get float[4] rgba row from surface */
2370            pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1,
2371                                      dst_format, rgba);
2372
2373            _mesa_format_convert(dest, dstMesaFormat, dstStride,
2374                                 rgba, RGBA32_FLOAT, srcStride,
2375                                 width, 1, NULL);
2376         }
2377         else {
2378            for (row = 0; row < height; row++) {
2379               GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2380                                                    width, height, format,
2381                                                    type, slice, row, 0);
2382
2383               /* get float[4] rgba row from surface */
2384               pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1,
2385                                         dst_format, rgba);
2386
2387               _mesa_format_convert(dest, dstMesaFormat, dstStride,
2388                                    rgba, RGBA32_FLOAT, srcStride,
2389                                    width, 1, NULL);
2390            }
2391         }
2392         map += tex_xfer->layer_stride;
2393      }
2394
2395      free(rgba);
2396   }
2397   done = TRUE;
2398
2399end:
2400   if (map)
2401      pipe_transfer_unmap(pipe, tex_xfer);
2402
2403   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
2404   pipe_resource_reference(&dst, NULL);
2405
2406fallback:
2407   if (!done) {
2408      _mesa_GetTexSubImage_sw(ctx, xoffset, yoffset, zoffset,
2409                              width, height, depth,
2410                              format, type, pixels, texImage);
2411   }
2412}
2413
2414
2415/**
2416 * Do a CopyTexSubImage operation using a read transfer from the source,
2417 * a write transfer to the destination and get_tile()/put_tile() to access
2418 * the pixels/texels.
2419 *
2420 * Note: srcY=0=TOP of renderbuffer
2421 */
2422static void
2423fallback_copy_texsubimage(struct gl_context *ctx,
2424                          struct st_renderbuffer *strb,
2425                          struct st_texture_image *stImage,
2426                          GLenum baseFormat,
2427                          GLint destX, GLint destY, GLint slice,
2428                          GLint srcX, GLint srcY,
2429                          GLsizei width, GLsizei height)
2430{
2431   struct st_context *st = st_context(ctx);
2432   struct pipe_context *pipe = st->pipe;
2433   struct pipe_transfer *src_trans;
2434   GLubyte *texDest;
2435   enum pipe_transfer_usage transfer_usage;
2436   void *map;
2437   unsigned dst_width = width;
2438   unsigned dst_height = height;
2439   unsigned dst_depth = 1;
2440   struct pipe_transfer *transfer;
2441
2442   if (ST_DEBUG & DEBUG_FALLBACK)
2443      debug_printf("%s: fallback processing\n", __func__);
2444
2445   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
2446      srcY = strb->Base.Height - srcY - height;
2447   }
2448
2449   map = pipe_transfer_map(pipe,
2450                           strb->texture,
2451                           strb->surface->u.tex.level,
2452                           strb->surface->u.tex.first_layer,
2453                           PIPE_TRANSFER_READ,
2454                           srcX, srcY,
2455                           width, height, &src_trans);
2456
2457   if ((baseFormat == GL_DEPTH_COMPONENT ||
2458        baseFormat == GL_DEPTH_STENCIL) &&
2459       util_format_is_depth_and_stencil(stImage->pt->format))
2460      transfer_usage = PIPE_TRANSFER_READ_WRITE;
2461   else
2462      transfer_usage = PIPE_TRANSFER_WRITE;
2463
2464   texDest = st_texture_image_map(st, stImage, transfer_usage,
2465                                  destX, destY, slice,
2466                                  dst_width, dst_height, dst_depth,
2467                                  &transfer);
2468
2469   if (baseFormat == GL_DEPTH_COMPONENT ||
2470       baseFormat == GL_DEPTH_STENCIL) {
2471      const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
2472                                     ctx->Pixel.DepthBias != 0.0F);
2473      GLint row, yStep;
2474      uint *data;
2475
2476      /* determine bottom-to-top vs. top-to-bottom order for src buffer */
2477      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
2478         srcY = height - 1;
2479         yStep = -1;
2480      }
2481      else {
2482         srcY = 0;
2483         yStep = 1;
2484      }
2485
2486      data = malloc(width * sizeof(uint));
2487
2488      if (data) {
2489         /* To avoid a large temp memory allocation, do copy row by row */
2490         for (row = 0; row < height; row++, srcY += yStep) {
2491            pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data);
2492            if (scaleOrBias) {
2493               _mesa_scale_and_bias_depth_uint(ctx, width, data);
2494            }
2495
2496            if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
2497               pipe_put_tile_z(transfer, texDest + row*transfer->layer_stride,
2498                               0, 0, width, 1, data);
2499            }
2500            else {
2501               pipe_put_tile_z(transfer, texDest, 0, row, width, 1, data);
2502            }
2503         }
2504      }
2505      else {
2506         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
2507      }
2508
2509      free(data);
2510   }
2511   else {
2512      /* RGBA format */
2513      GLfloat *tempSrc =
2514         malloc(width * height * 4 * sizeof(GLfloat));
2515
2516      if (tempSrc && texDest) {
2517         const GLint dims = 2;
2518         GLint dstRowStride;
2519         struct gl_texture_image *texImage = &stImage->base;
2520         struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
2521
2522         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
2523            unpack.Invert = GL_TRUE;
2524         }
2525
2526         if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
2527            dstRowStride = transfer->layer_stride;
2528         }
2529         else {
2530            dstRowStride = transfer->stride;
2531         }
2532
2533         /* get float/RGBA image from framebuffer */
2534         /* XXX this usually involves a lot of int/float conversion.
2535          * try to avoid that someday.
2536          */
2537         pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height,
2538                                   util_format_linear(strb->texture->format),
2539                                   tempSrc);
2540
2541         /* Store into texture memory.
2542          * Note that this does some special things such as pixel transfer
2543          * ops and format conversion.  In particular, if the dest tex format
2544          * is actually RGBA but the user created the texture as GL_RGB we
2545          * need to fill-in/override the alpha channel with 1.0.
2546          */
2547         _mesa_texstore(ctx, dims,
2548                        texImage->_BaseFormat,
2549                        texImage->TexFormat,
2550                        dstRowStride,
2551                        &texDest,
2552                        width, height, 1,
2553                        GL_RGBA, GL_FLOAT, tempSrc, /* src */
2554                        &unpack);
2555      }
2556      else {
2557         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
2558      }
2559
2560      free(tempSrc);
2561   }
2562
2563   st_texture_image_unmap(st, stImage, slice);
2564   pipe->transfer_unmap(pipe, src_trans);
2565}
2566
2567
2568/**
2569 * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
2570 * Note that the region to copy has already been clipped so we know we
2571 * won't read from outside the source renderbuffer's bounds.
2572 *
2573 * Note: srcY=0=Bottom of renderbuffer (GL convention)
2574 */
2575static void
2576st_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
2577                   struct gl_texture_image *texImage,
2578                   GLint destX, GLint destY, GLint slice,
2579                   struct gl_renderbuffer *rb,
2580                   GLint srcX, GLint srcY, GLsizei width, GLsizei height)
2581{
2582   struct st_texture_image *stImage = st_texture_image(texImage);
2583   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
2584   struct st_renderbuffer *strb = st_renderbuffer(rb);
2585   struct st_context *st = st_context(ctx);
2586   struct pipe_context *pipe = st->pipe;
2587   struct pipe_screen *screen = pipe->screen;
2588   struct pipe_blit_info blit;
2589   enum pipe_format dst_format;
2590   GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
2591   unsigned bind;
2592   GLint srcY0, srcY1;
2593
2594   assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
2595          texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
2596
2597   if (!strb || !strb->surface || !stImage->pt) {
2598      debug_printf("%s: null strb or stImage\n", __func__);
2599      return;
2600   }
2601
2602   if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat,
2603                                         texImage->TexFormat)) {
2604      goto fallback;
2605   }
2606
2607   /* The base internal format must match the mesa format, so make sure
2608    * e.g. an RGB internal format is really allocated as RGB and not as RGBA.
2609    */
2610   if (texImage->_BaseFormat !=
2611       _mesa_get_format_base_format(texImage->TexFormat) ||
2612       rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) {
2613      goto fallback;
2614   }
2615
2616   /* Choose the destination format to match the TexImage behavior. */
2617   dst_format = util_format_linear(stImage->pt->format);
2618   dst_format = util_format_luminance_to_red(dst_format);
2619   dst_format = util_format_intensity_to_red(dst_format);
2620
2621   /* See if the destination format is supported. */
2622   if (texImage->_BaseFormat == GL_DEPTH_STENCIL ||
2623       texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
2624      bind = PIPE_BIND_DEPTH_STENCIL;
2625   }
2626   else {
2627      bind = PIPE_BIND_RENDER_TARGET;
2628   }
2629
2630   if (!dst_format ||
2631       !screen->is_format_supported(screen, dst_format, stImage->pt->target,
2632                                    stImage->pt->nr_samples, bind)) {
2633      goto fallback;
2634   }
2635
2636   /* Y flipping for the main framebuffer. */
2637   if (do_flip) {
2638      srcY1 = strb->Base.Height - srcY - height;
2639      srcY0 = srcY1 + height;
2640   }
2641   else {
2642      srcY0 = srcY;
2643      srcY1 = srcY0 + height;
2644   }
2645
2646   /* Blit the texture.
2647    * This supports flipping, format conversions, and downsampling.
2648    */
2649   memset(&blit, 0, sizeof(blit));
2650   blit.src.resource = strb->texture;
2651   blit.src.format = util_format_linear(strb->surface->format);
2652   blit.src.level = strb->surface->u.tex.level;
2653   blit.src.box.x = srcX;
2654   blit.src.box.y = srcY0;
2655   blit.src.box.z = strb->surface->u.tex.first_layer;
2656   blit.src.box.width = width;
2657   blit.src.box.height = srcY1 - srcY0;
2658   blit.src.box.depth = 1;
2659   blit.dst.resource = stImage->pt;
2660   blit.dst.format = dst_format;
2661   blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level + texImage->TexObject->MinLevel;
2662   blit.dst.box.x = destX;
2663   blit.dst.box.y = destY;
2664   blit.dst.box.z = stImage->base.Face + slice + texImage->TexObject->MinLayer;
2665   blit.dst.box.width = width;
2666   blit.dst.box.height = height;
2667   blit.dst.box.depth = 1;
2668   blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat);
2669   blit.filter = PIPE_TEX_FILTER_NEAREST;
2670   pipe->blit(pipe, &blit);
2671   return;
2672
2673fallback:
2674   /* software fallback */
2675   fallback_copy_texsubimage(ctx,
2676                             strb, stImage, texImage->_BaseFormat,
2677                             destX, destY, slice,
2678                             srcX, srcY, width, height);
2679}
2680
2681
2682/**
2683 * Copy image data from stImage into the texture object 'stObj' at level
2684 * 'dstLevel'.
2685 */
2686static void
2687copy_image_data_to_texture(struct st_context *st,
2688			   struct st_texture_object *stObj,
2689                           GLuint dstLevel,
2690			   struct st_texture_image *stImage)
2691{
2692   /* debug checks */
2693   {
2694      const struct gl_texture_image *dstImage =
2695         stObj->base.Image[stImage->base.Face][dstLevel];
2696      assert(dstImage);
2697      assert(dstImage->Width == stImage->base.Width);
2698      assert(dstImage->Height == stImage->base.Height);
2699      assert(dstImage->Depth == stImage->base.Depth);
2700   }
2701
2702   if (stImage->pt) {
2703      /* Copy potentially with the blitter:
2704       */
2705      GLuint src_level;
2706      if (stImage->pt->last_level == 0)
2707         src_level = 0;
2708      else
2709         src_level = stImage->base.Level;
2710
2711      assert(src_level <= stImage->pt->last_level);
2712      assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width);
2713      assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY ||
2714             u_minify(stImage->pt->height0, src_level) == stImage->base.Height);
2715      assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY ||
2716             stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY ||
2717             u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth);
2718
2719      st_texture_image_copy(st->pipe,
2720                            stObj->pt, dstLevel,  /* dest texture, level */
2721                            stImage->pt, src_level, /* src texture, level */
2722                            stImage->base.Face);
2723
2724      pipe_resource_reference(&stImage->pt, NULL);
2725   }
2726   pipe_resource_reference(&stImage->pt, stObj->pt);
2727}
2728
2729
2730/**
2731 * Called during state validation.  When this function is finished,
2732 * the texture object should be ready for rendering.
2733 * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
2734 */
2735GLboolean
2736st_finalize_texture(struct gl_context *ctx,
2737		    struct pipe_context *pipe,
2738		    struct gl_texture_object *tObj)
2739{
2740   struct st_context *st = st_context(ctx);
2741   struct st_texture_object *stObj = st_texture_object(tObj);
2742   const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
2743   GLuint face;
2744   const struct st_texture_image *firstImage;
2745   enum pipe_format firstImageFormat;
2746   GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples;
2747
2748   if (tObj->Immutable)
2749      return GL_TRUE;
2750
2751   if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
2752      /* The texture is complete and we know exactly how many mipmap levels
2753       * are present/needed.  This is conditional because we may be called
2754       * from the st_generate_mipmap() function when the texture object is
2755       * incomplete.  In that case, we'll have set stObj->lastLevel before
2756       * we get here.
2757       */
2758      if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
2759          stObj->base.Sampler.MinFilter == GL_NEAREST)
2760         stObj->lastLevel = stObj->base.BaseLevel;
2761      else
2762         stObj->lastLevel = stObj->base._MaxLevel;
2763   }
2764
2765   if (tObj->Target == GL_TEXTURE_BUFFER) {
2766      struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject);
2767
2768      if (!st_obj) {
2769         pipe_resource_reference(&stObj->pt, NULL);
2770         st_texture_release_all_sampler_views(st, stObj);
2771         return GL_TRUE;
2772      }
2773
2774      if (st_obj->buffer != stObj->pt) {
2775         pipe_resource_reference(&stObj->pt, st_obj->buffer);
2776         st_texture_release_all_sampler_views(st, stObj);
2777         stObj->width0 = stObj->pt->width0 / _mesa_get_format_bytes(tObj->_BufferObjectFormat);
2778         stObj->height0 = 1;
2779         stObj->depth0 = 1;
2780      }
2781      return GL_TRUE;
2782
2783   }
2784
2785   firstImage = st_texture_image_const(_mesa_base_tex_image(&stObj->base));
2786   assert(firstImage);
2787
2788   /* If both firstImage and stObj point to a texture which can contain
2789    * all active images, favour firstImage.  Note that because of the
2790    * completeness requirement, we know that the image dimensions
2791    * will match.
2792    */
2793   if (firstImage->pt &&
2794       firstImage->pt != stObj->pt &&
2795       (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) {
2796      pipe_resource_reference(&stObj->pt, firstImage->pt);
2797      st_texture_release_all_sampler_views(st, stObj);
2798   }
2799
2800   /* If this texture comes from a window system, there is nothing else to do. */
2801   if (stObj->surface_based) {
2802      return GL_TRUE;
2803   }
2804
2805   /* Find gallium format for the Mesa texture */
2806   firstImageFormat =
2807      st_mesa_format_to_pipe_format(st, firstImage->base.TexFormat);
2808
2809   /* Find size of level=0 Gallium mipmap image, plus number of texture layers */
2810   {
2811      GLuint width, height, depth;
2812      if (!guess_base_level_size(stObj->base.Target,
2813                                 firstImage->base.Width2,
2814                                 firstImage->base.Height2,
2815                                 firstImage->base.Depth2,
2816                                 firstImage->base.Level,
2817                                 &width, &height, &depth)) {
2818         width = stObj->width0;
2819         height = stObj->height0;
2820         depth = stObj->depth0;
2821      } else {
2822         /* The width/height/depth may have been previously reset in
2823          * guess_and_alloc_texture. */
2824         stObj->width0 = width;
2825         stObj->height0 = height;
2826         stObj->depth0 = depth;
2827      }
2828      /* convert GL dims to Gallium dims */
2829      st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth,
2830                                      &ptWidth, &ptHeight, &ptDepth, &ptLayers);
2831      ptNumSamples = firstImage->base.NumSamples;
2832   }
2833
2834   /* If we already have a gallium texture, check that it matches the texture
2835    * object's format, target, size, num_levels, etc.
2836    */
2837   if (stObj->pt) {
2838      if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
2839          stObj->pt->format != firstImageFormat ||
2840          stObj->pt->last_level < stObj->lastLevel ||
2841          stObj->pt->width0 != ptWidth ||
2842          stObj->pt->height0 != ptHeight ||
2843          stObj->pt->depth0 != ptDepth ||
2844          stObj->pt->nr_samples != ptNumSamples ||
2845          stObj->pt->array_size != ptLayers)
2846      {
2847         /* The gallium texture does not match the Mesa texture so delete the
2848          * gallium texture now.  We'll make a new one below.
2849          */
2850         pipe_resource_reference(&stObj->pt, NULL);
2851         st_texture_release_all_sampler_views(st, stObj);
2852         st->dirty.st |= ST_NEW_FRAMEBUFFER;
2853      }
2854   }
2855
2856   /* May need to create a new gallium texture:
2857    */
2858   if (!stObj->pt) {
2859      GLuint bindings = default_bindings(st, firstImageFormat);
2860
2861      stObj->pt = st_texture_create(st,
2862                                    gl_target_to_pipe(stObj->base.Target),
2863                                    firstImageFormat,
2864                                    stObj->lastLevel,
2865                                    ptWidth,
2866                                    ptHeight,
2867                                    ptDepth,
2868                                    ptLayers, ptNumSamples,
2869                                    bindings);
2870
2871      if (!stObj->pt) {
2872         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
2873         return GL_FALSE;
2874      }
2875   }
2876
2877   /* Pull in any images not in the object's texture:
2878    */
2879   for (face = 0; face < nr_faces; face++) {
2880      GLuint level;
2881      for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) {
2882         struct st_texture_image *stImage =
2883            st_texture_image(stObj->base.Image[face][level]);
2884
2885         /* Need to import images in main memory or held in other textures.
2886          */
2887         if (stImage && stObj->pt != stImage->pt) {
2888            if (level == 0 ||
2889                (stImage->base.Width == u_minify(stObj->width0, level) &&
2890                 stImage->base.Height == u_minify(stObj->height0, level) &&
2891                 stImage->base.Depth == u_minify(stObj->depth0, level))) {
2892               /* src image fits expected dest mipmap level size */
2893               copy_image_data_to_texture(st, stObj, level, stImage);
2894            }
2895         }
2896      }
2897   }
2898
2899   return GL_TRUE;
2900}
2901
2902
2903/**
2904 * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory
2905 * for a whole mipmap stack.
2906 */
2907static GLboolean
2908st_AllocTextureStorage(struct gl_context *ctx,
2909                       struct gl_texture_object *texObj,
2910                       GLsizei levels, GLsizei width,
2911                       GLsizei height, GLsizei depth)
2912{
2913   const GLuint numFaces = _mesa_num_tex_faces(texObj->Target);
2914   struct gl_texture_image *texImage = texObj->Image[0][0];
2915   struct st_context *st = st_context(ctx);
2916   struct st_texture_object *stObj = st_texture_object(texObj);
2917   struct pipe_screen *screen = st->pipe->screen;
2918   GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings;
2919   enum pipe_format fmt;
2920   GLint level;
2921   GLuint num_samples = texImage->NumSamples;
2922
2923   assert(levels > 0);
2924
2925   /* Save the level=0 dimensions */
2926   stObj->width0 = width;
2927   stObj->height0 = height;
2928   stObj->depth0 = depth;
2929   stObj->lastLevel = levels - 1;
2930
2931   fmt = st_mesa_format_to_pipe_format(st, texImage->TexFormat);
2932
2933   bindings = default_bindings(st, fmt);
2934
2935   /* Raise the sample count if the requested one is unsupported. */
2936   if (num_samples > 1) {
2937      boolean found = FALSE;
2938
2939      for (; num_samples <= ctx->Const.MaxSamples; num_samples++) {
2940         if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D,
2941                                         num_samples,
2942                                         PIPE_BIND_SAMPLER_VIEW)) {
2943            /* Update the sample count in gl_texture_image as well. */
2944            texImage->NumSamples = num_samples;
2945            found = TRUE;
2946            break;
2947         }
2948      }
2949
2950      if (!found) {
2951         return GL_FALSE;
2952      }
2953   }
2954
2955   st_gl_texture_dims_to_pipe_dims(texObj->Target,
2956                                   width, height, depth,
2957                                   &ptWidth, &ptHeight, &ptDepth, &ptLayers);
2958
2959   stObj->pt = st_texture_create(st,
2960                                 gl_target_to_pipe(texObj->Target),
2961                                 fmt,
2962                                 levels - 1,
2963                                 ptWidth,
2964                                 ptHeight,
2965                                 ptDepth,
2966                                 ptLayers, num_samples,
2967                                 bindings);
2968   if (!stObj->pt)
2969      return GL_FALSE;
2970
2971   /* Set image resource pointers */
2972   for (level = 0; level < levels; level++) {
2973      GLuint face;
2974      for (face = 0; face < numFaces; face++) {
2975         struct st_texture_image *stImage =
2976            st_texture_image(texObj->Image[face][level]);
2977         pipe_resource_reference(&stImage->pt, stObj->pt);
2978      }
2979   }
2980
2981   return GL_TRUE;
2982}
2983
2984
2985static GLboolean
2986st_TestProxyTexImage(struct gl_context *ctx, GLenum target,
2987                     GLint level, mesa_format format,
2988                     GLint width, GLint height,
2989                     GLint depth, GLint border)
2990{
2991   struct st_context *st = st_context(ctx);
2992   struct pipe_context *pipe = st->pipe;
2993
2994   if (width == 0 || height == 0 || depth == 0) {
2995      /* zero-sized images are legal, and always fit! */
2996      return GL_TRUE;
2997   }
2998
2999   if (pipe->screen->can_create_resource) {
3000      /* Ask the gallium driver if the texture is too large */
3001      struct gl_texture_object *texObj =
3002         _mesa_get_current_tex_object(ctx, target);
3003      struct pipe_resource pt;
3004
3005      /* Setup the pipe_resource object
3006       */
3007      memset(&pt, 0, sizeof(pt));
3008
3009      pt.target = gl_target_to_pipe(target);
3010      pt.format = st_mesa_format_to_pipe_format(st, format);
3011
3012      st_gl_texture_dims_to_pipe_dims(target,
3013                                      width, height, depth,
3014                                      &pt.width0, &pt.height0,
3015                                      &pt.depth0, &pt.array_size);
3016
3017      if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR ||
3018                         texObj->Sampler.MinFilter == GL_NEAREST)) {
3019         /* assume just one mipmap level */
3020         pt.last_level = 0;
3021      }
3022      else {
3023         /* assume a full set of mipmaps */
3024         pt.last_level = _mesa_logbase2(MAX3(width, height, depth));
3025      }
3026
3027      return pipe->screen->can_create_resource(pipe->screen, &pt);
3028   }
3029   else {
3030      /* Use core Mesa fallback */
3031      return _mesa_test_proxy_teximage(ctx, target, level, format,
3032                                       width, height, depth, border);
3033   }
3034}
3035
3036static GLboolean
3037st_TextureView(struct gl_context *ctx,
3038               struct gl_texture_object *texObj,
3039               struct gl_texture_object *origTexObj)
3040{
3041   struct st_texture_object *orig = st_texture_object(origTexObj);
3042   struct st_texture_object *tex = st_texture_object(texObj);
3043   struct gl_texture_image *image = texObj->Image[0][0];
3044
3045   const int numFaces = _mesa_num_tex_faces(texObj->Target);
3046   const int numLevels = texObj->NumLevels;
3047
3048   int face;
3049   int level;
3050
3051   pipe_resource_reference(&tex->pt, orig->pt);
3052
3053   /* Set image resource pointers */
3054   for (level = 0; level < numLevels; level++) {
3055      for (face = 0; face < numFaces; face++) {
3056         struct st_texture_image *stImage =
3057            st_texture_image(texObj->Image[face][level]);
3058         pipe_resource_reference(&stImage->pt, tex->pt);
3059      }
3060   }
3061
3062   tex->surface_based = GL_TRUE;
3063   tex->surface_format =
3064      st_mesa_format_to_pipe_format(st_context(ctx), image->TexFormat);
3065
3066   tex->width0 = image->Width;
3067   tex->height0 = image->Height;
3068   tex->depth0 = image->Depth;
3069   tex->lastLevel = numLevels - 1;
3070
3071   return GL_TRUE;
3072}
3073
3074static void
3075st_ClearTexSubImage(struct gl_context *ctx,
3076                    struct gl_texture_image *texImage,
3077                    GLint xoffset, GLint yoffset, GLint zoffset,
3078                    GLsizei width, GLsizei height, GLsizei depth,
3079                    const GLvoid *clearValue)
3080{
3081   static const char zeros[16] = {0};
3082   struct st_texture_image *stImage = st_texture_image(texImage);
3083   struct pipe_resource *pt = stImage->pt;
3084   struct st_context *st = st_context(ctx);
3085   struct pipe_context *pipe = st->pipe;
3086   unsigned level = texImage->Level;
3087   struct pipe_box box;
3088
3089   if (!pt)
3090      return;
3091
3092   u_box_3d(xoffset, yoffset, zoffset + texImage->Face,
3093            width, height, depth, &box);
3094   if (texImage->TexObject->Immutable) {
3095      level += texImage->TexObject->MinLevel;
3096      box.z += texImage->TexObject->MinLayer;
3097   }
3098
3099   pipe->clear_texture(pipe, pt, level, &box, clearValue ? clearValue : zeros);
3100}
3101
3102void
3103st_init_texture_functions(struct dd_function_table *functions)
3104{
3105   functions->ChooseTextureFormat = st_ChooseTextureFormat;
3106   functions->QuerySamplesForFormat = st_QuerySamplesForFormat;
3107   functions->TexImage = st_TexImage;
3108   functions->TexSubImage = st_TexSubImage;
3109   functions->CompressedTexSubImage = st_CompressedTexSubImage;
3110   functions->CopyTexSubImage = st_CopyTexSubImage;
3111   functions->GenerateMipmap = st_generate_mipmap;
3112
3113   functions->GetTexSubImage = st_GetTexSubImage;
3114
3115   /* compressed texture functions */
3116   functions->CompressedTexImage = st_CompressedTexImage;
3117   functions->GetCompressedTexSubImage = _mesa_GetCompressedTexSubImage_sw;
3118
3119   functions->NewTextureObject = st_NewTextureObject;
3120   functions->NewTextureImage = st_NewTextureImage;
3121   functions->DeleteTextureImage = st_DeleteTextureImage;
3122   functions->DeleteTexture = st_DeleteTextureObject;
3123   functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
3124   functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
3125   functions->MapTextureImage = st_MapTextureImage;
3126   functions->UnmapTextureImage = st_UnmapTextureImage;
3127
3128   /* XXX Temporary until we can query pipe's texture sizes */
3129   functions->TestProxyTexImage = st_TestProxyTexImage;
3130
3131   functions->AllocTextureStorage = st_AllocTextureStorage;
3132   functions->TextureView = st_TextureView;
3133   functions->ClearTexSubImage = st_ClearTexSubImage;
3134}
3135