st_cb_texture.c revision 2b938a390c15a06be8cf706083890c822979508f 
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   /* temp0.w = 0 */
1276   ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_W), ureg_imm1u(ureg, 0));
1277
1278   /* out = txf(sampler, temp0.x) */
1279   ureg_TXF(ureg, out, TGSI_TEXTURE_BUFFER, ureg_src(temp0), sampler);
1280
1281   ureg_release_temporary(ureg, temp0);
1282
1283   ureg_END(ureg);
1284
1285   return ureg_create_shader_and_destroy(ureg, pipe);
1286}
1287
1288static bool
1289try_pbo_upload_common(struct gl_context *ctx,
1290                      struct pipe_surface *surface,
1291                      int xoffset, int yoffset,
1292                      unsigned upload_width, unsigned upload_height,
1293                      struct pipe_resource *buffer,
1294                      enum pipe_format src_format,
1295                      intptr_t buf_offset,
1296                      unsigned bytes_per_pixel,
1297                      unsigned stride,
1298                      unsigned image_height)
1299{
1300   struct st_context *st = st_context(ctx);
1301   struct cso_context *cso = st->cso_context;
1302   struct pipe_context *pipe = st->pipe;
1303   unsigned depth = surface->u.tex.last_layer - surface->u.tex.first_layer + 1;
1304   unsigned skip_pixels = 0;
1305   bool success = false;
1306
1307   /* Check alignment. */
1308   {
1309      unsigned ofs = (buf_offset * bytes_per_pixel) % ctx->Const.TextureBufferOffsetAlignment;
1310      if (ofs != 0) {
1311         if (ofs % bytes_per_pixel != 0)
1312            return false;
1313
1314         skip_pixels = ofs / bytes_per_pixel;
1315         buf_offset -= skip_pixels;
1316      }
1317   }
1318
1319   /* Create the shaders */
1320   if (!st->pbo_upload.vs) {
1321      st->pbo_upload.vs = create_pbo_upload_vs(st);
1322      if (!st->pbo_upload.vs)
1323         return false;
1324   }
1325
1326   if (depth != 1 && st->pbo_upload.use_gs && !st->pbo_upload.gs) {
1327      st->pbo_upload.gs = create_pbo_upload_gs(st);
1328      if (!st->pbo_upload.gs)
1329         return false;
1330   }
1331
1332   if (!st->pbo_upload.fs) {
1333      st->pbo_upload.fs = create_pbo_upload_fs(st);
1334      if (!st->pbo_upload.fs)
1335         return false;
1336   }
1337
1338   cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
1339                        CSO_BIT_FRAGMENT_SAMPLERS |
1340                        CSO_BIT_VERTEX_ELEMENTS |
1341                        CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
1342                        CSO_BIT_FRAMEBUFFER |
1343                        CSO_BIT_VIEWPORT |
1344                        CSO_BIT_BLEND |
1345                        CSO_BIT_DEPTH_STENCIL_ALPHA |
1346                        CSO_BIT_RASTERIZER |
1347                        CSO_BIT_STREAM_OUTPUTS |
1348                        CSO_BITS_ALL_SHADERS));
1349   cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
1350
1351
1352   /* Set up the sampler_view */
1353   {
1354      unsigned first_element = buf_offset;
1355      unsigned last_element = buf_offset + skip_pixels + upload_width - 1
1356         + (upload_height - 1 + (depth - 1) * image_height) * stride;
1357      struct pipe_sampler_view templ;
1358      struct pipe_sampler_view *sampler_view;
1359      struct pipe_sampler_state sampler = {0};
1360      const struct pipe_sampler_state *samplers[1] = {&sampler};
1361
1362      /* This should be ensured by Mesa before calling our callbacks */
1363      assert((last_element + 1) * bytes_per_pixel <= buffer->width0);
1364
1365      if (last_element - first_element > ctx->Const.MaxTextureBufferSize - 1)
1366         goto fail;
1367
1368      memset(&templ, 0, sizeof(templ));
1369      templ.target = PIPE_BUFFER;
1370      templ.format = src_format;
1371      templ.u.buf.first_element = first_element;
1372      templ.u.buf.last_element = last_element;
1373      templ.swizzle_r = PIPE_SWIZZLE_RED;
1374      templ.swizzle_g = PIPE_SWIZZLE_GREEN;
1375      templ.swizzle_b = PIPE_SWIZZLE_BLUE;
1376      templ.swizzle_a = PIPE_SWIZZLE_ALPHA;
1377
1378      sampler_view = pipe->create_sampler_view(pipe, buffer, &templ);
1379      if (sampler_view == NULL)
1380         goto fail;
1381
1382      cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view);
1383
1384      pipe_sampler_view_reference(&sampler_view, NULL);
1385
1386      cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers);
1387   }
1388
1389   /* Upload vertices */
1390   {
1391      struct pipe_vertex_buffer vbo;
1392      struct pipe_vertex_element velem;
1393
1394      float x0 = (float) xoffset / surface->width * 2.0f - 1.0f;
1395      float y0 = (float) yoffset / surface->height * 2.0f - 1.0f;
1396      float x1 = (float) (xoffset + upload_width) / surface->width * 2.0f - 1.0f;
1397      float y1 = (float) (yoffset + upload_height) / surface->height * 2.0f - 1.0f;
1398
1399      float *verts = NULL;
1400
1401      vbo.user_buffer = NULL;
1402      vbo.buffer = NULL;
1403      vbo.stride = 2 * sizeof(float);
1404
1405      u_upload_alloc(st->uploader, 0, 8 * sizeof(float), 4,
1406                     &vbo.buffer_offset, &vbo.buffer, (void **) &verts);
1407      if (!verts)
1408         goto fail;
1409
1410      verts[0] = x0;
1411      verts[1] = y0;
1412      verts[2] = x0;
1413      verts[3] = y1;
1414      verts[4] = x1;
1415      verts[5] = y0;
1416      verts[6] = x1;
1417      verts[7] = y1;
1418
1419      u_upload_unmap(st->uploader);
1420
1421      velem.src_offset = 0;
1422      velem.instance_divisor = 0;
1423      velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
1424      velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
1425
1426      cso_set_vertex_elements(cso, 1, &velem);
1427
1428      cso_set_vertex_buffers(cso, velem.vertex_buffer_index, 1, &vbo);
1429
1430      pipe_resource_reference(&vbo.buffer, NULL);
1431   }
1432
1433   /* Upload constants */
1434   /* Note: the user buffer must be valid until draw time */
1435   struct {
1436      int32_t xoffset;
1437      int32_t yoffset;
1438      int32_t stride;
1439      int32_t image_size;
1440   } constants;
1441
1442   {
1443      struct pipe_constant_buffer cb;
1444
1445      constants.xoffset = -xoffset + skip_pixels;
1446      constants.yoffset = -yoffset;
1447      constants.stride = stride;
1448      constants.image_size = stride * image_height;
1449
1450      if (st->constbuf_uploader) {
1451         cb.buffer = NULL;
1452         cb.user_buffer = NULL;
1453         u_upload_data(st->constbuf_uploader, 0, sizeof(constants),
1454                       ctx->Const.UniformBufferOffsetAlignment,
1455                       &constants, &cb.buffer_offset, &cb.buffer);
1456         if (!cb.buffer)
1457            goto fail;
1458
1459         u_upload_unmap(st->constbuf_uploader);
1460      } else {
1461         cb.buffer = NULL;
1462         cb.user_buffer = &constants;
1463         cb.buffer_offset = 0;
1464      }
1465      cb.buffer_size = sizeof(constants);
1466
1467      cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
1468
1469      pipe_resource_reference(&cb.buffer, NULL);
1470   }
1471
1472   /* Framebuffer_state */
1473   {
1474      struct pipe_framebuffer_state fb;
1475      memset(&fb, 0, sizeof(fb));
1476      fb.width = surface->width;
1477      fb.height = surface->height;
1478      fb.nr_cbufs = 1;
1479      pipe_surface_reference(&fb.cbufs[0], surface);
1480
1481      cso_set_framebuffer(cso, &fb);
1482
1483      pipe_surface_reference(&fb.cbufs[0], NULL);
1484   }
1485
1486   cso_set_viewport_dims(cso, surface->width, surface->height, FALSE);
1487
1488   /* Blend state */
1489   cso_set_blend(cso, &st->pbo_upload.blend);
1490
1491   /* Depth/stencil/alpha state */
1492   {
1493      struct pipe_depth_stencil_alpha_state dsa;
1494      memset(&dsa, 0, sizeof(dsa));
1495      cso_set_depth_stencil_alpha(cso, &dsa);
1496   }
1497
1498   /* Rasterizer state */
1499   cso_set_rasterizer(cso, &st->pbo_upload.raster);
1500
1501   /* Set up the shaders */
1502   cso_set_vertex_shader_handle(cso, st->pbo_upload.vs);
1503
1504   cso_set_geometry_shader_handle(cso, depth != 1 ? st->pbo_upload.gs : NULL);
1505
1506   cso_set_tessctrl_shader_handle(cso, NULL);
1507
1508   cso_set_tesseval_shader_handle(cso, NULL);
1509
1510   cso_set_fragment_shader_handle(cso, st->pbo_upload.fs);
1511
1512   /* Disable stream output */
1513   cso_set_stream_outputs(cso, 0, NULL, 0);
1514
1515   if (depth == 1) {
1516      cso_draw_arrays(cso, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
1517   } else {
1518      cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_STRIP,
1519                                0, 4, 0, depth);
1520   }
1521
1522   success = true;
1523
1524fail:
1525   cso_restore_state(cso);
1526   cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
1527
1528   return success;
1529}
1530
1531static bool
1532try_pbo_upload(struct gl_context *ctx, GLuint dims,
1533               struct gl_texture_image *texImage,
1534               GLenum format, GLenum type,
1535               enum pipe_format dst_format,
1536               GLint xoffset, GLint yoffset, GLint zoffset,
1537               GLint width, GLint height, GLint depth,
1538               const void *pixels,
1539               const struct gl_pixelstore_attrib *unpack)
1540{
1541   struct st_context *st = st_context(ctx);
1542   struct st_texture_image *stImage = st_texture_image(texImage);
1543   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1544   struct pipe_resource *texture = stImage->pt;
1545   struct pipe_context *pipe = st->pipe;
1546   struct pipe_screen *screen = pipe->screen;
1547   struct pipe_surface *surface = NULL;
1548   enum pipe_format src_format;
1549   const struct util_format_description *desc;
1550   GLenum gl_target = texImage->TexObject->Target;
1551   intptr_t buf_offset;
1552   unsigned bytes_per_pixel;
1553   unsigned stride, image_height;
1554   bool success;
1555
1556   if (!st->pbo_upload.enabled)
1557      return false;
1558
1559   /* From now on, we need the gallium representation of dimensions. */
1560   if (gl_target == GL_TEXTURE_1D_ARRAY) {
1561      depth = height;
1562      height = 1;
1563      zoffset = yoffset;
1564      yoffset = 0;
1565      image_height = 1;
1566   } else {
1567      image_height = unpack->ImageHeight > 0 ? unpack->ImageHeight : height;
1568   }
1569
1570   if (depth != 1 && !st->pbo_upload.upload_layers)
1571      return false;
1572
1573   /* Choose the source format. Initially, we do so without checking driver
1574    * support at all because of the remapping we later perform and because
1575    * at least the Radeon driver actually supports some formats for texture
1576    * buffers which it doesn't support for regular textures. */
1577   src_format = st_choose_matching_format(st, 0, format, type, unpack->SwapBytes);
1578   if (!src_format) {
1579      return false;
1580   }
1581
1582   src_format = util_format_linear(src_format);
1583   desc = util_format_description(src_format);
1584
1585   if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
1586      return false;
1587
1588   if (desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB)
1589      return false;
1590
1591   if (st->pbo_upload.rgba_only) {
1592      enum pipe_format orig_dst_format = dst_format;
1593
1594      if (!reinterpret_formats(&src_format, &dst_format)) {
1595         return false;
1596      }
1597
1598      if (dst_format != orig_dst_format &&
1599          !screen->is_format_supported(screen, dst_format, PIPE_TEXTURE_2D, 0,
1600                                       PIPE_BIND_RENDER_TARGET)) {
1601         return false;
1602      }
1603   }
1604
1605   if (!src_format ||
1606       !screen->is_format_supported(screen, src_format, PIPE_BUFFER, 0,
1607                                    PIPE_BIND_SAMPLER_VIEW)) {
1608      return false;
1609   }
1610
1611   /* Check if the offset satisfies the alignment requirements */
1612   buf_offset = (intptr_t) pixels;
1613   bytes_per_pixel = desc->block.bits / 8;
1614
1615   if (buf_offset % bytes_per_pixel) {
1616      return false;
1617   }
1618
1619   /* Convert to texels */
1620   buf_offset = buf_offset / bytes_per_pixel;
1621
1622   /* Compute the stride, taking unpack->Alignment into account */
1623   {
1624       unsigned pixels_per_row = unpack->RowLength > 0 ?
1625                           unpack->RowLength : width;
1626       unsigned bytes_per_row = pixels_per_row * bytes_per_pixel;
1627       unsigned remainder = bytes_per_row % unpack->Alignment;
1628       unsigned offset_rows;
1629
1630       if (remainder > 0)
1631          bytes_per_row += (unpack->Alignment - remainder);
1632
1633       if (bytes_per_row % bytes_per_pixel) {
1634          return false;
1635       }
1636
1637       stride = bytes_per_row / bytes_per_pixel;
1638
1639       offset_rows = unpack->SkipRows;
1640       if (dims == 3)
1641          offset_rows += image_height * unpack->SkipImages;
1642
1643       buf_offset += unpack->SkipPixels + stride * offset_rows;
1644   }
1645
1646   /* Set up the surface */
1647   {
1648      unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
1649      unsigned max_layer = util_max_layer(texture, level);
1650
1651      zoffset += texImage->Face + texImage->TexObject->MinLayer;
1652
1653      struct pipe_surface templ;
1654      memset(&templ, 0, sizeof(templ));
1655      templ.format = dst_format;
1656      templ.u.tex.level = level;
1657      templ.u.tex.first_layer = MIN2(zoffset, max_layer);
1658      templ.u.tex.last_layer = MIN2(zoffset + depth - 1, max_layer);
1659
1660      surface = pipe->create_surface(pipe, texture, &templ);
1661      if (!surface)
1662         return false;
1663   }
1664
1665   success = try_pbo_upload_common(ctx,  surface,
1666                                   xoffset, yoffset, width, height,
1667                                   st_buffer_object(unpack->BufferObj)->buffer,
1668                                   src_format,
1669                                   buf_offset,
1670                                   bytes_per_pixel, stride, image_height);
1671
1672   pipe_surface_reference(&surface, NULL);
1673
1674   return success;
1675}
1676
1677static void
1678st_TexSubImage(struct gl_context *ctx, GLuint dims,
1679               struct gl_texture_image *texImage,
1680               GLint xoffset, GLint yoffset, GLint zoffset,
1681               GLint width, GLint height, GLint depth,
1682               GLenum format, GLenum type, const void *pixels,
1683               const struct gl_pixelstore_attrib *unpack)
1684{
1685   struct st_context *st = st_context(ctx);
1686   struct st_texture_image *stImage = st_texture_image(texImage);
1687   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1688   struct pipe_context *pipe = st->pipe;
1689   struct pipe_screen *screen = pipe->screen;
1690   struct pipe_resource *dst = stImage->pt;
1691   struct pipe_resource *src = NULL;
1692   struct pipe_resource src_templ;
1693   struct pipe_transfer *transfer;
1694   struct pipe_blit_info blit;
1695   enum pipe_format src_format, dst_format;
1696   mesa_format mesa_src_format;
1697   GLenum gl_target = texImage->TexObject->Target;
1698   unsigned bind;
1699   GLubyte *map;
1700
1701   assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
1702          texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
1703
1704   if (!st->prefer_blit_based_texture_transfer) {
1705      goto fallback;
1706   }
1707
1708   if (!dst) {
1709      goto fallback;
1710   }
1711
1712   /* XXX Fallback for depth-stencil formats due to an incomplete stencil
1713    * blit implementation in some drivers. */
1714   if (format == GL_DEPTH_STENCIL) {
1715      goto fallback;
1716   }
1717
1718   /* If the base internal format and the texture format don't match,
1719    * we can't use blit-based TexSubImage. */
1720   if (texImage->_BaseFormat !=
1721       _mesa_get_format_base_format(texImage->TexFormat)) {
1722      goto fallback;
1723   }
1724
1725
1726   /* See if the destination format is supported. */
1727   if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
1728      bind = PIPE_BIND_DEPTH_STENCIL;
1729   else
1730      bind = PIPE_BIND_RENDER_TARGET;
1731
1732   /* For luminance and intensity, only the red channel is stored
1733    * in the destination. */
1734   dst_format = util_format_linear(dst->format);
1735   dst_format = util_format_luminance_to_red(dst_format);
1736   dst_format = util_format_intensity_to_red(dst_format);
1737
1738   if (!dst_format ||
1739       !screen->is_format_supported(screen, dst_format, dst->target,
1740                                    dst->nr_samples, bind)) {
1741      goto fallback;
1742   }
1743
1744   if (_mesa_is_bufferobj(unpack->BufferObj)) {
1745      if (try_pbo_upload(ctx, dims, texImage, format, type, dst_format,
1746                         xoffset, yoffset, zoffset,
1747                         width, height, depth, pixels, unpack))
1748         return;
1749   }
1750
1751   /* See if the texture format already matches the format and type,
1752    * in which case the memcpy-based fast path will likely be used and
1753    * we don't have to blit. */
1754   if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
1755                                            type, unpack->SwapBytes, NULL)) {
1756      goto fallback;
1757   }
1758
1759   /* Choose the source format. */
1760   src_format = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
1761                                          format, type, unpack->SwapBytes);
1762   if (!src_format) {
1763      goto fallback;
1764   }
1765
1766   mesa_src_format = st_pipe_format_to_mesa_format(src_format);
1767
1768   /* There is no reason to do this if we cannot use memcpy for the temporary
1769    * source texture at least. This also takes transfer ops into account,
1770    * etc. */
1771   if (!_mesa_texstore_can_use_memcpy(ctx,
1772                             _mesa_get_format_base_format(mesa_src_format),
1773                             mesa_src_format, format, type, unpack)) {
1774      goto fallback;
1775   }
1776
1777   /* TexSubImage only sets a single cubemap face. */
1778   if (gl_target == GL_TEXTURE_CUBE_MAP) {
1779      gl_target = GL_TEXTURE_2D;
1780   }
1781   /* TexSubImage can specify subsets of cube map array faces
1782    * so we need to upload via 2D array instead */
1783   if (gl_target == GL_TEXTURE_CUBE_MAP_ARRAY) {
1784      gl_target = GL_TEXTURE_2D_ARRAY;
1785   }
1786
1787   /* Initialize the source texture description. */
1788   memset(&src_templ, 0, sizeof(src_templ));
1789   src_templ.target = gl_target_to_pipe(gl_target);
1790   src_templ.format = src_format;
1791   src_templ.bind = PIPE_BIND_SAMPLER_VIEW;
1792   src_templ.usage = PIPE_USAGE_STAGING;
1793
1794   st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
1795                                   &src_templ.width0, &src_templ.height0,
1796                                   &src_templ.depth0, &src_templ.array_size);
1797
1798   /* Check for NPOT texture support. */
1799   if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
1800       (!util_is_power_of_two(src_templ.width0) ||
1801        !util_is_power_of_two(src_templ.height0) ||
1802        !util_is_power_of_two(src_templ.depth0))) {
1803      goto fallback;
1804   }
1805
1806   /* Create the source texture. */
1807   src = screen->resource_create(screen, &src_templ);
1808   if (!src) {
1809      goto fallback;
1810   }
1811
1812   /* Map source pixels. */
1813   pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
1814                                        format, type, pixels, unpack,
1815                                        "glTexSubImage");
1816   if (!pixels) {
1817      /* This is a GL error. */
1818      pipe_resource_reference(&src, NULL);
1819      return;
1820   }
1821
1822   /* From now on, we need the gallium representation of dimensions. */
1823   if (gl_target == GL_TEXTURE_1D_ARRAY) {
1824      zoffset = yoffset;
1825      yoffset = 0;
1826      depth = height;
1827      height = 1;
1828   }
1829
1830   map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0,
1831                              width, height, depth, &transfer);
1832   if (!map) {
1833      _mesa_unmap_teximage_pbo(ctx, unpack);
1834      pipe_resource_reference(&src, NULL);
1835      goto fallback;
1836   }
1837
1838   /* Upload pixels (just memcpy). */
1839   {
1840      const uint bytesPerRow = width * util_format_get_blocksize(src_format);
1841      GLuint row, slice;
1842
1843      for (slice = 0; slice < (unsigned) depth; slice++) {
1844         if (gl_target == GL_TEXTURE_1D_ARRAY) {
1845            /* 1D array textures.
1846             * We need to convert gallium coords to GL coords.
1847             */
1848            GLvoid *src = _mesa_image_address2d(unpack, pixels,
1849                                                width, depth, format,
1850                                                type, slice, 0);
1851            memcpy(map, src, bytesPerRow);
1852         }
1853         else {
1854            ubyte *slice_map = map;
1855
1856            for (row = 0; row < (unsigned) height; row++) {
1857               GLvoid *src = _mesa_image_address(dims, unpack, pixels,
1858                                                 width, height, format,
1859                                                 type, slice, row, 0);
1860               memcpy(slice_map, src, bytesPerRow);
1861               slice_map += transfer->stride;
1862            }
1863         }
1864         map += transfer->layer_stride;
1865      }
1866   }
1867
1868   pipe_transfer_unmap(pipe, transfer);
1869   _mesa_unmap_teximage_pbo(ctx, unpack);
1870
1871   /* Blit. */
1872   memset(&blit, 0, sizeof(blit));
1873   blit.src.resource = src;
1874   blit.src.level = 0;
1875   blit.src.format = src_format;
1876   blit.dst.resource = dst;
1877   blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
1878   blit.dst.format = dst_format;
1879   blit.src.box.x = blit.src.box.y = blit.src.box.z = 0;
1880   blit.dst.box.x = xoffset;
1881   blit.dst.box.y = yoffset;
1882   blit.dst.box.z = zoffset + texImage->Face + texImage->TexObject->MinLayer;
1883   blit.src.box.width = blit.dst.box.width = width;
1884   blit.src.box.height = blit.dst.box.height = height;
1885   blit.src.box.depth = blit.dst.box.depth = depth;
1886   blit.mask = st_get_blit_mask(format, texImage->_BaseFormat);
1887   blit.filter = PIPE_TEX_FILTER_NEAREST;
1888   blit.scissor_enable = FALSE;
1889
1890   st->pipe->blit(st->pipe, &blit);
1891
1892   pipe_resource_reference(&src, NULL);
1893   return;
1894
1895fallback:
1896   _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset,
1897                           width, height, depth, format, type, pixels,
1898                           unpack);
1899}
1900
1901static void
1902st_TexImage(struct gl_context * ctx, GLuint dims,
1903            struct gl_texture_image *texImage,
1904            GLenum format, GLenum type, const void *pixels,
1905            const struct gl_pixelstore_attrib *unpack)
1906{
1907   assert(dims == 1 || dims == 2 || dims == 3);
1908
1909   prep_teximage(ctx, texImage, format, type);
1910
1911   if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
1912      return;
1913
1914   /* allocate storage for texture data */
1915   if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
1916      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
1917      return;
1918   }
1919
1920   st_TexSubImage(ctx, dims, texImage, 0, 0, 0,
1921                  texImage->Width, texImage->Height, texImage->Depth,
1922                  format, type, pixels, unpack);
1923}
1924
1925
1926static void
1927st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
1928                         struct gl_texture_image *texImage,
1929                         GLint x, GLint y, GLint z,
1930                         GLsizei w, GLsizei h, GLsizei d,
1931                         GLenum format, GLsizei imageSize, const GLvoid *data)
1932{
1933   struct st_context *st = st_context(ctx);
1934   struct st_texture_image *stImage = st_texture_image(texImage);
1935   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1936   struct pipe_resource *texture = stImage->pt;
1937   struct pipe_context *pipe = st->pipe;
1938   struct pipe_screen *screen = pipe->screen;
1939   struct pipe_resource *dst = stImage->pt;
1940   struct pipe_surface *surface = NULL;
1941   struct compressed_pixelstore store;
1942   enum pipe_format copy_format;
1943   unsigned bytes_per_block;
1944   unsigned bw, bh;
1945   intptr_t buf_offset;
1946   bool success = false;
1947
1948   /* Check basic pre-conditions for PBO upload */
1949   if (!st->prefer_blit_based_texture_transfer) {
1950      goto fallback;
1951   }
1952
1953   if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj))
1954      goto fallback;
1955
1956   if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
1957       (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) {
1958      /* ETC isn't supported and is represented by uncompressed formats. */
1959      goto fallback;
1960   }
1961
1962   if (!dst) {
1963      goto fallback;
1964   }
1965
1966   if (!st->pbo_upload.enabled ||
1967       !screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) {
1968      goto fallback;
1969   }
1970
1971   /* Choose the pipe format for the upload. */
1972   bytes_per_block = util_format_get_blocksize(dst->format);
1973   bw = util_format_get_blockwidth(dst->format);
1974   bh = util_format_get_blockheight(dst->format);
1975
1976   switch (bytes_per_block) {
1977   case 8:
1978      copy_format = PIPE_FORMAT_R16G16B16A16_UINT;
1979      break;
1980   case 16:
1981      copy_format = PIPE_FORMAT_R32G32B32A32_UINT;
1982      break;
1983   default:
1984      goto fallback;
1985   }
1986
1987   if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0,
1988                                    PIPE_BIND_SAMPLER_VIEW)) {
1989      goto fallback;
1990   }
1991
1992   if (!screen->is_format_supported(screen, copy_format, dst->target,
1993                                    dst->nr_samples, PIPE_BIND_RENDER_TARGET)) {
1994      goto fallback;
1995   }
1996
1997   /* Interpret the pixelstore settings. */
1998   _mesa_compute_compressed_pixelstore(dims, texImage->TexFormat, w, h, d,
1999                                       &ctx->Unpack, &store);
2000   assert(store.CopyBytesPerRow % bytes_per_block == 0);
2001   assert(store.SkipBytes % bytes_per_block == 0);
2002
2003   /* Compute the offset into the buffer */
2004   buf_offset = (intptr_t)data + store.SkipBytes;
2005
2006   if (buf_offset % bytes_per_block) {
2007      goto fallback;
2008   }
2009
2010   buf_offset = buf_offset / bytes_per_block;
2011
2012   /* Set up the surface. */
2013   {
2014      unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
2015      unsigned max_layer = util_max_layer(texture, level);
2016
2017      z += texImage->Face + texImage->TexObject->MinLayer;
2018
2019      struct pipe_surface templ;
2020      memset(&templ, 0, sizeof(templ));
2021      templ.format = copy_format;
2022      templ.u.tex.level = level;
2023      templ.u.tex.first_layer = MIN2(z, max_layer);
2024      templ.u.tex.last_layer = MIN2(z + d - 1, max_layer);
2025
2026      surface = pipe->create_surface(pipe, texture, &templ);
2027      if (!surface)
2028         goto fallback;
2029   }
2030
2031   success = try_pbo_upload_common(ctx, surface,
2032                                   x / bw, y / bh,
2033                                   store.CopyBytesPerRow / bytes_per_block,
2034                                   store.CopyRowsPerSlice,
2035                                   st_buffer_object(ctx->Unpack.BufferObj)->buffer,
2036                                   copy_format,
2037                                   buf_offset,
2038                                   bytes_per_block,
2039                                   store.TotalBytesPerRow / bytes_per_block,
2040                                   store.TotalRowsPerSlice);
2041
2042   pipe_surface_reference(&surface, NULL);
2043
2044   if (success)
2045      return;
2046
2047fallback:
2048   _mesa_store_compressed_texsubimage(ctx, dims, texImage,
2049                                      x, y, z, w, h, d,
2050                                      format, imageSize, data);
2051}
2052
2053static void
2054st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
2055                      struct gl_texture_image *texImage,
2056                      GLsizei imageSize, const GLvoid *data)
2057{
2058   prep_teximage(ctx, texImage, GL_NONE, GL_NONE);
2059
2060   /* only 2D and 3D compressed images are supported at this time */
2061   if (dims == 1) {
2062      _mesa_problem(ctx, "Unexpected glCompressedTexImage1D call");
2063      return;
2064   }
2065
2066   /* This is pretty simple, because unlike the general texstore path we don't
2067    * have to worry about the usual image unpacking or image transfer
2068    * operations.
2069    */
2070   assert(texImage);
2071   assert(texImage->Width > 0);
2072   assert(texImage->Height > 0);
2073   assert(texImage->Depth > 0);
2074
2075   /* allocate storage for texture data */
2076   if (!st_AllocTextureImageBuffer(ctx, texImage)) {
2077      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims);
2078      return;
2079   }
2080
2081   st_CompressedTexSubImage(ctx, dims, texImage,
2082                            0, 0, 0,
2083                            texImage->Width, texImage->Height, texImage->Depth,
2084                            texImage->TexFormat,
2085                            imageSize, data);
2086}
2087
2088
2089
2090
2091/**
2092 * Called via ctx->Driver.GetTexSubImage()
2093 *
2094 * This uses a blit to copy the texture to a texture format which matches
2095 * the format and type combo and then a fast read-back is done using memcpy.
2096 * We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is
2097 * a format which matches the swizzling.
2098 *
2099 * If such a format isn't available, it falls back to _mesa_GetTexImage_sw.
2100 *
2101 * NOTE: Drivers usually do a blit to convert between tiled and linear
2102 *       texture layouts during texture uploads/downloads, so the blit
2103 *       we do here should be free in such cases.
2104 */
2105static void
2106st_GetTexSubImage(struct gl_context * ctx,
2107                  GLint xoffset, GLint yoffset, GLint zoffset,
2108                  GLsizei width, GLsizei height, GLint depth,
2109                  GLenum format, GLenum type, GLvoid * pixels,
2110                  struct gl_texture_image *texImage)
2111{
2112   struct st_context *st = st_context(ctx);
2113   struct pipe_context *pipe = st->pipe;
2114   struct pipe_screen *screen = pipe->screen;
2115   struct st_texture_image *stImage = st_texture_image(texImage);
2116   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
2117   struct pipe_resource *src = stObj->pt;
2118   struct pipe_resource *dst = NULL;
2119   struct pipe_resource dst_templ;
2120   enum pipe_format dst_format, src_format;
2121   mesa_format mesa_format;
2122   GLenum gl_target = texImage->TexObject->Target;
2123   enum pipe_texture_target pipe_target;
2124   struct pipe_blit_info blit;
2125   unsigned bind = PIPE_BIND_TRANSFER_READ;
2126   struct pipe_transfer *tex_xfer;
2127   ubyte *map = NULL;
2128   boolean done = FALSE;
2129
2130   assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
2131          texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
2132
2133   if (!st->prefer_blit_based_texture_transfer &&
2134       !_mesa_is_format_compressed(texImage->TexFormat)) {
2135      /* Try to avoid the fallback if we're doing texture decompression here */
2136      goto fallback;
2137   }
2138
2139   if (!stImage->pt || !src) {
2140      goto fallback;
2141   }
2142
2143   /* XXX Fallback to _mesa_GetTexImage_sw for depth-stencil formats
2144    * due to an incomplete stencil blit implementation in some drivers. */
2145   if (format == GL_DEPTH_STENCIL || format == GL_STENCIL_INDEX) {
2146      goto fallback;
2147   }
2148
2149   /* If the base internal format and the texture format don't match, we have
2150    * to fall back to _mesa_GetTexImage_sw. */
2151   if (texImage->_BaseFormat !=
2152       _mesa_get_format_base_format(texImage->TexFormat)) {
2153      goto fallback;
2154   }
2155
2156   /* See if the texture format already matches the format and type,
2157    * in which case the memcpy-based fast path will be used. */
2158   if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
2159                                            type, ctx->Pack.SwapBytes, NULL)) {
2160      goto fallback;
2161   }
2162
2163   /* Convert the source format to what is expected by GetTexImage
2164    * and see if it's supported.
2165    *
2166    * This only applies to glGetTexImage:
2167    * - Luminance must be returned as (L,0,0,1).
2168    * - Luminance alpha must be returned as (L,0,0,A).
2169    * - Intensity must be returned as (I,0,0,1)
2170    */
2171   if (stObj->surface_based)
2172      src_format = util_format_linear(stObj->surface_format);
2173   else
2174      src_format = util_format_linear(src->format);
2175   src_format = util_format_luminance_to_red(src_format);
2176   src_format = util_format_intensity_to_red(src_format);
2177
2178   if (!src_format ||
2179       !screen->is_format_supported(screen, src_format, src->target,
2180                                    src->nr_samples,
2181                                    PIPE_BIND_SAMPLER_VIEW)) {
2182      goto fallback;
2183   }
2184
2185   if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
2186      bind |= PIPE_BIND_DEPTH_STENCIL;
2187   else
2188      bind |= PIPE_BIND_RENDER_TARGET;
2189
2190   /* GetTexImage only returns a single face for cubemaps. */
2191   if (gl_target == GL_TEXTURE_CUBE_MAP) {
2192      gl_target = GL_TEXTURE_2D;
2193   }
2194   pipe_target = gl_target_to_pipe(gl_target);
2195
2196   /* Choose the destination format by finding the best match
2197    * for the format+type combo. */
2198   dst_format = st_choose_matching_format(st, bind, format, type,
2199					  ctx->Pack.SwapBytes);
2200
2201   if (dst_format == PIPE_FORMAT_NONE) {
2202      GLenum dst_glformat;
2203
2204      /* Fall back to _mesa_GetTexImage_sw except for compressed formats,
2205       * where decompression with a blit is always preferred. */
2206      if (!util_format_is_compressed(src->format)) {
2207         goto fallback;
2208      }
2209
2210      /* Set the appropriate format for the decompressed texture.
2211       * Luminance and sRGB formats shouldn't appear here.*/
2212      switch (src_format) {
2213      case PIPE_FORMAT_DXT1_RGB:
2214      case PIPE_FORMAT_DXT1_RGBA:
2215      case PIPE_FORMAT_DXT3_RGBA:
2216      case PIPE_FORMAT_DXT5_RGBA:
2217      case PIPE_FORMAT_RGTC1_UNORM:
2218      case PIPE_FORMAT_RGTC2_UNORM:
2219      case PIPE_FORMAT_ETC1_RGB8:
2220      case PIPE_FORMAT_BPTC_RGBA_UNORM:
2221         dst_glformat = GL_RGBA8;
2222         break;
2223      case PIPE_FORMAT_RGTC1_SNORM:
2224      case PIPE_FORMAT_RGTC2_SNORM:
2225         if (!ctx->Extensions.EXT_texture_snorm)
2226            goto fallback;
2227         dst_glformat = GL_RGBA8_SNORM;
2228         break;
2229      case PIPE_FORMAT_BPTC_RGB_FLOAT:
2230      case PIPE_FORMAT_BPTC_RGB_UFLOAT:
2231         if (!ctx->Extensions.ARB_texture_float)
2232            goto fallback;
2233         dst_glformat = GL_RGBA32F;
2234         break;
2235      default:
2236         assert(0);
2237         goto fallback;
2238      }
2239
2240      dst_format = st_choose_format(st, dst_glformat, format, type,
2241                                    pipe_target, 0, bind, FALSE);
2242
2243      if (dst_format == PIPE_FORMAT_NONE) {
2244         /* unable to get an rgba format!?! */
2245         goto fallback;
2246      }
2247   }
2248
2249   /* create the destination texture of size (width X height X depth) */
2250   memset(&dst_templ, 0, sizeof(dst_templ));
2251   dst_templ.target = pipe_target;
2252   dst_templ.format = dst_format;
2253   dst_templ.bind = bind;
2254   dst_templ.usage = PIPE_USAGE_STAGING;
2255
2256   st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
2257                                   &dst_templ.width0, &dst_templ.height0,
2258                                   &dst_templ.depth0, &dst_templ.array_size);
2259
2260   dst = screen->resource_create(screen, &dst_templ);
2261   if (!dst) {
2262      goto fallback;
2263   }
2264
2265   /* From now on, we need the gallium representation of dimensions. */
2266   if (gl_target == GL_TEXTURE_1D_ARRAY) {
2267      zoffset = yoffset;
2268      yoffset = 0;
2269      depth = height;
2270      height = 1;
2271   }
2272
2273   assert(texImage->Face == 0 ||
2274          texImage->TexObject->MinLayer == 0 ||
2275          zoffset == 0);
2276
2277   memset(&blit, 0, sizeof(blit));
2278   blit.src.resource = src;
2279   blit.src.level = texImage->Level + texImage->TexObject->MinLevel;
2280   blit.src.format = src_format;
2281   blit.dst.resource = dst;
2282   blit.dst.level = 0;
2283   blit.dst.format = dst->format;
2284   blit.src.box.x = xoffset;
2285   blit.dst.box.x = 0;
2286   blit.src.box.y = yoffset;
2287   blit.dst.box.y = 0;
2288   blit.src.box.z = texImage->Face + texImage->TexObject->MinLayer + zoffset;
2289   blit.dst.box.z = 0;
2290   blit.src.box.width = blit.dst.box.width = width;
2291   blit.src.box.height = blit.dst.box.height = height;
2292   blit.src.box.depth = blit.dst.box.depth = depth;
2293   blit.mask = st_get_blit_mask(texImage->_BaseFormat, format);
2294   blit.filter = PIPE_TEX_FILTER_NEAREST;
2295   blit.scissor_enable = FALSE;
2296
2297   /* blit/render/decompress */
2298   st->pipe->blit(st->pipe, &blit);
2299
2300   pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
2301
2302   map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ,
2303                              0, 0, 0, width, height, depth, &tex_xfer);
2304   if (!map) {
2305      goto end;
2306   }
2307
2308   mesa_format = st_pipe_format_to_mesa_format(dst_format);
2309
2310   /* copy/pack data into user buffer */
2311   if (_mesa_format_matches_format_and_type(mesa_format, format, type,
2312                                            ctx->Pack.SwapBytes, NULL)) {
2313      /* memcpy */
2314      const uint bytesPerRow = width * util_format_get_blocksize(dst_format);
2315      GLuint row, slice;
2316
2317      for (slice = 0; slice < depth; slice++) {
2318         if (gl_target == GL_TEXTURE_1D_ARRAY) {
2319            /* 1D array textures.
2320             * We need to convert gallium coords to GL coords.
2321             */
2322            GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2323                                                 width, depth, format,
2324                                                 type, 0, slice, 0);
2325            memcpy(dest, map, bytesPerRow);
2326         }
2327         else {
2328            ubyte *slice_map = map;
2329
2330            for (row = 0; row < height; row++) {
2331               GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2332                                                    width, height, format,
2333                                                    type, slice, row, 0);
2334               memcpy(dest, slice_map, bytesPerRow);
2335               slice_map += tex_xfer->stride;
2336            }
2337         }
2338         map += tex_xfer->layer_stride;
2339      }
2340   }
2341   else {
2342      /* format translation via floats */
2343      GLuint row, slice;
2344      GLfloat *rgba;
2345      uint32_t dstMesaFormat;
2346      int dstStride, srcStride;
2347
2348      assert(util_format_is_compressed(src->format));
2349
2350      rgba = malloc(width * 4 * sizeof(GLfloat));
2351      if (!rgba) {
2352         goto end;
2353      }
2354
2355      if (ST_DEBUG & DEBUG_FALLBACK)
2356         debug_printf("%s: fallback format translation\n", __func__);
2357
2358      dstMesaFormat = _mesa_format_from_format_and_type(format, type);
2359      dstStride = _mesa_image_row_stride(&ctx->Pack, width, format, type);
2360      srcStride = 4 * width * sizeof(GLfloat);
2361      for (slice = 0; slice < depth; slice++) {
2362         if (gl_target == GL_TEXTURE_1D_ARRAY) {
2363            /* 1D array textures.
2364             * We need to convert gallium coords to GL coords.
2365             */
2366            GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2367                                                 width, depth, format,
2368                                                 type, 0, slice, 0);
2369
2370            /* get float[4] rgba row from surface */
2371            pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1,
2372                                      dst_format, rgba);
2373
2374            _mesa_format_convert(dest, dstMesaFormat, dstStride,
2375                                 rgba, RGBA32_FLOAT, srcStride,
2376                                 width, 1, NULL);
2377         }
2378         else {
2379            for (row = 0; row < height; row++) {
2380               GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
2381                                                    width, height, format,
2382                                                    type, slice, row, 0);
2383
2384               /* get float[4] rgba row from surface */
2385               pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1,
2386                                         dst_format, rgba);
2387
2388               _mesa_format_convert(dest, dstMesaFormat, dstStride,
2389                                    rgba, RGBA32_FLOAT, srcStride,
2390                                    width, 1, NULL);
2391            }
2392         }
2393         map += tex_xfer->layer_stride;
2394      }
2395
2396      free(rgba);
2397   }
2398   done = TRUE;
2399
2400end:
2401   if (map)
2402      pipe_transfer_unmap(pipe, tex_xfer);
2403
2404   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
2405   pipe_resource_reference(&dst, NULL);
2406
2407fallback:
2408   if (!done) {
2409      _mesa_GetTexSubImage_sw(ctx, xoffset, yoffset, zoffset,
2410                              width, height, depth,
2411                              format, type, pixels, texImage);
2412   }
2413}
2414
2415
2416/**
2417 * Do a CopyTexSubImage operation using a read transfer from the source,
2418 * a write transfer to the destination and get_tile()/put_tile() to access
2419 * the pixels/texels.
2420 *
2421 * Note: srcY=0=TOP of renderbuffer
2422 */
2423static void
2424fallback_copy_texsubimage(struct gl_context *ctx,
2425                          struct st_renderbuffer *strb,
2426                          struct st_texture_image *stImage,
2427                          GLenum baseFormat,
2428                          GLint destX, GLint destY, GLint slice,
2429                          GLint srcX, GLint srcY,
2430                          GLsizei width, GLsizei height)
2431{
2432   struct st_context *st = st_context(ctx);
2433   struct pipe_context *pipe = st->pipe;
2434   struct pipe_transfer *src_trans;
2435   GLubyte *texDest;
2436   enum pipe_transfer_usage transfer_usage;
2437   void *map;
2438   unsigned dst_width = width;
2439   unsigned dst_height = height;
2440   unsigned dst_depth = 1;
2441   struct pipe_transfer *transfer;
2442
2443   if (ST_DEBUG & DEBUG_FALLBACK)
2444      debug_printf("%s: fallback processing\n", __func__);
2445
2446   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
2447      srcY = strb->Base.Height - srcY - height;
2448   }
2449
2450   map = pipe_transfer_map(pipe,
2451                           strb->texture,
2452                           strb->surface->u.tex.level,
2453                           strb->surface->u.tex.first_layer,
2454                           PIPE_TRANSFER_READ,
2455                           srcX, srcY,
2456                           width, height, &src_trans);
2457
2458   if ((baseFormat == GL_DEPTH_COMPONENT ||
2459        baseFormat == GL_DEPTH_STENCIL) &&
2460       util_format_is_depth_and_stencil(stImage->pt->format))
2461      transfer_usage = PIPE_TRANSFER_READ_WRITE;
2462   else
2463      transfer_usage = PIPE_TRANSFER_WRITE;
2464
2465   texDest = st_texture_image_map(st, stImage, transfer_usage,
2466                                  destX, destY, slice,
2467                                  dst_width, dst_height, dst_depth,
2468                                  &transfer);
2469
2470   if (baseFormat == GL_DEPTH_COMPONENT ||
2471       baseFormat == GL_DEPTH_STENCIL) {
2472      const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
2473                                     ctx->Pixel.DepthBias != 0.0F);
2474      GLint row, yStep;
2475      uint *data;
2476
2477      /* determine bottom-to-top vs. top-to-bottom order for src buffer */
2478      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
2479         srcY = height - 1;
2480         yStep = -1;
2481      }
2482      else {
2483         srcY = 0;
2484         yStep = 1;
2485      }
2486
2487      data = malloc(width * sizeof(uint));
2488
2489      if (data) {
2490         /* To avoid a large temp memory allocation, do copy row by row */
2491         for (row = 0; row < height; row++, srcY += yStep) {
2492            pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data);
2493            if (scaleOrBias) {
2494               _mesa_scale_and_bias_depth_uint(ctx, width, data);
2495            }
2496
2497            if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
2498               pipe_put_tile_z(transfer, texDest + row*transfer->layer_stride,
2499                               0, 0, width, 1, data);
2500            }
2501            else {
2502               pipe_put_tile_z(transfer, texDest, 0, row, width, 1, data);
2503            }
2504         }
2505      }
2506      else {
2507         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
2508      }
2509
2510      free(data);
2511   }
2512   else {
2513      /* RGBA format */
2514      GLfloat *tempSrc =
2515         malloc(width * height * 4 * sizeof(GLfloat));
2516
2517      if (tempSrc && texDest) {
2518         const GLint dims = 2;
2519         GLint dstRowStride;
2520         struct gl_texture_image *texImage = &stImage->base;
2521         struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
2522
2523         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
2524            unpack.Invert = GL_TRUE;
2525         }
2526
2527         if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
2528            dstRowStride = transfer->layer_stride;
2529         }
2530         else {
2531            dstRowStride = transfer->stride;
2532         }
2533
2534         /* get float/RGBA image from framebuffer */
2535         /* XXX this usually involves a lot of int/float conversion.
2536          * try to avoid that someday.
2537          */
2538         pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height,
2539                                   util_format_linear(strb->texture->format),
2540                                   tempSrc);
2541
2542         /* Store into texture memory.
2543          * Note that this does some special things such as pixel transfer
2544          * ops and format conversion.  In particular, if the dest tex format
2545          * is actually RGBA but the user created the texture as GL_RGB we
2546          * need to fill-in/override the alpha channel with 1.0.
2547          */
2548         _mesa_texstore(ctx, dims,
2549                        texImage->_BaseFormat,
2550                        texImage->TexFormat,
2551                        dstRowStride,
2552                        &texDest,
2553                        width, height, 1,
2554                        GL_RGBA, GL_FLOAT, tempSrc, /* src */
2555                        &unpack);
2556      }
2557      else {
2558         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
2559      }
2560
2561      free(tempSrc);
2562   }
2563
2564   st_texture_image_unmap(st, stImage, slice);
2565   pipe->transfer_unmap(pipe, src_trans);
2566}
2567
2568
2569/**
2570 * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
2571 * Note that the region to copy has already been clipped so we know we
2572 * won't read from outside the source renderbuffer's bounds.
2573 *
2574 * Note: srcY=0=Bottom of renderbuffer (GL convention)
2575 */
2576static void
2577st_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
2578                   struct gl_texture_image *texImage,
2579                   GLint destX, GLint destY, GLint slice,
2580                   struct gl_renderbuffer *rb,
2581                   GLint srcX, GLint srcY, GLsizei width, GLsizei height)
2582{
2583   struct st_texture_image *stImage = st_texture_image(texImage);
2584   struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
2585   struct st_renderbuffer *strb = st_renderbuffer(rb);
2586   struct st_context *st = st_context(ctx);
2587   struct pipe_context *pipe = st->pipe;
2588   struct pipe_screen *screen = pipe->screen;
2589   struct pipe_blit_info blit;
2590   enum pipe_format dst_format;
2591   GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
2592   unsigned bind;
2593   GLint srcY0, srcY1;
2594
2595   assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
2596          texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
2597
2598   if (!strb || !strb->surface || !stImage->pt) {
2599      debug_printf("%s: null strb or stImage\n", __func__);
2600      return;
2601   }
2602
2603   if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat,
2604                                         texImage->TexFormat)) {
2605      goto fallback;
2606   }
2607
2608   /* The base internal format must match the mesa format, so make sure
2609    * e.g. an RGB internal format is really allocated as RGB and not as RGBA.
2610    */
2611   if (texImage->_BaseFormat !=
2612       _mesa_get_format_base_format(texImage->TexFormat) ||
2613       rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) {
2614      goto fallback;
2615   }
2616
2617   /* Choose the destination format to match the TexImage behavior. */
2618   dst_format = util_format_linear(stImage->pt->format);
2619   dst_format = util_format_luminance_to_red(dst_format);
2620   dst_format = util_format_intensity_to_red(dst_format);
2621
2622   /* See if the destination format is supported. */
2623   if (texImage->_BaseFormat == GL_DEPTH_STENCIL ||
2624       texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
2625      bind = PIPE_BIND_DEPTH_STENCIL;
2626   }
2627   else {
2628      bind = PIPE_BIND_RENDER_TARGET;
2629   }
2630
2631   if (!dst_format ||
2632       !screen->is_format_supported(screen, dst_format, stImage->pt->target,
2633                                    stImage->pt->nr_samples, bind)) {
2634      goto fallback;
2635   }
2636
2637   /* Y flipping for the main framebuffer. */
2638   if (do_flip) {
2639      srcY1 = strb->Base.Height - srcY - height;
2640      srcY0 = srcY1 + height;
2641   }
2642   else {
2643      srcY0 = srcY;
2644      srcY1 = srcY0 + height;
2645   }
2646
2647   /* Blit the texture.
2648    * This supports flipping, format conversions, and downsampling.
2649    */
2650   memset(&blit, 0, sizeof(blit));
2651   blit.src.resource = strb->texture;
2652   blit.src.format = util_format_linear(strb->surface->format);
2653   blit.src.level = strb->surface->u.tex.level;
2654   blit.src.box.x = srcX;
2655   blit.src.box.y = srcY0;
2656   blit.src.box.z = strb->surface->u.tex.first_layer;
2657   blit.src.box.width = width;
2658   blit.src.box.height = srcY1 - srcY0;
2659   blit.src.box.depth = 1;
2660   blit.dst.resource = stImage->pt;
2661   blit.dst.format = dst_format;
2662   blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level + texImage->TexObject->MinLevel;
2663   blit.dst.box.x = destX;
2664   blit.dst.box.y = destY;
2665   blit.dst.box.z = stImage->base.Face + slice + texImage->TexObject->MinLayer;
2666   blit.dst.box.width = width;
2667   blit.dst.box.height = height;
2668   blit.dst.box.depth = 1;
2669   blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat);
2670   blit.filter = PIPE_TEX_FILTER_NEAREST;
2671   pipe->blit(pipe, &blit);
2672   return;
2673
2674fallback:
2675   /* software fallback */
2676   fallback_copy_texsubimage(ctx,
2677                             strb, stImage, texImage->_BaseFormat,
2678                             destX, destY, slice,
2679                             srcX, srcY, width, height);
2680}
2681
2682
2683/**
2684 * Copy image data from stImage into the texture object 'stObj' at level
2685 * 'dstLevel'.
2686 */
2687static void
2688copy_image_data_to_texture(struct st_context *st,
2689			   struct st_texture_object *stObj,
2690                           GLuint dstLevel,
2691			   struct st_texture_image *stImage)
2692{
2693   /* debug checks */
2694   {
2695      const struct gl_texture_image *dstImage =
2696         stObj->base.Image[stImage->base.Face][dstLevel];
2697      assert(dstImage);
2698      assert(dstImage->Width == stImage->base.Width);
2699      assert(dstImage->Height == stImage->base.Height);
2700      assert(dstImage->Depth == stImage->base.Depth);
2701   }
2702
2703   if (stImage->pt) {
2704      /* Copy potentially with the blitter:
2705       */
2706      GLuint src_level;
2707      if (stImage->pt->last_level == 0)
2708         src_level = 0;
2709      else
2710         src_level = stImage->base.Level;
2711
2712      assert(src_level <= stImage->pt->last_level);
2713      assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width);
2714      assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY ||
2715             u_minify(stImage->pt->height0, src_level) == stImage->base.Height);
2716      assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY ||
2717             stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY ||
2718             u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth);
2719
2720      st_texture_image_copy(st->pipe,
2721                            stObj->pt, dstLevel,  /* dest texture, level */
2722                            stImage->pt, src_level, /* src texture, level */
2723                            stImage->base.Face);
2724
2725      pipe_resource_reference(&stImage->pt, NULL);
2726   }
2727   pipe_resource_reference(&stImage->pt, stObj->pt);
2728}
2729
2730
2731/**
2732 * Called during state validation.  When this function is finished,
2733 * the texture object should be ready for rendering.
2734 * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
2735 */
2736GLboolean
2737st_finalize_texture(struct gl_context *ctx,
2738		    struct pipe_context *pipe,
2739		    struct gl_texture_object *tObj)
2740{
2741   struct st_context *st = st_context(ctx);
2742   struct st_texture_object *stObj = st_texture_object(tObj);
2743   const GLuint nr_faces = _mesa_num_tex_faces(stObj->base.Target);
2744   GLuint face;
2745   const struct st_texture_image *firstImage;
2746   enum pipe_format firstImageFormat;
2747   GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples;
2748
2749   if (tObj->Immutable)
2750      return GL_TRUE;
2751
2752   if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
2753      /* The texture is complete and we know exactly how many mipmap levels
2754       * are present/needed.  This is conditional because we may be called
2755       * from the st_generate_mipmap() function when the texture object is
2756       * incomplete.  In that case, we'll have set stObj->lastLevel before
2757       * we get here.
2758       */
2759      if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
2760          stObj->base.Sampler.MinFilter == GL_NEAREST)
2761         stObj->lastLevel = stObj->base.BaseLevel;
2762      else
2763         stObj->lastLevel = stObj->base._MaxLevel;
2764   }
2765
2766   if (tObj->Target == GL_TEXTURE_BUFFER) {
2767      struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject);
2768
2769      if (!st_obj) {
2770         pipe_resource_reference(&stObj->pt, NULL);
2771         st_texture_release_all_sampler_views(st, stObj);
2772         return GL_TRUE;
2773      }
2774
2775      if (st_obj->buffer != stObj->pt) {
2776         pipe_resource_reference(&stObj->pt, st_obj->buffer);
2777         st_texture_release_all_sampler_views(st, stObj);
2778         stObj->width0 = stObj->pt->width0 / _mesa_get_format_bytes(tObj->_BufferObjectFormat);
2779         stObj->height0 = 1;
2780         stObj->depth0 = 1;
2781      }
2782      return GL_TRUE;
2783
2784   }
2785
2786   firstImage = st_texture_image_const(_mesa_base_tex_image(&stObj->base));
2787   assert(firstImage);
2788
2789   /* If both firstImage and stObj point to a texture which can contain
2790    * all active images, favour firstImage.  Note that because of the
2791    * completeness requirement, we know that the image dimensions
2792    * will match.
2793    */
2794   if (firstImage->pt &&
2795       firstImage->pt != stObj->pt &&
2796       (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) {
2797      pipe_resource_reference(&stObj->pt, firstImage->pt);
2798      st_texture_release_all_sampler_views(st, stObj);
2799   }
2800
2801   /* If this texture comes from a window system, there is nothing else to do. */
2802   if (stObj->surface_based) {
2803      return GL_TRUE;
2804   }
2805
2806   /* Find gallium format for the Mesa texture */
2807   firstImageFormat =
2808      st_mesa_format_to_pipe_format(st, firstImage->base.TexFormat);
2809
2810   /* Find size of level=0 Gallium mipmap image, plus number of texture layers */
2811   {
2812      GLuint width, height, depth;
2813      if (!guess_base_level_size(stObj->base.Target,
2814                                 firstImage->base.Width2,
2815                                 firstImage->base.Height2,
2816                                 firstImage->base.Depth2,
2817                                 firstImage->base.Level,
2818                                 &width, &height, &depth)) {
2819         width = stObj->width0;
2820         height = stObj->height0;
2821         depth = stObj->depth0;
2822      } else {
2823         /* The width/height/depth may have been previously reset in
2824          * guess_and_alloc_texture. */
2825         stObj->width0 = width;
2826         stObj->height0 = height;
2827         stObj->depth0 = depth;
2828      }
2829      /* convert GL dims to Gallium dims */
2830      st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth,
2831                                      &ptWidth, &ptHeight, &ptDepth, &ptLayers);
2832      ptNumSamples = firstImage->base.NumSamples;
2833   }
2834
2835   /* If we already have a gallium texture, check that it matches the texture
2836    * object's format, target, size, num_levels, etc.
2837    */
2838   if (stObj->pt) {
2839      if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
2840          stObj->pt->format != firstImageFormat ||
2841          stObj->pt->last_level < stObj->lastLevel ||
2842          stObj->pt->width0 != ptWidth ||
2843          stObj->pt->height0 != ptHeight ||
2844          stObj->pt->depth0 != ptDepth ||
2845          stObj->pt->nr_samples != ptNumSamples ||
2846          stObj->pt->array_size != ptLayers)
2847      {
2848         /* The gallium texture does not match the Mesa texture so delete the
2849          * gallium texture now.  We'll make a new one below.
2850          */
2851         pipe_resource_reference(&stObj->pt, NULL);
2852         st_texture_release_all_sampler_views(st, stObj);
2853         st->dirty.st |= ST_NEW_FRAMEBUFFER;
2854      }
2855   }
2856
2857   /* May need to create a new gallium texture:
2858    */
2859   if (!stObj->pt) {
2860      GLuint bindings = default_bindings(st, firstImageFormat);
2861
2862      stObj->pt = st_texture_create(st,
2863                                    gl_target_to_pipe(stObj->base.Target),
2864                                    firstImageFormat,
2865                                    stObj->lastLevel,
2866                                    ptWidth,
2867                                    ptHeight,
2868                                    ptDepth,
2869                                    ptLayers, ptNumSamples,
2870                                    bindings);
2871
2872      if (!stObj->pt) {
2873         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
2874         return GL_FALSE;
2875      }
2876   }
2877
2878   /* Pull in any images not in the object's texture:
2879    */
2880   for (face = 0; face < nr_faces; face++) {
2881      GLuint level;
2882      for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) {
2883         struct st_texture_image *stImage =
2884            st_texture_image(stObj->base.Image[face][level]);
2885
2886         /* Need to import images in main memory or held in other textures.
2887          */
2888         if (stImage && stObj->pt != stImage->pt) {
2889            if (level == 0 ||
2890                (stImage->base.Width == u_minify(stObj->width0, level) &&
2891                 stImage->base.Height == u_minify(stObj->height0, level) &&
2892                 stImage->base.Depth == u_minify(stObj->depth0, level))) {
2893               /* src image fits expected dest mipmap level size */
2894               copy_image_data_to_texture(st, stObj, level, stImage);
2895            }
2896         }
2897      }
2898   }
2899
2900   return GL_TRUE;
2901}
2902
2903
2904/**
2905 * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory
2906 * for a whole mipmap stack.
2907 */
2908static GLboolean
2909st_AllocTextureStorage(struct gl_context *ctx,
2910                       struct gl_texture_object *texObj,
2911                       GLsizei levels, GLsizei width,
2912                       GLsizei height, GLsizei depth)
2913{
2914   const GLuint numFaces = _mesa_num_tex_faces(texObj->Target);
2915   struct gl_texture_image *texImage = texObj->Image[0][0];
2916   struct st_context *st = st_context(ctx);
2917   struct st_texture_object *stObj = st_texture_object(texObj);
2918   struct pipe_screen *screen = st->pipe->screen;
2919   GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings;
2920   enum pipe_format fmt;
2921   GLint level;
2922   GLuint num_samples = texImage->NumSamples;
2923
2924   assert(levels > 0);
2925
2926   /* Save the level=0 dimensions */
2927   stObj->width0 = width;
2928   stObj->height0 = height;
2929   stObj->depth0 = depth;
2930   stObj->lastLevel = levels - 1;
2931
2932   fmt = st_mesa_format_to_pipe_format(st, texImage->TexFormat);
2933
2934   bindings = default_bindings(st, fmt);
2935
2936   /* Raise the sample count if the requested one is unsupported. */
2937   if (num_samples > 1) {
2938      boolean found = FALSE;
2939
2940      for (; num_samples <= ctx->Const.MaxSamples; num_samples++) {
2941         if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D,
2942                                         num_samples,
2943                                         PIPE_BIND_SAMPLER_VIEW)) {
2944            /* Update the sample count in gl_texture_image as well. */
2945            texImage->NumSamples = num_samples;
2946            found = TRUE;
2947            break;
2948         }
2949      }
2950
2951      if (!found) {
2952         return GL_FALSE;
2953      }
2954   }
2955
2956   st_gl_texture_dims_to_pipe_dims(texObj->Target,
2957                                   width, height, depth,
2958                                   &ptWidth, &ptHeight, &ptDepth, &ptLayers);
2959
2960   stObj->pt = st_texture_create(st,
2961                                 gl_target_to_pipe(texObj->Target),
2962                                 fmt,
2963                                 levels - 1,
2964                                 ptWidth,
2965                                 ptHeight,
2966                                 ptDepth,
2967                                 ptLayers, num_samples,
2968                                 bindings);
2969   if (!stObj->pt)
2970      return GL_FALSE;
2971
2972   /* Set image resource pointers */
2973   for (level = 0; level < levels; level++) {
2974      GLuint face;
2975      for (face = 0; face < numFaces; face++) {
2976         struct st_texture_image *stImage =
2977            st_texture_image(texObj->Image[face][level]);
2978         pipe_resource_reference(&stImage->pt, stObj->pt);
2979      }
2980   }
2981
2982   return GL_TRUE;
2983}
2984
2985
2986static GLboolean
2987st_TestProxyTexImage(struct gl_context *ctx, GLenum target,
2988                     GLint level, mesa_format format,
2989                     GLint width, GLint height,
2990                     GLint depth, GLint border)
2991{
2992   struct st_context *st = st_context(ctx);
2993   struct pipe_context *pipe = st->pipe;
2994
2995   if (width == 0 || height == 0 || depth == 0) {
2996      /* zero-sized images are legal, and always fit! */
2997      return GL_TRUE;
2998   }
2999
3000   if (pipe->screen->can_create_resource) {
3001      /* Ask the gallium driver if the texture is too large */
3002      struct gl_texture_object *texObj =
3003         _mesa_get_current_tex_object(ctx, target);
3004      struct pipe_resource pt;
3005
3006      /* Setup the pipe_resource object
3007       */
3008      memset(&pt, 0, sizeof(pt));
3009
3010      pt.target = gl_target_to_pipe(target);
3011      pt.format = st_mesa_format_to_pipe_format(st, format);
3012
3013      st_gl_texture_dims_to_pipe_dims(target,
3014                                      width, height, depth,
3015                                      &pt.width0, &pt.height0,
3016                                      &pt.depth0, &pt.array_size);
3017
3018      if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR ||
3019                         texObj->Sampler.MinFilter == GL_NEAREST)) {
3020         /* assume just one mipmap level */
3021         pt.last_level = 0;
3022      }
3023      else {
3024         /* assume a full set of mipmaps */
3025         pt.last_level = _mesa_logbase2(MAX3(width, height, depth));
3026      }
3027
3028      return pipe->screen->can_create_resource(pipe->screen, &pt);
3029   }
3030   else {
3031      /* Use core Mesa fallback */
3032      return _mesa_test_proxy_teximage(ctx, target, level, format,
3033                                       width, height, depth, border);
3034   }
3035}
3036
3037static GLboolean
3038st_TextureView(struct gl_context *ctx,
3039               struct gl_texture_object *texObj,
3040               struct gl_texture_object *origTexObj)
3041{
3042   struct st_texture_object *orig = st_texture_object(origTexObj);
3043   struct st_texture_object *tex = st_texture_object(texObj);
3044   struct gl_texture_image *image = texObj->Image[0][0];
3045
3046   const int numFaces = _mesa_num_tex_faces(texObj->Target);
3047   const int numLevels = texObj->NumLevels;
3048
3049   int face;
3050   int level;
3051
3052   pipe_resource_reference(&tex->pt, orig->pt);
3053
3054   /* Set image resource pointers */
3055   for (level = 0; level < numLevels; level++) {
3056      for (face = 0; face < numFaces; face++) {
3057         struct st_texture_image *stImage =
3058            st_texture_image(texObj->Image[face][level]);
3059         pipe_resource_reference(&stImage->pt, tex->pt);
3060      }
3061   }
3062
3063   tex->surface_based = GL_TRUE;
3064   tex->surface_format =
3065      st_mesa_format_to_pipe_format(st_context(ctx), image->TexFormat);
3066
3067   tex->width0 = image->Width;
3068   tex->height0 = image->Height;
3069   tex->depth0 = image->Depth;
3070   tex->lastLevel = numLevels - 1;
3071
3072   return GL_TRUE;
3073}
3074
3075static void
3076st_ClearTexSubImage(struct gl_context *ctx,
3077                    struct gl_texture_image *texImage,
3078                    GLint xoffset, GLint yoffset, GLint zoffset,
3079                    GLsizei width, GLsizei height, GLsizei depth,
3080                    const GLvoid *clearValue)
3081{
3082   static const char zeros[16] = {0};
3083   struct st_texture_image *stImage = st_texture_image(texImage);
3084   struct pipe_resource *pt = stImage->pt;
3085   struct st_context *st = st_context(ctx);
3086   struct pipe_context *pipe = st->pipe;
3087   unsigned level = texImage->Level;
3088   struct pipe_box box;
3089
3090   if (!pt)
3091      return;
3092
3093   u_box_3d(xoffset, yoffset, zoffset + texImage->Face,
3094            width, height, depth, &box);
3095   if (texImage->TexObject->Immutable) {
3096      level += texImage->TexObject->MinLevel;
3097      box.z += texImage->TexObject->MinLayer;
3098   }
3099
3100   pipe->clear_texture(pipe, pt, level, &box, clearValue ? clearValue : zeros);
3101}
3102
3103void
3104st_init_texture_functions(struct dd_function_table *functions)
3105{
3106   functions->ChooseTextureFormat = st_ChooseTextureFormat;
3107   functions->QuerySamplesForFormat = st_QuerySamplesForFormat;
3108   functions->TexImage = st_TexImage;
3109   functions->TexSubImage = st_TexSubImage;
3110   functions->CompressedTexSubImage = st_CompressedTexSubImage;
3111   functions->CopyTexSubImage = st_CopyTexSubImage;
3112   functions->GenerateMipmap = st_generate_mipmap;
3113
3114   functions->GetTexSubImage = st_GetTexSubImage;
3115
3116   /* compressed texture functions */
3117   functions->CompressedTexImage = st_CompressedTexImage;
3118   functions->GetCompressedTexSubImage = _mesa_GetCompressedTexSubImage_sw;
3119
3120   functions->NewTextureObject = st_NewTextureObject;
3121   functions->NewTextureImage = st_NewTextureImage;
3122   functions->DeleteTextureImage = st_DeleteTextureImage;
3123   functions->DeleteTexture = st_DeleteTextureObject;
3124   functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
3125   functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
3126   functions->MapTextureImage = st_MapTextureImage;
3127   functions->UnmapTextureImage = st_UnmapTextureImage;
3128
3129   /* XXX Temporary until we can query pipe's texture sizes */
3130   functions->TestProxyTexImage = st_TestProxyTexImage;
3131
3132   functions->AllocTextureStorage = st_AllocTextureStorage;
3133   functions->TextureView = st_TextureView;
3134   functions->ClearTexSubImage = st_ClearTexSubImage;
3135}
3136