src/mesa/drivers/dri/intel/intel_pixel_draw.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 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 portionsalloc
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "glheader.h"
  29 #include "enums.h"
  30 #include "image.h"
  31 #include "mtypes.h"
  32 #include "macros.h"
  33 #include "bufferobj.h"
  34 #include "swrast/swrast.h"
  35
  36 #include "intel_screen.h"
  37 #include "intel_context.h"
  38 #include "intel_ioctl.h"
  39 #include "intel_batchbuffer.h"
  40 #include "intel_blit.h"
  41 #include "intel_buffers.h"
  42 #include "intel_regions.h"
  43 #include "intel_pixel.h"
  44 #include "intel_buffer_objects.h"
  45 #include "intel_tris.h"
  46
  47
  48
  49 static GLboolean
  50 do_texture_drawpixels(GLcontext * ctx,
  51                       GLint x, GLint y,
  52                       GLsizei width, GLsizei height,
  53                       GLenum format, GLenum type,
  54                       const struct gl_pixelstore_attrib *unpack,
  55                       const GLvoid * pixels)
  56 {
  57    struct intel_context *intel = intel_context(ctx);
  58    struct intel_region *dst = intel_drawbuf_region(intel);
  59    struct intel_buffer_object *src = intel_buffer_object(unpack->BufferObj);
  60    GLuint rowLength = unpack->RowLength ? unpack->RowLength : width;
  61    GLuint src_offset;
  62
  63    if (INTEL_DEBUG & DEBUG_PIXEL)
  64       fprintf(stderr, "%s\n", __FUNCTION__);
  65
  66    intelFlush(&intel->ctx);
  67
  68    if (!dst)
  69       return GL_FALSE;
  70
  71    intel->vtbl.render_start(intel);
  72    intel->vtbl.emit_state(intel);
  73
  74    if (src) {
  75       if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
  76                                      format, type, pixels)) {
  77          _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels");
  78          return GL_TRUE;
  79       }
  80    }
  81    else {
  82       /* PBO only for now:
  83        */
  84 /*       _mesa_printf("%s - not PBO\n", __FUNCTION__); */
  85       return GL_FALSE;
  86    }
  87
  88    /* There are a couple of things we can't do yet, one of which is
  89     * set the correct state for pixel operations when GL texturing is
  90     * enabled.  That's a pretty rare state and probably not worth the
  91     * effort.  A completely device-independent version of this may do
  92     * more.
  93     *
  94     * Similarly, we make no attempt to merge metaops processing with
  95     * an enabled fragment program, though it would certainly be
  96     * possible.
  97     */
  98    if (!intel_check_meta_tex_fragment_ops(ctx)) {
  99       if (INTEL_DEBUG & DEBUG_PIXEL)
 100          _mesa_printf("%s - bad GL fragment state for metaops texture\n",
 101                       __FUNCTION__);
 102       return GL_FALSE;
 103    }
 104
 105    intel->vtbl.install_meta_state(intel);
 106
 107
 108    /* Is this true?  Also will need to turn depth testing on according
 109     * to state:
 110     */
 111    intel->vtbl.meta_no_stencil_write(intel);
 112    intel->vtbl.meta_no_depth_write(intel);
 113
 114    /* Set the 3d engine to draw into the destination region:
 115     */
 116    intel->vtbl.meta_draw_region(intel, dst, intel->depth_region);
 117
 118    intel->vtbl.meta_import_pixel_state(intel);
 119
 120    src_offset = (GLuint) _mesa_image_address(2, unpack, pixels, width, height,
 121                                              format, type, 0, 0, 0);
 122
 123
 124    /* Setup the pbo up as a rectangular texture, if possible.
 125     *
 126     * TODO: This is almost always possible if the i915 fragment
 127     * program is adjusted to correctly swizzle the sampled colors.
 128     * The major exception is any 24bit texture, like RGB888, for which
 129     * there is no hardware support.
 130     */
 131    if (!intel->vtbl.meta_tex_rect_source(intel, src->buffer, src_offset,
 132                                          rowLength, height, format, type)) {
 133       intel->vtbl.leave_meta_state(intel);
 134       return GL_FALSE;
 135    }
 136
 137    intel->vtbl.meta_texture_blend_replace(intel);
 138
 139
 140    LOCK_HARDWARE(intel);
 141
 142    if (intel->driDrawable->numClipRects) {
 143       __DRIdrawablePrivate *dPriv = intel->driDrawable;
 144       GLint srcx, srcy;
 145       GLint dstx, dsty;
 146
 147       dstx = x;
 148       dsty = dPriv->h - (y + height);
 149
 150       srcx = 0;                 /* skiprows/pixels already done */
 151       srcy = 0;
 152
 153       if (0) {
 154          const GLint orig_x = dstx;
 155          const GLint orig_y = dsty;
 156
 157          if (!_mesa_clip_to_region(0, 0, dst->pitch, dst->height,
 158                                    &dstx, &dsty, &width, &height))
 159             goto out;
 160
 161          srcx += dstx - orig_x;
 162          srcy += dsty - orig_y;
 163       }
 164
 165
 166       if (INTEL_DEBUG & DEBUG_PIXEL)
 167          _mesa_printf("draw %d,%d %dx%d\n", dstx, dsty, width, height);
 168
 169       /* Must use the regular cliprect mechanism in order to get the
 170        * drawing origin set correctly.  Otherwise scissor state is in
 171        * incorrect coordinate space.  Does this even need to hold the
 172        * lock???
 173        */
 174       intel->vtbl.meta_draw_quad(intel,
 175                                  dstx, dstx + width * ctx->Pixel.ZoomX,
 176                                  dPriv->h - (y + height * ctx->Pixel.ZoomY),
 177                                  dPriv->h - (y),
 178                                  -ctx->Current.RasterPos[2] * .5,
 179                                  0x00ff00ff,
 180                                  srcx, srcx + width, srcy + height, srcy);
 181     out:
 182       intel->vtbl.leave_meta_state(intel);
 183       intel_batchbuffer_flush(intel->batch);
 184    }
 185    UNLOCK_HARDWARE(intel);
 186    return GL_TRUE;
 187 }
 188
 189
 190
 191
 192
 193 /* Pros:
 194  *   - no waiting for idle before updating framebuffer.
 195  *
 196  * Cons:
 197  *   - if upload is by memcpy, this may actually be slower than fallback path.
 198  *   - uploads the whole image even if destination is clipped
 199  *
 200  * Need to benchmark.
 201  *
 202  * Given the questions about performance, implement for pbo's only.
 203  * This path is definitely a win if the pbo is already in agp.  If it
 204  * turns out otherwise, we can add the code necessary to upload client
 205  * data to agp space before performing the blit.  (Though it may turn
 206  * out to be better/simpler just to use the texture engine).
 207  */
 208 static GLboolean
 209 do_blit_drawpixels(GLcontext * ctx,
 210                    GLint x, GLint y,
 211                    GLsizei width, GLsizei height,
 212                    GLenum format, GLenum type,
 213                    const struct gl_pixelstore_attrib *unpack,
 214                    const GLvoid * pixels)
 215 {
 216    struct intel_context *intel = intel_context(ctx);
 217    struct intel_region *dest = intel_drawbuf_region(intel);
 218    struct intel_buffer_object *src = intel_buffer_object(unpack->BufferObj);
 219    GLuint src_offset;
 220    GLuint rowLength;
 221    dri_fence *fence = NULL;
 222
 223    if (INTEL_DEBUG & DEBUG_PIXEL)
 224       _mesa_printf("%s\n", __FUNCTION__);
 225
 226
 227    if (!dest) {
 228       if (INTEL_DEBUG & DEBUG_PIXEL)
 229          _mesa_printf("%s - no dest\n", __FUNCTION__);
 230       return GL_FALSE;
 231    }
 232
 233    if (src) {
 234       /* This validation should be done by core mesa:
 235        */
 236       if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
 237                                      format, type, pixels)) {
 238          _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels");
 239          return GL_TRUE;
 240       }
 241    }
 242    else {
 243       /* PBO only for now:
 244        */
 245       if (INTEL_DEBUG & DEBUG_PIXEL)
 246          _mesa_printf("%s - not PBO\n", __FUNCTION__);
 247       return GL_FALSE;
 248    }
 249
 250    if (!intel_check_blit_format(dest, format, type)) {
 251       if (INTEL_DEBUG & DEBUG_PIXEL)
 252          _mesa_printf("%s - bad format for blit\n", __FUNCTION__);
 253       return GL_FALSE;
 254    }
 255
 256    if (!intel_check_blit_fragment_ops(ctx)) {
 257       if (INTEL_DEBUG & DEBUG_PIXEL)
 258          _mesa_printf("%s - bad GL fragment state for blitter\n",
 259                       __FUNCTION__);
 260       return GL_FALSE;
 261    }
 262
 263    if (ctx->Pixel.ZoomX != 1.0F) {
 264       if (INTEL_DEBUG & DEBUG_PIXEL)
 265          _mesa_printf("%s - bad PixelZoomX for blit\n", __FUNCTION__);
 266       return GL_FALSE;
 267    }
 268
 269
 270    if (unpack->RowLength > 0)
 271       rowLength = unpack->RowLength;
 272    else
 273       rowLength = width;
 274
 275    if (ctx->Pixel.ZoomY == -1.0F) {
 276       if (INTEL_DEBUG & DEBUG_PIXEL)
 277          _mesa_printf("%s - bad PixelZoomY for blit\n", __FUNCTION__);
 278       return GL_FALSE;          /* later */
 279       y -= height;
 280    }
 281    else if (ctx->Pixel.ZoomY == 1.0F) {
 282       rowLength = -rowLength;
 283    }
 284    else {
 285       if (INTEL_DEBUG & DEBUG_PIXEL)
 286          _mesa_printf("%s - bad PixelZoomY for blit\n", __FUNCTION__);
 287       return GL_FALSE;
 288    }
 289
 290    src_offset = (GLuint) _mesa_image_address(2, unpack, pixels, width, height,
 291                                              format, type, 0, 0, 0);
 292
 293    intelFlush(&intel->ctx);
 294    LOCK_HARDWARE(intel);
 295
 296    if (intel->driDrawable->numClipRects) {
 297       __DRIdrawablePrivate *dPriv = intel->driDrawable;
 298       int nbox = dPriv->numClipRects;
 299       drm_clip_rect_t *box = dPriv->pClipRects;
 300       drm_clip_rect_t rect;
 301       drm_clip_rect_t dest_rect;
 302       dri_bo *src_buffer = intel_bufferobj_buffer(intel, src, INTEL_READ);
 303       int i;
 304
 305       dest_rect.x1 = dPriv->x + x;
 306       dest_rect.y1 = dPriv->y + dPriv->h - (y + height);
 307       dest_rect.x2 = dest_rect.x1 + width;
 308       dest_rect.y2 = dest_rect.y1 + height;
 309
 310       for (i = 0; i < nbox; i++) {
 311          if (!intel_intersect_cliprects(&rect, &dest_rect, &box[i]))
 312             continue;
 313
 314          intelEmitCopyBlit(intel,
 315                            dest->cpp,
 316                            rowLength, src_buffer, src_offset, GL_FALSE,
 317                            dest->pitch, dest->buffer, 0, dest->tiled,
 318                            rect.x1 - dest_rect.x1,
 319                            rect.y2 - dest_rect.y2,
 320                            rect.x1,
 321                            rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1,
 322                            ctx->Color.ColorLogicOpEnabled ?
 323                            ctx->Color.LogicOp : GL_COPY);
 324       }
 325       intel_batchbuffer_flush(intel->batch);
 326       fence = intel->batch->last_fence;
 327       dri_fence_reference(fence);
 328    }
 329    UNLOCK_HARDWARE(intel);
 330
 331    if (fence) {
 332       dri_fence_wait(fence);
 333       dri_fence_unreference(fence);
 334    }
 335
 336    if (INTEL_DEBUG & DEBUG_PIXEL)
 337       _mesa_printf("%s - DONE\n", __FUNCTION__);
 338
 339    return GL_TRUE;
 340 }
 341
 342
 343
 344 void
 345 intelDrawPixels(GLcontext * ctx,
 346                 GLint x, GLint y,
 347                 GLsizei width, GLsizei height,
 348                 GLenum format,
 349                 GLenum type,
 350                 const struct gl_pixelstore_attrib *unpack,
 351                 const GLvoid * pixels)
 352 {
 353    if (do_blit_drawpixels(ctx, x, y, width, height, format, type,
 354                           unpack, pixels))
 355       return;
 356
 357    if (do_texture_drawpixels(ctx, x, y, width, height, format, type,
 358                              unpack, pixels))
 359       return;
 360
 361
 362    if (INTEL_DEBUG & DEBUG_PIXEL)
 363       _mesa_printf("%s: fallback to swrast\n", __FUNCTION__);
 364
 365    if (ctx->FragmentProgram._Current == ctx->FragmentProgram._TexEnvProgram) {
 366       /*
 367        * We don't want the i915 texenv program to be applied to DrawPixels.
 368        * This is really just a performance optimization (mesa will other-
 369        * wise happily run the fragment program on each pixel in the image).
 370        */
 371       struct gl_fragment_program *fpSave = ctx->FragmentProgram._Current;
 372    /* can't just set current frag prog to 0 here as on buffer resize
 373       we'll get new state checks which will segfault. Remains a hack. */
 374       ctx->FragmentProgram._Current = NULL;
 375       ctx->FragmentProgram._UseTexEnvProgram = GL_FALSE;
 376       ctx->FragmentProgram._Active = GL_FALSE;
 377       _swrast_DrawPixels( ctx, x, y, width, height, format, type,
 378                           unpack, pixels );
 379       ctx->FragmentProgram._Current = fpSave;
 380       ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
 381       ctx->FragmentProgram._Active = GL_TRUE;
 382       _swrast_InvalidateState(ctx, _NEW_PROGRAM);
 383    }
 384    else {
 385       _swrast_DrawPixels( ctx, x, y, width, height, format, type,
 386                           unpack, pixels );
 387    }
 388 }