src/mesa/state_tracker/st_cb_drawpixels.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28  /*
  29   * Authors:
  30   *   Brian Paul
  31   */
  32
  33 #include "main/imports.h"
  34 #include "main/image.h"
  35 #include "main/bufferobj.h"
  36 #include "main/macros.h"
  37 #include "main/texformat.h"
  38 #include "main/texstore.h"
  39 #include "shader/program.h"
  40 #include "shader/prog_print.h"
  41
  42 #include "st_debug.h"
  43 #include "st_context.h"
  44 #include "st_atom.h"
  45 #include "st_atom_constbuf.h"
  46 #include "st_program.h"
  47 #include "st_cb_drawpixels.h"
  48 #include "st_cb_readpixels.h"
  49 #include "st_cb_fbo.h"
  50 #include "st_format.h"
  51 #include "st_texture.h"
  52 #include "st_inlines.h"
  53
  54 #include "pipe/p_context.h"
  55 #include "pipe/p_defines.h"
  56 #include "util/u_inlines.h"
  57 #include "tgsi/tgsi_ureg.h"
  58 #include "util/u_tile.h"
  59 #include "util/u_draw_quad.h"
  60 #include "util/u_format.h"
  61 #include "util/u_math.h"
  62 #include "util/u_rect.h"
  63 #include "shader/prog_instruction.h"
  64 #include "cso_cache/cso_context.h"
  65
  66
  67 /**
  68  * Check if the given program is:
  69  * 0: MOVE result.color, fragment.color;
  70  * 1: END;
  71  */
  72 static GLboolean
  73 is_passthrough_program(const struct gl_fragment_program *prog)
  74 {
  75    if (prog->Base.NumInstructions == 2) {
  76       const struct prog_instruction *inst = prog->Base.Instructions;
  77       if (inst[0].Opcode == OPCODE_MOV &&
  78           inst[1].Opcode == OPCODE_END &&
  79           inst[0].DstReg.File == PROGRAM_OUTPUT &&
  80           inst[0].DstReg.Index == FRAG_RESULT_COLOR &&
  81           inst[0].DstReg.WriteMask == WRITEMASK_XYZW &&
  82           inst[0].SrcReg[0].File == PROGRAM_INPUT &&
  83           inst[0].SrcReg[0].Index == FRAG_ATTRIB_COL0 &&
  84           inst[0].SrcReg[0].Swizzle == SWIZZLE_XYZW) {
  85          return GL_TRUE;
  86       }
  87    }
  88    return GL_FALSE;
  89 }
  90
  91
  92
  93 /**
  94  * Make fragment shader for glDraw/CopyPixels.  This shader is made
  95  * by combining the pixel transfer shader with the user-defined shader.
  96  * \return pointer to Gallium driver fragment shader
  97  */
  98 static void *
  99 combined_drawpix_fragment_program(GLcontext *ctx)
 100 {
 101    struct st_context *st = st_context(ctx);
 102    struct st_fragment_program *stfp;
 103
 104    if (st->pixel_xfer.program->serialNo == st->pixel_xfer.xfer_prog_sn
 105        && st->fp->serialNo == st->pixel_xfer.user_prog_sn) {
 106       /* the pixel tranfer program has not changed and the user-defined
 107        * program has not changed, so re-use the combined program.
 108        */
 109       stfp = st->pixel_xfer.combined_prog;
 110    }
 111    else {
 112       /* Concatenate the pixel transfer program with the current user-
 113        * defined program.
 114        */
 115       if (is_passthrough_program(&st->fp->Base)) {
 116          stfp = (struct st_fragment_program *)
 117             _mesa_clone_fragment_program(ctx, &st->pixel_xfer.program->Base);
 118       }
 119       else {
 120 #if 0
 121          printf("Base program:\n");
 122          _mesa_print_program(&st->fp->Base.Base);
 123          printf("DrawPix program:\n");
 124          _mesa_print_program(&st->pixel_xfer.program->Base.Base);
 125 #endif
 126          stfp = (struct st_fragment_program *)
 127             _mesa_combine_programs(ctx,
 128                                    &st->pixel_xfer.program->Base.Base,
 129                                    &st->fp->Base.Base);
 130       }
 131
 132 #if 0
 133       {
 134          struct gl_program *p = &stfp->Base.Base;
 135          printf("Combined DrawPixels program:\n");
 136          _mesa_print_program(p);
 137          printf("InputsRead: 0x%x\n", p->InputsRead);
 138          printf("OutputsWritten: 0x%x\n", p->OutputsWritten);
 139          _mesa_print_parameter_list(p->Parameters);
 140       }
 141 #endif
 142
 143       /* translate to TGSI tokens */
 144       st_translate_fragment_program(st, stfp);
 145
 146       /* save new program, update serial numbers */
 147       st->pixel_xfer.xfer_prog_sn = st->pixel_xfer.program->serialNo;
 148       st->pixel_xfer.user_prog_sn = st->fp->serialNo;
 149       st->pixel_xfer.combined_prog_sn = stfp->serialNo;
 150       /* can't reference new program directly, already have a reference on it */
 151       st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);
 152       st->pixel_xfer.combined_prog = stfp;
 153    }
 154
 155    /* Ideally we'd have updated the pipe constants during the normal
 156     * st/atom mechanism.  But we can't since this is specific to glDrawPixels.
 157     */
 158    st_upload_constants(st, stfp->Base.Base.Parameters, PIPE_SHADER_FRAGMENT);
 159
 160    return stfp->driver_shader;
 161 }
 162
 163
 164 /**
 165  * Create fragment shader that does a TEX() instruction to get a Z
 166  * value, then writes to FRAG_RESULT_DEPTH.
 167  * Pass fragment color through as-is.
 168  * \return pointer to the Gallium driver fragment shader
 169  */
 170 static void *
 171 make_fragment_shader_z(struct st_context *st)
 172 {
 173    GLcontext *ctx = st->ctx;
 174    struct gl_program *p;
 175    GLuint ic = 0;
 176
 177    if (st->drawpix.z_shader) {
 178       return st->drawpix.z_shader->driver_shader;
 179    }
 180
 181    /*
 182     * Create shader now
 183     */
 184    p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
 185    if (!p)
 186       return NULL;
 187
 188    p->NumInstructions = 3;
 189
 190    p->Instructions = _mesa_alloc_instructions(p->NumInstructions);
 191    if (!p->Instructions) {
 192       ctx->Driver.DeleteProgram(ctx, p);
 193       return NULL;
 194    }
 195    _mesa_init_instructions(p->Instructions, p->NumInstructions);
 196
 197    /* TEX result.depth, fragment.texcoord[0], texture[0], 2D; */
 198    p->Instructions[ic].Opcode = OPCODE_TEX;
 199    p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
 200    p->Instructions[ic].DstReg.Index = FRAG_RESULT_DEPTH;
 201    p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Z;
 202    p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
 203    p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
 204    p->Instructions[ic].TexSrcUnit = 0;
 205    p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
 206    ic++;
 207
 208    /* MOV result.color, fragment.color */
 209    p->Instructions[ic].Opcode = OPCODE_MOV;
 210    p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
 211    p->Instructions[ic].DstReg.Index = FRAG_RESULT_COLOR;
 212    p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
 213    p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_COL0;
 214    ic++;
 215
 216    /* END; */
 217    p->Instructions[ic++].Opcode = OPCODE_END;
 218
 219    assert(ic == p->NumInstructions);
 220
 221    p->InputsRead = FRAG_BIT_TEX0 | FRAG_BIT_COL0;
 222    p->OutputsWritten = (1 << FRAG_RESULT_COLOR) | (1 << FRAG_RESULT_DEPTH);
 223    p->SamplersUsed = 0x1;  /* sampler 0 (bit 0) is used */
 224
 225    st->drawpix.z_shader = (struct st_fragment_program *) p;
 226    st_translate_fragment_program(st, st->drawpix.z_shader);
 227
 228    return st->drawpix.z_shader->driver_shader;
 229 }
 230
 231
 232
 233 /**
 234  * Create a simple vertex shader that just passes through the
 235  * vertex position and texcoord (and optionally, color).
 236  */
 237 static void *
 238 make_passthrough_vertex_shader(struct st_context *st,
 239                                GLboolean passColor)
 240 {
 241    if (!st->drawpix.vert_shaders[passColor]) {
 242       struct ureg_program *ureg =
 243          ureg_create( TGSI_PROCESSOR_VERTEX );
 244
 245       if (ureg == NULL)
 246          return NULL;
 247
 248       /* MOV result.pos, vertex.pos; */
 249       ureg_MOV(ureg,
 250                ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),
 251                ureg_DECL_vs_input( ureg, 0 ));
 252
 253       /* MOV result.texcoord0, vertex.texcoord0; */
 254       ureg_MOV(ureg,
 255                ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),
 256                ureg_DECL_vs_input( ureg, 1 ));
 257
 258       if (passColor) {
 259          /* MOV result.color0, vertex.color0; */
 260          ureg_MOV(ureg,
 261                   ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),
 262                   ureg_DECL_vs_input( ureg, 2 ));
 263       }
 264
 265       ureg_END( ureg );
 266
 267       st->drawpix.vert_shaders[passColor] =
 268          ureg_create_shader_and_destroy( ureg, st->pipe );
 269    }
 270
 271    return st->drawpix.vert_shaders[passColor];
 272 }
 273
 274
 275 /**
 276  * Return a texture internalFormat for drawing/copying an image
 277  * of the given type.
 278  */
 279 static GLenum
 280 base_format(GLenum format)
 281 {
 282    switch (format) {
 283    case GL_DEPTH_COMPONENT:
 284       return GL_DEPTH_COMPONENT;
 285    case GL_DEPTH_STENCIL:
 286       return GL_DEPTH_STENCIL;
 287    case GL_STENCIL_INDEX:
 288       return GL_STENCIL_INDEX;
 289    default:
 290       return GL_RGBA;
 291    }
 292 }
 293
 294
 295 /**
 296  * Make texture containing an image for glDrawPixels image.
 297  * If 'pixels' is NULL, leave the texture image data undefined.
 298  */
 299 static struct pipe_texture *
 300 make_texture(struct st_context *st,
 301              GLsizei width, GLsizei height, GLenum format, GLenum type,
 302              const struct gl_pixelstore_attrib *unpack,
 303              const GLvoid *pixels)
 304 {
 305    GLcontext *ctx = st->ctx;
 306    struct pipe_context *pipe = st->pipe;
 307    struct pipe_screen *screen = pipe->screen;
 308    gl_format mformat;
 309    struct pipe_texture *pt;
 310    enum pipe_format pipeFormat;
 311    GLuint cpp;
 312    GLenum baseFormat;
 313    int ptw, pth;
 314
 315    baseFormat = base_format(format);
 316
 317    mformat = st_ChooseTextureFormat(ctx, baseFormat, format, type);
 318    assert(mformat);
 319
 320    pipeFormat = st_mesa_format_to_pipe_format(mformat);
 321    assert(pipeFormat);
 322    cpp = st_sizeof_format(pipeFormat);
 323
 324    pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
 325    if (!pixels)
 326       return NULL;
 327
 328    /* Need to use POT texture? */
 329    ptw = width;
 330    pth = height;
 331    if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
 332       int l2pt, maxSize;
 333
 334       l2pt = util_logbase2(width);
 335       if (1<<l2pt != width) {
 336          ptw = 1<<(l2pt+1);
 337       }
 338       l2pt = util_logbase2(height);
 339       if (1<<l2pt != height) {
 340          pth = 1<<(l2pt+1);
 341       }
 342
 343       /* Check against maximum texture size */
 344       maxSize = 1 << (pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
 345       assert(ptw <= maxSize);
 346       assert(pth <= maxSize);
 347    }
 348
 349    pt = st_texture_create(st, PIPE_TEXTURE_2D, pipeFormat, 0, ptw, pth, 1,
 350                           PIPE_TEXTURE_USAGE_SAMPLER);
 351    if (!pt) {
 352       _mesa_unmap_pbo_source(ctx, unpack);
 353       return NULL;
 354    }
 355
 356    {
 357       struct pipe_transfer *transfer;
 358       static const GLuint dstImageOffsets = 0;
 359       GLboolean success;
 360       GLubyte *dest;
 361       const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;
 362
 363       /* we'll do pixel transfer in a fragment shader */
 364       ctx->_ImageTransferState = 0x0;
 365
 366       transfer = st_no_flush_get_tex_transfer(st, pt, 0, 0, 0,
 367                                               PIPE_TRANSFER_WRITE, 0, 0,
 368                                               width, height);
 369
 370       /* map texture transfer */
 371       dest = screen->transfer_map(screen, transfer);
 372
 373
 374       /* Put image into texture transfer.
 375        * Note that the image is actually going to be upside down in
 376        * the texture.  We deal with that with texcoords.
 377        */
 378       success = _mesa_texstore(ctx, 2,           /* dims */
 379                                baseFormat,       /* baseInternalFormat */
 380                                mformat,          /* gl_format */
 381                                dest,             /* dest */
 382                                0, 0, 0,          /* dstX/Y/Zoffset */
 383                                transfer->stride, /* dstRowStride, bytes */
 384                                &dstImageOffsets, /* dstImageOffsets */
 385                                width, height, 1, /* size */
 386                                format, type,     /* src format/type */
 387                                pixels,           /* data source */
 388                                unpack);
 389
 390       /* unmap */
 391       screen->transfer_unmap(screen, transfer);
 392       screen->tex_transfer_destroy(transfer);
 393
 394       assert(success);
 395
 396       /* restore */
 397       ctx->_ImageTransferState = imageTransferStateSave;
 398    }
 399
 400    _mesa_unmap_pbo_source(ctx, unpack);
 401
 402    return pt;
 403 }
 404
 405
 406 /**
 407  * Draw quad with texcoords and optional color.
 408  * Coords are window coords with y=0=bottom.
 409  * \param color  may be null
 410  * \param invertTex  if true, flip texcoords vertically
 411  */
 412 static void
 413 draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
 414           GLfloat x1, GLfloat y1, const GLfloat *color,
 415           GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)
 416 {
 417    struct st_context *st = st_context(ctx);
 418    struct pipe_context *pipe = st->pipe;
 419    GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */
 420
 421    /* setup vertex data */
 422    {
 423       const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
 424       const GLfloat fb_width = (GLfloat) fb->Width;
 425       const GLfloat fb_height = (GLfloat) fb->Height;
 426       const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;
 427       const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;
 428       const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;
 429       const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;
 430       const GLfloat sLeft = 0.0f, sRight = maxXcoord;
 431       const GLfloat tTop = invertTex ? maxYcoord : 0.0f;
 432       const GLfloat tBot = invertTex ? 0.0f : maxYcoord;
 433       GLuint tex, i;
 434
 435       /* upper-left */
 436       verts[0][0][0] = clip_x0;    /* v[0].attr[0].x */
 437       verts[0][0][1] = clip_y0;    /* v[0].attr[0].y */
 438
 439       /* upper-right */
 440       verts[1][0][0] = clip_x1;
 441       verts[1][0][1] = clip_y0;
 442
 443       /* lower-right */
 444       verts[2][0][0] = clip_x1;
 445       verts[2][0][1] = clip_y1;
 446
 447       /* lower-left */
 448       verts[3][0][0] = clip_x0;
 449       verts[3][0][1] = clip_y1;
 450
 451       tex = color ? 2 : 1;
 452       verts[0][tex][0] = sLeft; /* v[0].attr[tex].s */
 453       verts[0][tex][1] = tTop;  /* v[0].attr[tex].t */
 454       verts[1][tex][0] = sRight;
 455       verts[1][tex][1] = tTop;
 456       verts[2][tex][0] = sRight;
 457       verts[2][tex][1] = tBot;
 458       verts[3][tex][0] = sLeft;
 459       verts[3][tex][1] = tBot;
 460
 461       /* same for all verts: */
 462       if (color) {
 463          for (i = 0; i < 4; i++) {
 464             verts[i][0][2] = z;   /*Z*/
 465             verts[i][0][3] = 1.0f; /*W*/
 466             verts[i][1][0] = color[0];
 467             verts[i][1][1] = color[1];
 468             verts[i][1][2] = color[2];
 469             verts[i][1][3] = color[3];
 470             verts[i][2][2] = 0.0f; /*R*/
 471             verts[i][2][3] = 1.0f; /*Q*/
 472          }
 473       }
 474       else {
 475          for (i = 0; i < 4; i++) {
 476             verts[i][0][2] = z;   /*Z*/
 477             verts[i][0][3] = 1.0f; /*W*/
 478             verts[i][1][2] = 0.0f; /*R*/
 479             verts[i][1][3] = 1.0f; /*Q*/
 480          }
 481       }
 482    }
 483
 484    {
 485       struct pipe_buffer *buf;
 486
 487       /* allocate/load buffer object with vertex data */
 488       buf = pipe_buffer_create(pipe->screen, 32, PIPE_BUFFER_USAGE_VERTEX,
 489                                sizeof(verts));
 490       st_no_flush_pipe_buffer_write(st, buf, 0, sizeof(verts), verts);
 491
 492       util_draw_vertex_buffer(pipe, buf, 0,
 493                               PIPE_PRIM_QUADS,
 494                               4,  /* verts */
 495                               3); /* attribs/vert */
 496       pipe_buffer_reference(&buf, NULL);
 497    }
 498 }
 499
 500
 501
 502 static void
 503 draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
 504                    GLsizei width, GLsizei height,
 505                    GLfloat zoomX, GLfloat zoomY,
 506                    struct pipe_texture *pt,
 507                    void *driver_vp,
 508                    void *driver_fp,
 509                    const GLfloat *color,
 510                    GLboolean invertTex)
 511 {
 512    struct st_context *st = st_context(ctx);
 513    struct pipe_context *pipe = st->pipe;
 514    struct cso_context *cso = st->cso_context;
 515    GLfloat x0, y0, x1, y1;
 516    GLsizei maxSize;
 517
 518    /* limit checks */
 519    /* XXX if DrawPixels image is larger than max texture size, break
 520     * it up into chunks.
 521     */
 522    maxSize = 1 << (pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
 523    assert(width <= maxSize);
 524    assert(height <= maxSize);
 525
 526    cso_save_rasterizer(cso);
 527    cso_save_viewport(cso);
 528    cso_save_samplers(cso);
 529    cso_save_sampler_textures(cso);
 530    cso_save_fragment_shader(cso);
 531    cso_save_vertex_shader(cso);
 532
 533    /* rasterizer state: just scissor */
 534    {
 535       struct pipe_rasterizer_state rasterizer;
 536       memset(&rasterizer, 0, sizeof(rasterizer));
 537       rasterizer.gl_rasterization_rules = 1;
 538       rasterizer.scissor = ctx->Scissor.Enabled;
 539       cso_set_rasterizer(cso, &rasterizer);
 540    }
 541
 542    /* fragment shader state: TEX lookup program */
 543    cso_set_fragment_shader_handle(cso, driver_fp);
 544
 545    /* vertex shader state: position + texcoord pass-through */
 546    cso_set_vertex_shader_handle(cso, driver_vp);
 547
 548
 549    /* texture sampling state: */
 550    {
 551       struct pipe_sampler_state sampler;
 552       memset(&sampler, 0, sizeof(sampler));
 553       sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;
 554       sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;
 555       sampler.wrap_r = PIPE_TEX_WRAP_CLAMP;
 556       sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 557       sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 558       sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 559       sampler.normalized_coords = 1;
 560
 561       cso_single_sampler(cso, 0, &sampler);
 562       if (st->pixel_xfer.pixelmap_enabled) {
 563          cso_single_sampler(cso, 1, &sampler);
 564       }
 565       cso_single_sampler_done(cso);
 566    }
 567
 568    /* viewport state: viewport matching window dims */
 569    {
 570       const float w = (float) ctx->DrawBuffer->Width;
 571       const float h = (float) ctx->DrawBuffer->Height;
 572       struct pipe_viewport_state vp;
 573       vp.scale[0] =  0.5f * w;
 574       vp.scale[1] = -0.5f * h;
 575       vp.scale[2] = 1.0f;
 576       vp.scale[3] = 1.0f;
 577       vp.translate[0] = 0.5f * w;
 578       vp.translate[1] = 0.5f * h;
 579       vp.translate[2] = 0.0f;
 580       vp.translate[3] = 0.0f;
 581       cso_set_viewport(cso, &vp);
 582    }
 583
 584    /* texture state: */
 585    if (st->pixel_xfer.pixelmap_enabled) {
 586       struct pipe_texture *textures[2];
 587       textures[0] = pt;
 588       textures[1] = st->pixel_xfer.pixelmap_texture;
 589       pipe->set_fragment_sampler_textures(pipe, 2, textures);
 590    }
 591    else {
 592       pipe->set_fragment_sampler_textures(pipe, 1, &pt);
 593    }
 594
 595    /* Compute window coords (y=0=bottom) with pixel zoom.
 596     * Recall that these coords are transformed by the current
 597     * vertex shader and viewport transformation.
 598     */
 599    x0 = (GLfloat) x;
 600    x1 = x + width * ctx->Pixel.ZoomX;
 601    y0 = (GLfloat) y;
 602    y1 = y + height * ctx->Pixel.ZoomY;
 603
 604    draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,
 605              (GLfloat) width / pt->width0,
 606              (GLfloat) height / pt->height0);
 607
 608    /* restore state */
 609    cso_restore_rasterizer(cso);
 610    cso_restore_viewport(cso);
 611    cso_restore_samplers(cso);
 612    cso_restore_sampler_textures(cso);
 613    cso_restore_fragment_shader(cso);
 614    cso_restore_vertex_shader(cso);
 615 }
 616
 617
 618 static void
 619 draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
 620                     GLsizei width, GLsizei height, GLenum format, GLenum type,
 621                     const struct gl_pixelstore_attrib *unpack,
 622                     const GLvoid *pixels)
 623 {
 624    struct st_context *st = st_context(ctx);
 625    struct pipe_context *pipe = st->pipe;
 626    struct pipe_screen *screen = pipe->screen;
 627    struct st_renderbuffer *strb;
 628    enum pipe_transfer_usage usage;
 629    struct pipe_transfer *pt;
 630    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
 631    GLint skipPixels;
 632    ubyte *stmap;
 633    struct gl_pixelstore_attrib clippedUnpack = *unpack;
 634
 635    if (!zoom) {
 636       if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
 637                                  &clippedUnpack)) {
 638          /* totally clipped */
 639          return;
 640       }
 641    }
 642
 643    strb = st_renderbuffer(ctx->DrawBuffer->
 644                           Attachment[BUFFER_STENCIL].Renderbuffer);
 645
 646    if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
 647       y = ctx->DrawBuffer->Height - y - height;
 648    }
 649
 650    if(format != GL_DEPTH_STENCIL &&
 651       util_format_get_component_bits(strb->format, UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
 652       usage = PIPE_TRANSFER_READ_WRITE;
 653    else
 654       usage = PIPE_TRANSFER_WRITE;
 655
 656    pt = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture, 0, 0, 0,
 657                                        usage, x, y,
 658                                        width, height);
 659
 660    stmap = screen->transfer_map(screen, pt);
 661
 662    pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);
 663    assert(pixels);
 664
 665    /* if width > MAX_WIDTH, have to process image in chunks */
 666    skipPixels = 0;
 667    while (skipPixels < width) {
 668       const GLint spanX = skipPixels;
 669       const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
 670       GLint row;
 671       for (row = 0; row < height; row++) {
 672          GLubyte sValues[MAX_WIDTH];
 673          GLuint zValues[MAX_WIDTH];
 674          GLenum destType = GL_UNSIGNED_BYTE;
 675          const GLvoid *source = _mesa_image_address2d(&clippedUnpack, pixels,
 676                                                       width, height,
 677                                                       format, type,
 678                                                       row, skipPixels);
 679          _mesa_unpack_stencil_span(ctx, spanWidth, destType, sValues,
 680                                    type, source, &clippedUnpack,
 681                                    ctx->_ImageTransferState);
 682
 683          if (format == GL_DEPTH_STENCIL) {
 684             _mesa_unpack_depth_span(ctx, spanWidth, GL_UNSIGNED_INT, zValues,
 685                                     (1 << 24) - 1, type, source,
 686                                     &clippedUnpack);
 687          }
 688
 689          if (zoom) {
 690             _mesa_problem(ctx, "Gallium glDrawPixels(GL_STENCIL) with "
 691                           "zoom not complete");
 692          }
 693
 694          {
 695             GLint spanY;
 696
 697             if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
 698                spanY = height - row - 1;
 699             }
 700             else {
 701                spanY = row;
 702             }
 703
 704             /* now pack the stencil (and Z) values in the dest format */
 705             switch (pt->texture->format) {
 706             case PIPE_FORMAT_S8_UNORM:
 707                {
 708                   ubyte *dest = stmap + spanY * pt->stride + spanX;
 709                   assert(usage == PIPE_TRANSFER_WRITE);
 710                   memcpy(dest, sValues, spanWidth);
 711                }
 712                break;
 713             case PIPE_FORMAT_S8Z24_UNORM:
 714                if (format == GL_DEPTH_STENCIL) {
 715                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
 716                   GLint k;
 717                   assert(usage == PIPE_TRANSFER_WRITE);
 718                   for (k = 0; k < spanWidth; k++) {
 719                      dest[k] = zValues[k] | (sValues[k] << 24);
 720                   }
 721                }
 722                else {
 723                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
 724                   GLint k;
 725                   assert(usage == PIPE_TRANSFER_READ_WRITE);
 726                   for (k = 0; k < spanWidth; k++) {
 727                      dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);
 728                   }
 729                }
 730                break;
 731             case PIPE_FORMAT_Z24S8_UNORM:
 732                if (format == GL_DEPTH_STENCIL) {
 733                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
 734                   GLint k;
 735                   assert(usage == PIPE_TRANSFER_WRITE);
 736                   for (k = 0; k < spanWidth; k++) {
 737                      dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);
 738                   }
 739                }
 740                else {
 741                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
 742                   GLint k;
 743                   assert(usage == PIPE_TRANSFER_READ_WRITE);
 744                   for (k = 0; k < spanWidth; k++) {
 745                      dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);
 746                   }
 747                }
 748                break;
 749             default:
 750                assert(0);
 751             }
 752          }
 753       }
 754       skipPixels += spanWidth;
 755    }
 756
 757    _mesa_unmap_pbo_source(ctx, &clippedUnpack);
 758
 759    /* unmap the stencil buffer */
 760    screen->transfer_unmap(screen, pt);
 761    screen->tex_transfer_destroy(pt);
 762 }
 763
 764
 765 /**
 766  * Called via ctx->Driver.DrawPixels()
 767  */
 768 static void
 769 st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 770               GLenum format, GLenum type,
 771               const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels)
 772 {
 773    void *driver_vp, *driver_fp;
 774    struct st_context *st = st_context(ctx);
 775    const GLfloat *color;
 776
 777    if (format == GL_STENCIL_INDEX ||
 778        format == GL_DEPTH_STENCIL) {
 779       draw_stencil_pixels(ctx, x, y, width, height, format, type,
 780                           unpack, pixels);
 781       return;
 782    }
 783
 784    /* Mesa state should be up to date by now */
 785    assert(ctx->NewState == 0x0);
 786
 787    st_validate_state(st);
 788
 789    if (format == GL_DEPTH_COMPONENT) {
 790       driver_fp = make_fragment_shader_z(st);
 791       driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
 792       color = ctx->Current.RasterColor;
 793    }
 794    else {
 795       driver_fp = combined_drawpix_fragment_program(ctx);
 796       driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
 797       color = NULL;
 798    }
 799
 800    /* draw with textured quad */
 801    {
 802       struct pipe_texture *pt
 803          = make_texture(st, width, height, format, type, unpack, pixels);
 804       if (pt) {
 805          draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
 806                             width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
 807                             pt,
 808                             driver_vp,
 809                             driver_fp,
 810                             color, GL_FALSE);
 811          pipe_texture_reference(&pt, NULL);
 812       }
 813    }
 814 }
 815
 816
 817
 818 static void
 819 copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
 820                     GLsizei width, GLsizei height,
 821                     GLint dstx, GLint dsty)
 822 {
 823    struct st_renderbuffer *rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);
 824    struct pipe_screen *screen = ctx->st->pipe->screen;
 825    enum pipe_transfer_usage usage;
 826    struct pipe_transfer *ptDraw;
 827    ubyte *drawMap;
 828    ubyte *buffer;
 829    int i;
 830
 831    buffer = malloc(width * height * sizeof(ubyte));
 832    if (!buffer) {
 833       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels(stencil)");
 834       return;
 835    }
 836
 837    /* this will do stencil pixel transfer ops */
 838    st_read_stencil_pixels(ctx, srcx, srcy, width, height,
 839                           GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
 840                           &ctx->DefaultPacking, buffer);
 841
 842    if(util_format_get_component_bits(rbDraw->format, UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
 843       usage = PIPE_TRANSFER_READ_WRITE;
 844    else
 845       usage = PIPE_TRANSFER_WRITE;
 846
 847    if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
 848       dsty = rbDraw->Base.Height - dsty - height;
 849    }
 850
 851    ptDraw = st_cond_flush_get_tex_transfer(st_context(ctx),
 852                                            rbDraw->texture, 0, 0, 0,
 853                                            usage, dstx, dsty,
 854                                            width, height);
 855
 856    assert(util_format_get_blockwidth(ptDraw->texture->format) == 1);
 857    assert(util_format_get_blockheight(ptDraw->texture->format) == 1);
 858
 859    /* map the stencil buffer */
 860    drawMap = screen->transfer_map(screen, ptDraw);
 861
 862    /* draw */
 863    /* XXX PixelZoom not handled yet */
 864    for (i = 0; i < height; i++) {
 865       ubyte *dst;
 866       const ubyte *src;
 867       int y;
 868
 869       y = i;
 870
 871       if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
 872          y = height - y - 1;
 873       }
 874
 875       dst = drawMap + y * ptDraw->stride;
 876       src = buffer + i * width;
 877
 878       switch (ptDraw->texture->format) {
 879       case PIPE_FORMAT_S8Z24_UNORM:
 880          {
 881             uint *dst4 = (uint *) dst;
 882             int j;
 883             assert(usage == PIPE_TRANSFER_READ_WRITE);
 884             for (j = 0; j < width; j++) {
 885                *dst4 = (*dst4 & 0xffffff) | (src[j] << 24);
 886                dst4++;
 887             }
 888          }
 889          break;
 890       case PIPE_FORMAT_Z24S8_UNORM:
 891          {
 892             uint *dst4 = (uint *) dst;
 893             int j;
 894             assert(usage == PIPE_TRANSFER_READ_WRITE);
 895             for (j = 0; j < width; j++) {
 896                *dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);
 897                dst4++;
 898             }
 899          }
 900          break;
 901       case PIPE_FORMAT_S8_UNORM:
 902          assert(usage == PIPE_TRANSFER_WRITE);
 903          memcpy(dst, src, width);
 904          break;
 905       default:
 906          assert(0);
 907       }
 908    }
 909
 910    free(buffer);
 911
 912    /* unmap the stencil buffer */
 913    screen->transfer_unmap(screen, ptDraw);
 914    screen->tex_transfer_destroy(ptDraw);
 915 }
 916
 917
 918 static void
 919 st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
 920               GLsizei width, GLsizei height,
 921               GLint dstx, GLint dsty, GLenum type)
 922 {
 923    struct st_context *st = st_context(ctx);
 924    struct pipe_context *pipe = st->pipe;
 925    struct pipe_screen *screen = pipe->screen;
 926    struct st_renderbuffer *rbRead;
 927    void *driver_vp, *driver_fp;
 928    struct pipe_texture *pt;
 929    GLfloat *color;
 930    enum pipe_format srcFormat, texFormat;
 931    int ptw, pth;
 932
 933    pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
 934
 935    st_validate_state(st);
 936
 937    if (srcx < 0) {
 938       width -= -srcx;
 939       dstx += -srcx;
 940       srcx = 0;
 941    }
 942
 943    if (srcy < 0) {
 944       height -= -srcy;
 945       dsty += -srcy;
 946       srcy = 0;
 947    }
 948
 949    if (dstx < 0) {
 950       width -= -dstx;
 951       srcx += -dstx;
 952       dstx = 0;
 953    }
 954
 955    if (dsty < 0) {
 956       height -= -dsty;
 957       srcy += -dsty;
 958       dsty = 0;
 959    }
 960
 961    if (width < 0 || height < 0)
 962       return;
 963
 964
 965    if (type == GL_STENCIL) {
 966       /* can't use texturing to do stencil */
 967       copy_stencil_pixels(ctx, srcx, srcy, width, height, dstx, dsty);
 968       return;
 969    }
 970
 971    if (type == GL_COLOR) {
 972       rbRead = st_get_color_read_renderbuffer(ctx);
 973       color = NULL;
 974       driver_fp = combined_drawpix_fragment_program(ctx);
 975       driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
 976    }
 977    else {
 978       assert(type == GL_DEPTH);
 979       rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
 980       color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
 981       driver_fp = make_fragment_shader_z(st);
 982       driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
 983    }
 984
 985    srcFormat = rbRead->texture->format;
 986
 987    if (screen->is_format_supported(screen, srcFormat, PIPE_TEXTURE_2D,
 988                                    PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
 989       texFormat = srcFormat;
 990    }
 991    else {
 992       /* srcFormat can't be used as a texture format */
 993       if (type == GL_DEPTH) {
 994          texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,
 995                                       PIPE_TEXTURE_2D,
 996                                       PIPE_TEXTURE_USAGE_DEPTH_STENCIL);
 997          assert(texFormat != PIPE_FORMAT_NONE); /* XXX no depth texture formats??? */
 998       }
 999       else {
1000          /* default color format */
1001          texFormat = st_choose_format(screen, GL_RGBA, PIPE_TEXTURE_2D,
1002                                       PIPE_TEXTURE_USAGE_SAMPLER);
1003          assert(texFormat != PIPE_FORMAT_NONE);
1004       }
1005    }
1006
1007    if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
1008       srcy = ctx->DrawBuffer->Height - srcy - height;
1009
1010       if (srcy < 0) {
1011          height -= -srcy;
1012          srcy = 0;
1013       }
1014
1015       if (height < 0)
1016          return;
1017    }
1018
1019    /* Need to use POT texture? */
1020    ptw = width;
1021    pth = height;
1022    if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
1023       int l2pt, maxSize;
1024
1025       l2pt = util_logbase2(width);
1026       if (1<<l2pt != width) {
1027          ptw = 1<<(l2pt+1);
1028       }
1029       l2pt = util_logbase2(height);
1030       if (1<<l2pt != height) {
1031          pth = 1<<(l2pt+1);
1032       }
1033
1034       /* Check against maximum texture size */
1035       maxSize = 1 << (pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
1036       assert(ptw <= maxSize);
1037       assert(pth <= maxSize);
1038    }
1039
1040    pt = st_texture_create(st, PIPE_TEXTURE_2D, texFormat, 0,
1041                           ptw, pth, 1,
1042                           PIPE_TEXTURE_USAGE_SAMPLER);
1043    if (!pt)
1044       return;
1045
1046
1047    if (srcFormat == texFormat) {
1048       /* copy source framebuffer surface into mipmap/texture */
1049       struct pipe_surface *psRead = screen->get_tex_surface(screen,
1050                                        rbRead->texture, 0, 0, 0,
1051                                        PIPE_BUFFER_USAGE_GPU_READ);
1052       struct pipe_surface *psTex = screen->get_tex_surface(screen, pt, 0, 0, 0,
1053                                       PIPE_BUFFER_USAGE_GPU_WRITE );
1054       if (pipe->surface_copy) {
1055          pipe->surface_copy(pipe,
1056                             psTex, /* dest */
1057                             0, 0, /* destx/y */
1058                             psRead,
1059                             srcx, srcy, width, height);
1060       } else {
1061          util_surface_copy(pipe, FALSE,
1062                            psTex,
1063                            0, 0,
1064                            psRead,
1065                            srcx, srcy, width, height);
1066       }
1067       pipe_surface_reference(&psRead, NULL);
1068       pipe_surface_reference(&psTex, NULL);
1069    }
1070    else {
1071       /* CPU-based fallback/conversion */
1072       struct pipe_transfer *ptRead =
1073          st_cond_flush_get_tex_transfer(st, rbRead->texture, 0, 0, 0,
1074                                         PIPE_TRANSFER_READ, srcx, srcy, width,
1075                                         height);
1076       struct pipe_transfer *ptTex;
1077       enum pipe_transfer_usage transfer_usage;
1078
1079       if (ST_DEBUG & DEBUG_FALLBACK)
1080          debug_printf("%s: fallback processing\n", __FUNCTION__);
1081
1082       if (type == GL_DEPTH && util_format_is_depth_and_stencil(pt->format))
1083          transfer_usage = PIPE_TRANSFER_READ_WRITE;
1084       else
1085          transfer_usage = PIPE_TRANSFER_WRITE;
1086
1087       ptTex = st_cond_flush_get_tex_transfer(st, pt, 0, 0, 0, transfer_usage,
1088                                              0, 0, width, height);
1089
1090       if (type == GL_COLOR) {
1091          /* alternate path using get/put_tile() */
1092          GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
1093
1094          pipe_get_tile_rgba(ptRead, 0, 0, width, height, buf);
1095          pipe_put_tile_rgba(ptTex, 0, 0, width, height, buf);
1096
1097          free(buf);
1098       }
1099       else {
1100          /* GL_DEPTH */
1101          GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));
1102          pipe_get_tile_z(ptRead, 0, 0, width, height, buf);
1103          pipe_put_tile_z(ptTex, 0, 0, width, height, buf);
1104          free(buf);
1105       }
1106
1107       screen->tex_transfer_destroy(ptRead);
1108       screen->tex_transfer_destroy(ptTex);
1109    }
1110
1111    /* draw textured quad */
1112    draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],
1113                       width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
1114                       pt,
1115                       driver_vp,
1116                       driver_fp,
1117                       color, GL_TRUE);
1118
1119    pipe_texture_reference(&pt, NULL);
1120 }
1121
1122
1123
1124 void st_init_drawpixels_functions(struct dd_function_table *functions)
1125 {
1126    functions->DrawPixels = st_DrawPixels;
1127    functions->CopyPixels = st_CopyPixels;
1128 }
1129
1130
1131 void
1132 st_destroy_drawpix(struct st_context *st)
1133 {
1134    st_reference_fragprog(st, &st->drawpix.z_shader, NULL);
1135    st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);
1136    if (st->drawpix.vert_shaders[0])
1137       free(st->drawpix.vert_shaders[0]);
1138    if (st->drawpix.vert_shaders[1])
1139       free(st->drawpix.vert_shaders[1]);
1140 }