src/mesa/drivers/dri/nouveau/nouveau_texture.c

   1 /*
   2  * Copyright (C) 2009 Francisco Jerez.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  */
  26
  27 #include "nouveau_driver.h"
  28 #include "nouveau_context.h"
  29 #include "nouveau_texture.h"
  30 #include "nouveau_fbo.h"
  31 #include "nouveau_util.h"
  32
  33 #include "main/pbo.h"
  34 #include "main/texobj.h"
  35 #include "main/texstore.h"
  36 #include "main/texformat.h"
  37 #include "main/texcompress.h"
  38 #include "main/texgetimage.h"
  39 #include "main/mipmap.h"
  40 #include "main/teximage.h"
  41 #include "drivers/common/meta.h"
  42 #include "swrast/s_texfetch.h"
  43
  44 static struct gl_texture_object *
  45 nouveau_texture_new(struct gl_context *ctx, GLuint name, GLenum target)
  46 {
  47         struct nouveau_texture *nt = CALLOC_STRUCT(nouveau_texture);
  48
  49         _mesa_initialize_texture_object(&nt->base, name, target);
  50
  51         return &nt->base;
  52 }
  53
  54 static void
  55 nouveau_texture_free(struct gl_context *ctx, struct gl_texture_object *t)
  56 {
  57         struct nouveau_texture *nt = to_nouveau_texture(t);
  58         int i;
  59
  60         for (i = 0; i < MAX_TEXTURE_LEVELS; i++)
  61                 nouveau_surface_ref(NULL, &nt->surfaces[i]);
  62
  63         _mesa_delete_texture_object(ctx, t);
  64 }
  65
  66 static struct gl_texture_image *
  67 nouveau_teximage_new(struct gl_context *ctx)
  68 {
  69         struct nouveau_teximage *nti = CALLOC_STRUCT(nouveau_teximage);
  70
  71         return &nti->base.Base;
  72 }
  73
  74 static void
  75 nouveau_teximage_free(struct gl_context *ctx, struct gl_texture_image *ti)
  76 {
  77         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
  78
  79         nouveau_surface_ref(NULL, &nti->surface);
  80 }
  81
  82 static void
  83 nouveau_teximage_map(struct gl_context *ctx, struct gl_texture_image *ti,
  84                      int access, int x, int y, int w, int h)
  85 {
  86         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
  87         struct nouveau_surface *s = &nti->surface;
  88         struct nouveau_surface *st = &nti->transfer.surface;
  89         struct nouveau_client *client = context_client(ctx);
  90
  91         if (s->bo) {
  92                 if (!(access & GL_MAP_READ_BIT) &&
  93                     nouveau_pushbuf_refd(context_push(ctx), s->bo)) {
  94                         unsigned size;
  95                         /*
  96                          * Heuristic: use a bounce buffer to pipeline
  97                          * teximage transfers.
  98                          */
  99                         st->layout = LINEAR;
 100                         st->format = s->format;
 101                         st->cpp = s->cpp;
 102                         st->width = w;
 103                         st->height = h;
 104                         st->pitch = s->pitch;
 105                         nti->transfer.x = x;
 106                         nti->transfer.y = y;
 107
 108                         size = get_format_blocksy(st->format, h) * st->pitch;
 109                         nti->base.Map = nouveau_get_scratch(ctx, size,
 110                                                        &st->bo, &st->offset);
 111
 112                 } else {
 113                         int ret, flags = 0;
 114
 115                         if (access & GL_MAP_READ_BIT)
 116                                 flags |= NOUVEAU_BO_RD;
 117                         if (access & GL_MAP_WRITE_BIT)
 118                                 flags |= NOUVEAU_BO_WR;
 119
 120                         if (!s->bo->map) {
 121                                 ret = nouveau_bo_map(s->bo, flags, client);
 122                                 assert(!ret);
 123                         }
 124
 125                         nti->base.Map = s->bo->map +
 126                                 get_format_blocksy(s->format, y) * s->pitch +
 127                                 get_format_blocksx(s->format, x) * s->cpp;
 128
 129                 }
 130         }
 131 }
 132
 133 static void
 134 nouveau_teximage_unmap(struct gl_context *ctx, struct gl_texture_image *ti)
 135 {
 136         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
 137         struct nouveau_surface *s = &nti->surface;
 138         struct nouveau_surface *st = &nti->transfer.surface;
 139
 140         if (st->bo) {
 141                 context_drv(ctx)->surface_copy(ctx, s, st, nti->transfer.x,
 142                                                nti->transfer.y, 0, 0,
 143                                                st->width, st->height);
 144                 nouveau_surface_ref(NULL, st);
 145
 146         }
 147         nti->base.Map = NULL;
 148 }
 149
 150
 151 static void
 152 nouveau_map_texture_image(struct gl_context *ctx,
 153                           struct gl_texture_image *ti,
 154                           GLuint slice,
 155                           GLuint x, GLuint y, GLuint w, GLuint h,
 156                           GLbitfield mode,
 157                           GLubyte **map,
 158                           GLint *stride)
 159 {
 160         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
 161         struct nouveau_surface *s = &nti->surface;
 162         struct nouveau_surface *st = &nti->transfer.surface;
 163         struct nouveau_client *client = context_client(ctx);
 164
 165         /* Nouveau has no support for 3D or cubemap textures. */
 166         assert(slice == 0);
 167
 168         if (s->bo) {
 169                 if (!(mode & GL_MAP_READ_BIT) &&
 170                     nouveau_pushbuf_refd(context_push(ctx), s->bo)) {
 171                         unsigned size;
 172                         /*
 173                          * Heuristic: use a bounce buffer to pipeline
 174                          * teximage transfers.
 175                          */
 176                         st->layout = LINEAR;
 177                         st->format = s->format;
 178                         st->cpp = s->cpp;
 179                         st->width = w;
 180                         st->height = h;
 181                         st->pitch = s->pitch;
 182                         nti->transfer.x = x;
 183                         nti->transfer.y = y;
 184
 185                         size = get_format_blocksy(st->format, h) * st->pitch;
 186                         *map = nouveau_get_scratch(ctx, size,
 187                                           &st->bo, &st->offset);
 188                         *stride = st->pitch;
 189                 } else {
 190                         int ret, flags = 0;
 191
 192                         if (mode & GL_MAP_READ_BIT)
 193                                 flags |= NOUVEAU_BO_RD;
 194                         if (mode & GL_MAP_WRITE_BIT)
 195                                 flags |= NOUVEAU_BO_WR;
 196
 197                         if (!s->bo->map) {
 198                                 ret = nouveau_bo_map(s->bo, flags, client);
 199                                 assert(!ret);
 200                         }
 201
 202                         *map = s->bo->map +
 203                                 get_format_blocksy(s->format, y) * s->pitch +
 204                                 get_format_blocksx(s->format, x) * s->cpp;
 205                         *stride = s->pitch;
 206                 }
 207         } else {
 208                 *map = nti->base.Map +
 209                         get_format_blocksy(s->format, y) * s->pitch +
 210                         get_format_blocksx(s->format, x) * s->cpp;
 211                 *stride = s->pitch;
 212         }
 213 }
 214
 215 static void
 216 nouveau_unmap_texture_image(struct gl_context *ctx, struct gl_texture_image *ti,
 217                             GLuint slice)
 218 {
 219         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
 220         struct nouveau_surface *s = &nti->surface;
 221         struct nouveau_surface *st = &nti->transfer.surface;
 222
 223         if (st->bo) {
 224                 context_drv(ctx)->surface_copy(ctx, s, st, nti->transfer.x,
 225                                                nti->transfer.y, 0, 0,
 226                                                st->width, st->height);
 227                 nouveau_surface_ref(NULL, st);
 228
 229         }
 230
 231         nti->base.Map = NULL;
 232 }
 233
 234 static gl_format
 235 nouveau_choose_tex_format(struct gl_context *ctx, GLenum target,
 236                           GLint internalFormat,
 237                           GLenum srcFormat, GLenum srcType)
 238 {
 239         switch (internalFormat) {
 240         case 4:
 241         case GL_RGBA:
 242         case GL_RGBA2:
 243         case GL_RGBA4:
 244         case GL_RGBA8:
 245         case GL_RGBA12:
 246         case GL_RGBA16:
 247         case GL_RGB10_A2:
 248         case GL_COMPRESSED_RGBA:
 249                 return MESA_FORMAT_ARGB8888;
 250         case GL_RGB5_A1:
 251                 return MESA_FORMAT_ARGB1555;
 252
 253         case GL_RGB:
 254         case GL_RGB8:
 255         case GL_RGB10:
 256         case GL_RGB12:
 257         case GL_RGB16:
 258         case GL_COMPRESSED_RGB:
 259                 return MESA_FORMAT_XRGB8888;
 260         case 3:
 261         case GL_R3_G3_B2:
 262         case GL_RGB4:
 263         case GL_RGB5:
 264                 return MESA_FORMAT_RGB565;
 265
 266         case 2:
 267         case GL_LUMINANCE_ALPHA:
 268         case GL_LUMINANCE4_ALPHA4:
 269         case GL_LUMINANCE6_ALPHA2:
 270         case GL_LUMINANCE12_ALPHA4:
 271         case GL_LUMINANCE12_ALPHA12:
 272         case GL_LUMINANCE16_ALPHA16:
 273         case GL_LUMINANCE8_ALPHA8:
 274         case GL_COMPRESSED_LUMINANCE_ALPHA:
 275                 return MESA_FORMAT_ARGB8888;
 276
 277         case 1:
 278         case GL_LUMINANCE:
 279         case GL_LUMINANCE4:
 280         case GL_LUMINANCE12:
 281         case GL_LUMINANCE16:
 282         case GL_LUMINANCE8:
 283         case GL_COMPRESSED_LUMINANCE:
 284                 return MESA_FORMAT_L8;
 285
 286         case GL_ALPHA:
 287         case GL_ALPHA4:
 288         case GL_ALPHA12:
 289         case GL_ALPHA16:
 290         case GL_ALPHA8:
 291         case GL_COMPRESSED_ALPHA:
 292                 return MESA_FORMAT_A8;
 293
 294         case GL_INTENSITY:
 295         case GL_INTENSITY4:
 296         case GL_INTENSITY12:
 297         case GL_INTENSITY16:
 298         case GL_INTENSITY8:
 299                 return MESA_FORMAT_I8;
 300
 301         case GL_RGB_S3TC:
 302         case GL_RGB4_S3TC:
 303         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 304                 return MESA_FORMAT_RGB_DXT1;
 305
 306         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 307                 return MESA_FORMAT_RGBA_DXT1;
 308
 309         case GL_RGBA_S3TC:
 310         case GL_RGBA4_S3TC:
 311         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 312                 return MESA_FORMAT_RGBA_DXT3;
 313
 314         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 315                 return MESA_FORMAT_RGBA_DXT5;
 316
 317         default:
 318                 assert(0);
 319         }
 320 }
 321
 322 static GLboolean
 323 teximage_fits(struct gl_texture_object *t, int level)
 324 {
 325         struct nouveau_surface *s = &to_nouveau_texture(t)->surfaces[level];
 326         struct gl_texture_image *ti = t->Image[0][level];
 327
 328         if (!ti || !to_nouveau_teximage(ti)->surface.bo)
 329                 return GL_FALSE;
 330
 331         if (level == t->BaseLevel && (s->offset & 0x7f))
 332                 return GL_FALSE;
 333
 334         return t->Target == GL_TEXTURE_RECTANGLE ||
 335                 (s->bo && s->format == ti->TexFormat &&
 336                  s->width == ti->Width && s->height == ti->Height);
 337 }
 338
 339 static GLboolean
 340 validate_teximage(struct gl_context *ctx, struct gl_texture_object *t,
 341                   int level, int x, int y, int z,
 342                   int width, int height, int depth)
 343 {
 344         struct gl_texture_image *ti = t->Image[0][level];
 345
 346         if (teximage_fits(t, level)) {
 347                 struct nouveau_surface *ss = to_nouveau_texture(t)->surfaces;
 348                 struct nouveau_surface *s = &to_nouveau_teximage(ti)->surface;
 349
 350                 if (t->Target == GL_TEXTURE_RECTANGLE)
 351                         nouveau_surface_ref(s, &ss[level]);
 352                 else
 353                         context_drv(ctx)->surface_copy(ctx, &ss[level], s,
 354                                                        x, y, x, y,
 355                                                        width, height);
 356
 357                 return GL_TRUE;
 358         }
 359
 360         return GL_FALSE;
 361 }
 362
 363 static int
 364 get_last_level(struct gl_texture_object *t)
 365 {
 366         struct gl_texture_image *base = t->Image[0][t->BaseLevel];
 367
 368         if (t->Sampler.MinFilter == GL_NEAREST ||
 369             t->Sampler.MinFilter == GL_LINEAR || !base)
 370                 return t->BaseLevel;
 371         else
 372                 return MIN2(t->BaseLevel + base->MaxNumLevels - 1, t->MaxLevel);
 373 }
 374
 375 static void
 376 relayout_texture(struct gl_context *ctx, struct gl_texture_object *t)
 377 {
 378         struct gl_texture_image *base = t->Image[0][t->BaseLevel];
 379
 380         if (base && t->Target != GL_TEXTURE_RECTANGLE) {
 381                 struct nouveau_surface *ss = to_nouveau_texture(t)->surfaces;
 382                 struct nouveau_surface *s = &to_nouveau_teximage(base)->surface;
 383                 int i, ret, last = get_last_level(t);
 384                 enum nouveau_surface_layout layout =
 385                         (_mesa_is_format_compressed(s->format) ? LINEAR : SWIZZLED);
 386                 unsigned size, pitch, offset = 0,
 387                         width = s->width,
 388                         height = s->height;
 389
 390                 /* Deallocate the old storage. */
 391                 for (i = 0; i < MAX_TEXTURE_LEVELS; i++)
 392                         nouveau_bo_ref(NULL, &ss[i].bo);
 393
 394                 /* Relayout the mipmap tree. */
 395                 for (i = t->BaseLevel; i <= last; i++) {
 396                         pitch = _mesa_format_row_stride(s->format, width);
 397                         size = get_format_blocksy(s->format, height) * pitch;
 398
 399                         /* Images larger than 16B have to be aligned. */
 400                         if (size > 16)
 401                                 offset = align(offset, 64);
 402
 403                         ss[i] = (struct nouveau_surface) {
 404                                 .offset = offset,
 405                                 .layout = layout,
 406                                 .format = s->format,
 407                                 .width = width,
 408                                 .height = height,
 409                                 .cpp = s->cpp,
 410                                 .pitch = pitch,
 411                         };
 412
 413                         offset += size;
 414                         width = MAX2(1, width / 2);
 415                         height = MAX2(1, height / 2);
 416                 }
 417
 418                 /* Get new storage. */
 419                 size = align(offset, 64);
 420
 421                 ret = nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_MAP |
 422                                      NOUVEAU_BO_GART | NOUVEAU_BO_VRAM,
 423                                      0, size, NULL, &ss[last].bo);
 424                 assert(!ret);
 425
 426                 for (i = t->BaseLevel; i < last; i++)
 427                         nouveau_bo_ref(ss[last].bo, &ss[i].bo);
 428         }
 429 }
 430
 431 GLboolean
 432 nouveau_texture_validate(struct gl_context *ctx, struct gl_texture_object *t)
 433 {
 434         struct nouveau_texture *nt = to_nouveau_texture(t);
 435         int i, last = get_last_level(t);
 436
 437         if (!teximage_fits(t, t->BaseLevel) ||
 438             !teximage_fits(t, last))
 439                 return GL_FALSE;
 440
 441         if (nt->dirty) {
 442                 nt->dirty = GL_FALSE;
 443
 444                 /* Copy the teximages to the actual miptree. */
 445                 for (i = t->BaseLevel; i <= last; i++) {
 446                         struct nouveau_surface *s = &nt->surfaces[i];
 447
 448                         validate_teximage(ctx, t, i, 0, 0, 0,
 449                                           s->width, s->height, 1);
 450                 }
 451
 452                 PUSH_KICK(context_push(ctx));
 453         }
 454
 455         return GL_TRUE;
 456 }
 457
 458 void
 459 nouveau_texture_reallocate(struct gl_context *ctx, struct gl_texture_object *t)
 460 {
 461         if (!teximage_fits(t, t->BaseLevel) ||
 462             !teximage_fits(t, get_last_level(t))) {
 463                 texture_dirty(t);
 464                 relayout_texture(ctx, t);
 465                 nouveau_texture_validate(ctx, t);
 466         }
 467 }
 468
 469 static unsigned
 470 get_teximage_placement(struct gl_texture_image *ti)
 471 {
 472         if (ti->TexFormat == MESA_FORMAT_A8 ||
 473             ti->TexFormat == MESA_FORMAT_L8 ||
 474             ti->TexFormat == MESA_FORMAT_I8)
 475                 /* 1 cpp formats will have to be swizzled by the CPU,
 476                  * so leave them in system RAM for now. */
 477                 return NOUVEAU_BO_MAP;
 478         else
 479                 return NOUVEAU_BO_GART | NOUVEAU_BO_MAP;
 480 }
 481
 482 static void
 483 nouveau_teximage(struct gl_context *ctx, GLint dims,
 484                  struct gl_texture_image *ti,
 485                  GLsizei imageSize,
 486                  GLenum format, GLenum type, const GLvoid *pixels,
 487                  const struct gl_pixelstore_attrib *packing,
 488                  GLboolean compressed)
 489 {
 490         struct gl_texture_object *t = ti->TexObject;
 491         const GLuint level = ti->Level;
 492         struct nouveau_surface *s = &to_nouveau_teximage(ti)->surface;
 493         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
 494         int ret;
 495         GLuint depth = compressed ? 1 : ti->Depth;
 496
 497         /* Allocate a new bo for the image. */
 498         nouveau_surface_alloc(ctx, s, LINEAR, get_teximage_placement(ti),
 499                               ti->TexFormat, ti->Width, ti->Height);
 500         nti->base.RowStride = s->pitch / s->cpp;
 501
 502         if (compressed)
 503                 pixels = _mesa_validate_pbo_compressed_teximage(ctx,
 504                         imageSize,
 505                         pixels, packing, "glCompressedTexImage");
 506         else
 507                 pixels = _mesa_validate_pbo_teximage(ctx,
 508                         dims, ti->Width, ti->Height, depth, format, type,
 509                         pixels, packing, "glTexImage");
 510
 511         if (pixels) {
 512                 /* Store the pixel data. */
 513                 nouveau_teximage_map(ctx, ti, GL_MAP_WRITE_BIT,
 514                                      0, 0, ti->Width, ti->Height);
 515
 516                 ret = _mesa_texstore(ctx, dims, ti->_BaseFormat,
 517                                      ti->TexFormat,
 518                                      s->pitch,
 519                                      &nti->base.Map,
 520                                      ti->Width, ti->Height, depth,
 521                                      format, type, pixels, packing);
 522                 assert(ret);
 523
 524                 nouveau_teximage_unmap(ctx, ti);
 525                 _mesa_unmap_teximage_pbo(ctx, packing);
 526
 527                 if (!validate_teximage(ctx, t, level, 0, 0, 0,
 528                                        ti->Width, ti->Height, depth))
 529                         /* It doesn't fit, mark it as dirty. */
 530                         texture_dirty(t);
 531         }
 532
 533         if (level == t->BaseLevel) {
 534                 if (!teximage_fits(t, level))
 535                         relayout_texture(ctx, t);
 536                 nouveau_texture_validate(ctx, t);
 537         }
 538
 539         context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 540         context_dirty_i(ctx, TEX_ENV, ctx->Texture.CurrentUnit);
 541 }
 542
 543
 544 static void
 545 nouveau_teximage_123d(struct gl_context *ctx, GLuint dims,
 546                       struct gl_texture_image *ti,
 547                       GLenum format, GLenum type, const GLvoid *pixels,
 548                       const struct gl_pixelstore_attrib *packing)
 549 {
 550         nouveau_teximage(ctx, dims, ti, 0, format, type, pixels,
 551                          packing, GL_FALSE);
 552 }
 553
 554 static void
 555 nouveau_compressed_teximage(struct gl_context *ctx, GLuint dims,
 556                     struct gl_texture_image *ti,
 557                     GLsizei imageSize, const GLvoid *data)
 558 {
 559         nouveau_teximage(ctx, 2, ti, imageSize, 0, 0, data,
 560                          &ctx->Unpack, GL_TRUE);
 561 }
 562
 563 static void
 564 nouveau_texsubimage(struct gl_context *ctx, GLint dims,
 565                     struct gl_texture_image *ti,
 566                     GLint xoffset, GLint yoffset, GLint zoffset,
 567                     GLint width, GLint height, GLint depth,
 568                     GLsizei imageSize,
 569                     GLenum format, GLenum type, const void *pixels,
 570                     const struct gl_pixelstore_attrib *packing,
 571                     GLboolean compressed)
 572 {
 573         struct nouveau_surface *s = &to_nouveau_teximage(ti)->surface;
 574         struct nouveau_teximage *nti = to_nouveau_teximage(ti);
 575         int ret;
 576
 577         if (compressed)
 578                 pixels = _mesa_validate_pbo_compressed_teximage(ctx,
 579                                 imageSize,
 580                                 pixels, packing, "glCompressedTexSubImage");
 581         else
 582                 pixels = _mesa_validate_pbo_teximage(ctx,
 583                                 dims, width, height, depth, format, type,
 584                                 pixels, packing, "glTexSubImage");
 585
 586         if (pixels) {
 587                 nouveau_teximage_map(ctx, ti, GL_MAP_WRITE_BIT,
 588                                      xoffset, yoffset, width, height);
 589
 590                 ret = _mesa_texstore(ctx, dims, ti->_BaseFormat, ti->TexFormat,
 591                                      s->pitch,
 592                                      &nti->base.Map,
 593                                      width, height, depth,
 594                                      format, type, pixels, packing);
 595                 assert(ret);
 596
 597                 nouveau_teximage_unmap(ctx, ti);
 598                 _mesa_unmap_teximage_pbo(ctx, packing);
 599         }
 600
 601         if (!to_nouveau_texture(ti->TexObject)->dirty)
 602                 validate_teximage(ctx, ti->TexObject, ti->Level,
 603                                   xoffset, yoffset, zoffset,
 604                                   width, height, depth);
 605 }
 606
 607 static void
 608 nouveau_texsubimage_123d(struct gl_context *ctx, GLuint dims,
 609                          struct gl_texture_image *ti,
 610                          GLint xoffset, GLint yoffset, GLint zoffset,
 611                          GLint width, GLint height, GLint depth,
 612                          GLenum format, GLenum type, const void *pixels,
 613                          const struct gl_pixelstore_attrib *packing)
 614 {
 615         nouveau_texsubimage(ctx, dims, ti, xoffset, yoffset, zoffset,
 616                             width, height, depth, 0, format, type, pixels,
 617                             packing, GL_FALSE);
 618 }
 619
 620 static void
 621 nouveau_compressed_texsubimage(struct gl_context *ctx, GLuint dims,
 622                        struct gl_texture_image *ti,
 623                        GLint xoffset, GLint yoffset, GLint zoffset,
 624                        GLsizei width, GLint height, GLint depth,
 625                        GLenum format,
 626                        GLint imageSize, const void *data)
 627 {
 628         nouveau_texsubimage(ctx, dims, ti, xoffset, yoffset, zoffset,
 629                           width, height, depth, imageSize, format, 0, data,
 630                           &ctx->Unpack, GL_TRUE);
 631 }
 632
 633 static void
 634 nouveau_bind_texture(struct gl_context *ctx, GLenum target,
 635                      struct gl_texture_object *t)
 636 {
 637         context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 638         context_dirty_i(ctx, TEX_ENV, ctx->Texture.CurrentUnit);
 639 }
 640
 641 static gl_format
 642 get_texbuffer_format(struct gl_renderbuffer *rb, GLint format)
 643 {
 644         struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface;
 645
 646         if (s->cpp < 4)
 647                 return s->format;
 648         else if (format == __DRI_TEXTURE_FORMAT_RGBA)
 649                 return MESA_FORMAT_ARGB8888;
 650         else
 651                 return MESA_FORMAT_XRGB8888;
 652 }
 653
 654 void
 655 nouveau_set_texbuffer(__DRIcontext *dri_ctx,
 656                       GLint target, GLint format,
 657                       __DRIdrawable *draw)
 658 {
 659         struct nouveau_context *nctx = dri_ctx->driverPrivate;
 660         struct gl_context *ctx = &nctx->base;
 661         struct gl_framebuffer *fb = draw->driverPrivate;
 662         struct gl_renderbuffer *rb =
 663                 fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer;
 664         struct gl_texture_object *t = _mesa_get_current_tex_object(ctx, target);
 665         struct gl_texture_image *ti;
 666         struct nouveau_teximage *nti;
 667         struct nouveau_surface *s;
 668
 669         _mesa_lock_texture(ctx, t);
 670         ti = _mesa_get_tex_image(ctx, t, target, 0);
 671         nti = to_nouveau_teximage(ti);
 672         s = &to_nouveau_teximage(ti)->surface;
 673
 674         /* Update the texture surface with the given drawable. */
 675         nouveau_update_renderbuffers(dri_ctx, draw);
 676         nouveau_surface_ref(&to_nouveau_renderbuffer(rb)->surface, s);
 677
 678         s->format = get_texbuffer_format(rb, format);
 679
 680         /* Update the image fields. */
 681         _mesa_init_teximage_fields(ctx, ti, s->width, s->height,
 682                                    1, 0, s->cpp, s->format);
 683         nti->base.RowStride = s->pitch / s->cpp;
 684
 685         /* Try to validate it. */
 686         if (!validate_teximage(ctx, t, 0, 0, 0, 0, s->width, s->height, 1))
 687                 nouveau_texture_reallocate(ctx, t);
 688
 689         context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 690         context_dirty_i(ctx, TEX_ENV, ctx->Texture.CurrentUnit);
 691
 692         _mesa_unlock_texture(ctx, t);
 693 }
 694
 695 void
 696 nouveau_texture_functions_init(struct dd_function_table *functions)
 697 {
 698         functions->NewTextureObject = nouveau_texture_new;
 699         functions->DeleteTexture = nouveau_texture_free;
 700         functions->NewTextureImage = nouveau_teximage_new;
 701         functions->FreeTextureImageBuffer = nouveau_teximage_free;
 702         functions->ChooseTextureFormat = nouveau_choose_tex_format;
 703         functions->TexImage = nouveau_teximage_123d;
 704         functions->TexSubImage = nouveau_texsubimage_123d;
 705         functions->CompressedTexImage = nouveau_compressed_teximage;
 706         functions->CompressedTexSubImage = nouveau_compressed_texsubimage;
 707         functions->BindTexture = nouveau_bind_texture;
 708         functions->MapTextureImage = nouveau_map_texture_image;
 709         functions->UnmapTextureImage = nouveau_unmap_texture_image;
 710 }