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

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright 2011 Intel Corporation
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  * Authors:
  28  *     Chad Versace <chad@chad-versace.us>
  29  *
  30  **************************************************************************/
  31
  32 #include <stdbool.h>
  33 #include <stdint.h>
  34 #include "main/glheader.h"
  35 #include "main/macros.h"
  36 #include "main/mtypes.h"
  37 #include "main/colormac.h"
  38 #include "main/renderbuffer.h"
  39
  40 #include "intel_buffers.h"
  41 #include "intel_fbo.h"
  42 #include "intel_screen.h"
  43 #include "intel_span.h"
  44 #include "intel_regions.h"
  45 #include "intel_tex.h"
  46
  47 #include "swrast/swrast.h"
  48
  49 static void
  50 intel_set_span_functions(struct intel_context *intel,
  51                          struct gl_renderbuffer *rb);
  52
  53 #undef DBG
  54 #define DBG 0
  55
  56 #define LOCAL_VARS                                                      \
  57    struct intel_renderbuffer *irb = intel_renderbuffer(rb);             \
  58    int minx = 0, miny = 0;                                              \
  59    int maxx = rb->Width;                                                \
  60    int maxy = rb->Height;                                               \
  61    int pitch = rb->RowStride * irb->region->cpp;                        \
  62    void *buf = rb->Data;                                                \
  63    GLuint p;                                                            \
  64    (void) p;
  65
  66 #define HW_CLIPLOOP()
  67 #define HW_ENDCLIPLOOP()
  68
  69 #define Y_FLIP(_y) (_y)
  70
  71 #define HW_LOCK()
  72
  73 #define HW_UNLOCK()
  74
  75 /* r5g6b5 color span and pixel functions */
  76 #define SPANTMP_PIXEL_FMT GL_RGB
  77 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_5_6_5
  78 #define TAG(x) intel_##x##_RGB565
  79 #define TAG2(x,y) intel_##x##y_RGB565
  80 #include "spantmp2.h"
  81
  82 /* a4r4g4b4 color span and pixel functions */
  83 #define SPANTMP_PIXEL_FMT GL_BGRA
  84 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_4_4_4_4_REV
  85 #define TAG(x) intel_##x##_ARGB4444
  86 #define TAG2(x,y) intel_##x##y_ARGB4444
  87 #include "spantmp2.h"
  88
  89 /* a1r5g5b5 color span and pixel functions */
  90 #define SPANTMP_PIXEL_FMT GL_BGRA
  91 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_1_5_5_5_REV
  92 #define TAG(x) intel_##x##_ARGB1555
  93 #define TAG2(x,y) intel_##x##y##_ARGB1555
  94 #include "spantmp2.h"
  95
  96 /* a8r8g8b8 color span and pixel functions */
  97 #define SPANTMP_PIXEL_FMT GL_BGRA
  98 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
  99 #define TAG(x) intel_##x##_ARGB8888
 100 #define TAG2(x,y) intel_##x##y##_ARGB8888
 101 #include "spantmp2.h"
 102
 103 /* x8r8g8b8 color span and pixel functions */
 104 #define SPANTMP_PIXEL_FMT GL_BGR
 105 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
 106 #define TAG(x) intel_##x##_xRGB8888
 107 #define TAG2(x,y) intel_##x##y##_xRGB8888
 108 #include "spantmp2.h"
 109
 110 /* a8 color span and pixel functions */
 111 #define SPANTMP_PIXEL_FMT GL_ALPHA
 112 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_BYTE
 113 #define TAG(x) intel_##x##_A8
 114 #define TAG2(x,y) intel_##x##y##_A8
 115 #include "spantmp2.h"
 116
 117 /* ------------------------------------------------------------------------- */
 118 /* s8 stencil span and pixel functions                                       */
 119 /* ------------------------------------------------------------------------- */
 120
 121 /*
 122  * HAVE_HW_STENCIL_SPANS determines if stencil buffer read/writes are done with
 123  * memcpy or for loops. Since the stencil buffer is interleaved, memcpy won't
 124  * work.
 125  */
 126 #define HAVE_HW_STENCIL_SPANS 0
 127
 128 #define LOCAL_STENCIL_VARS                                              \
 129    (void) ctx;                                                          \
 130    int minx = 0;                                                        \
 131    int miny = 0;                                                        \
 132    int maxx = rb->Width;                                                \
 133    int maxy = rb->Height;                                               \
 134                                                                         \
 135    /*                                                                   \
 136     * Here we ignore rb->Data and rb->RowStride as set by               \
 137     * intelSpanRenderStart. Since intel_offset_S8 decodes the W tile    \
 138     * manually, the region's *real* base address and stride is          \
 139     * required.                                                         \
 140     */                                                                  \
 141    struct intel_renderbuffer *irb = intel_renderbuffer(rb);             \
 142    uint8_t *buf = irb->region->bo->virtual;                             \
 143    unsigned stride = irb->region->pitch;                                \
 144    unsigned height = irb->region->height;                               \
 145    bool flip = rb->Name == 0;                                           \
 146    int y_scale = flip ? -1 : 1;                                         \
 147    int y_bias = flip ? (height * 2 + height % 2 - 1) : 0;               \
 148
 149 #undef Y_FLIP
 150 #define Y_FLIP(y) (y_scale * (y) + y_bias)
 151
 152 /**
 153  * \brief Get pointer offset into stencil buffer.
 154  *
 155  * The stencil buffer is W tiled. Since the GTT is incapable of W fencing, we
 156  * must decode the tile's layout in software.
 157  *
 158  * See
 159  *   - PRM, 2011 Sandy Bridge, Volume 1, Part 2, Section 4.5.2.1 W-Major Tile
 160  *     Format.
 161  *   - PRM, 2011 Sandy Bridge, Volume 1, Part 2, Section 4.5.3 Tiling Algorithm
 162  *
 163  * Even though the returned offset is always positive, the return type is
 164  * signed due to
 165  *    commit e8b1c6d6f55f5be3bef25084fdd8b6127517e137
 166  *    mesa: Fix return type of  _mesa_get_format_bytes() (#37351)
 167  */
 168 intptr_t
 169 intel_offset_S8(uint32_t stride, uint32_t x, uint32_t y)
 170 {
 171    uint32_t tile_size = 4096;
 172    uint32_t tile_width = 64;
 173    uint32_t tile_height = 64;
 174    uint32_t row_size = 64 * stride;
 175
 176    uint32_t tile_x = x / tile_width;
 177    uint32_t tile_y = y / tile_height;
 178
 179    /* The byte's address relative to the tile's base addres. */
 180    uint32_t byte_x = x % tile_width;
 181    uint32_t byte_y = y % tile_height;
 182
 183    uintptr_t u = tile_y * row_size
 184                + tile_x * tile_size
 185                + 512 * (byte_x / 8)
 186                +  64 * (byte_y / 8)
 187                +  32 * ((byte_y / 4) % 2)
 188                +  16 * ((byte_x / 4) % 2)
 189                +   8 * ((byte_y / 2) % 2)
 190                +   4 * ((byte_x / 2) % 2)
 191                +   2 * (byte_y % 2)
 192                +   1 * (byte_x % 2);
 193
 194    /*
 195     * Errata for Gen5:
 196     *
 197     * An additional offset is needed which is not documented in the PRM.
 198     *
 199     * if ((byte_x / 8) % 2 == 1) {
 200     *    if ((byte_y / 8) % 2) == 0) {
 201     *       u += 64;
 202     *    } else {
 203     *       u -= 64;
 204     *    }
 205     * }
 206     *
 207     * The offset is expressed more tersely as
 208     * u += ((int) x & 0x8) * (8 - (((int) y & 0x8) << 1));
 209     */
 210
 211    return u;
 212 }
 213
 214 #define WRITE_STENCIL(x, y, src)  buf[intel_offset_S8(stride, x, y)] = src;
 215 #define READ_STENCIL(dest, x, y) dest = buf[intel_offset_S8(stride, x, y)]
 216 #define TAG(x) intel_##x##_S8
 217 #include "stenciltmp.h"
 218
 219 /* ------------------------------------------------------------------------- */
 220
 221 void
 222 intel_renderbuffer_map(struct intel_context *intel, struct gl_renderbuffer *rb)
 223 {
 224    struct gl_context *ctx = &intel->ctx;
 225    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 226    GLubyte *map;
 227    int stride;
 228
 229    if (!irb)
 230       return;
 231
 232    if (irb->wrapped_depth)
 233       intel_renderbuffer_map(intel, irb->wrapped_depth);
 234    if (irb->wrapped_stencil)
 235       intel_renderbuffer_map(intel, irb->wrapped_stencil);
 236
 237    ctx->Driver.MapRenderbuffer(ctx, rb, 0, 0, rb->Width, rb->Height,
 238                                GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 239                                &map, &stride);
 240    rb->Data = map;
 241    rb->RowStride = stride / _mesa_get_format_bytes(rb->Format);
 242
 243    intel_set_span_functions(intel, rb);
 244 }
 245
 246 void
 247 intel_renderbuffer_unmap(struct intel_context *intel,
 248                          struct gl_renderbuffer *rb)
 249 {
 250    struct gl_context *ctx = &intel->ctx;
 251    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 252
 253    if (!irb)
 254       return;
 255
 256    if (irb->wrapped_depth)
 257       intel_renderbuffer_unmap(intel, irb->wrapped_depth);
 258    if (irb->wrapped_stencil)
 259       intel_renderbuffer_unmap(intel, irb->wrapped_stencil);
 260
 261    ctx->Driver.UnmapRenderbuffer(ctx, rb);
 262
 263    rb->GetRow = NULL;
 264    rb->PutRow = NULL;
 265    rb->Data = NULL;
 266    rb->RowStride = 0;
 267 }
 268
 269 static void
 270 intel_framebuffer_map(struct intel_context *intel, struct gl_framebuffer *fb)
 271 {
 272    int i;
 273
 274    for (i = 0; i < BUFFER_COUNT; i++) {
 275       intel_renderbuffer_map(intel, fb->Attachment[i].Renderbuffer);
 276    }
 277
 278    intel_check_front_buffer_rendering(intel);
 279 }
 280
 281 static void
 282 intel_framebuffer_unmap(struct intel_context *intel, struct gl_framebuffer *fb)
 283 {
 284    int i;
 285
 286    for (i = 0; i < BUFFER_COUNT; i++) {
 287       intel_renderbuffer_unmap(intel, fb->Attachment[i].Renderbuffer);
 288    }
 289 }
 290
 291 /**
 292  * Prepare for software rendering.  Map current read/draw framebuffers'
 293  * renderbuffes and all currently bound texture objects.
 294  *
 295  * Old note: Moved locking out to get reasonable span performance.
 296  */
 297 void
 298 intelSpanRenderStart(struct gl_context * ctx)
 299 {
 300    struct intel_context *intel = intel_context(ctx);
 301    GLuint i;
 302
 303    intel_flush(&intel->ctx);
 304    intel_prepare_render(intel);
 305
 306    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 307       if (ctx->Texture.Unit[i]._ReallyEnabled) {
 308          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 309
 310          intel_finalize_mipmap_tree(intel, i);
 311          intel_tex_map_images(intel, intel_texture_object(texObj),
 312                               GL_MAP_READ_BIT | GL_MAP_WRITE_BIT);
 313       }
 314    }
 315
 316    intel_framebuffer_map(intel, ctx->DrawBuffer);
 317    if (ctx->ReadBuffer != ctx->DrawBuffer) {
 318       intel_framebuffer_map(intel, ctx->ReadBuffer);
 319    }
 320 }
 321
 322 /**
 323  * Called when done software rendering.  Unmap the buffers we mapped in
 324  * the above function.
 325  */
 326 void
 327 intelSpanRenderFinish(struct gl_context * ctx)
 328 {
 329    struct intel_context *intel = intel_context(ctx);
 330    GLuint i;
 331
 332    _swrast_flush(ctx);
 333
 334    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 335       if (ctx->Texture.Unit[i]._ReallyEnabled) {
 336          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 337          intel_tex_unmap_images(intel, intel_texture_object(texObj));
 338       }
 339    }
 340
 341    intel_framebuffer_unmap(intel, ctx->DrawBuffer);
 342    if (ctx->ReadBuffer != ctx->DrawBuffer) {
 343       intel_framebuffer_unmap(intel, ctx->ReadBuffer);
 344    }
 345 }
 346
 347
 348 void
 349 intelInitSpanFuncs(struct gl_context * ctx)
 350 {
 351    struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
 352    swdd->SpanRenderStart = intelSpanRenderStart;
 353    swdd->SpanRenderFinish = intelSpanRenderFinish;
 354 }
 355
 356 void
 357 intel_map_vertex_shader_textures(struct gl_context *ctx)
 358 {
 359    struct intel_context *intel = intel_context(ctx);
 360    int i;
 361
 362    if (ctx->VertexProgram._Current == NULL)
 363       return;
 364
 365    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 366       if (ctx->Texture.Unit[i]._ReallyEnabled &&
 367           ctx->VertexProgram._Current->Base.TexturesUsed[i] != 0) {
 368          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 369
 370          intel_tex_map_images(intel, intel_texture_object(texObj),
 371                               GL_MAP_READ_BIT | GL_MAP_WRITE_BIT);
 372       }
 373    }
 374 }
 375
 376 void
 377 intel_unmap_vertex_shader_textures(struct gl_context *ctx)
 378 {
 379    struct intel_context *intel = intel_context(ctx);
 380    int i;
 381
 382    if (ctx->VertexProgram._Current == NULL)
 383       return;
 384
 385    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 386       if (ctx->Texture.Unit[i]._ReallyEnabled &&
 387           ctx->VertexProgram._Current->Base.TexturesUsed[i] != 0) {
 388          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 389
 390          intel_tex_unmap_images(intel, intel_texture_object(texObj));
 391       }
 392    }
 393 }
 394
 395 typedef void (*span_init_func)(struct gl_renderbuffer *rb);
 396
 397 static span_init_func intel_span_init_funcs[MESA_FORMAT_COUNT] =
 398 {
 399    [MESA_FORMAT_A8] = intel_InitPointers_A8,
 400    [MESA_FORMAT_RGB565] = intel_InitPointers_RGB565,
 401    [MESA_FORMAT_ARGB4444] = intel_InitPointers_ARGB4444,
 402    [MESA_FORMAT_ARGB1555] = intel_InitPointers_ARGB1555,
 403    [MESA_FORMAT_XRGB8888] = intel_InitPointers_xRGB8888,
 404    [MESA_FORMAT_ARGB8888] = intel_InitPointers_ARGB8888,
 405    [MESA_FORMAT_SARGB8] = intel_InitPointers_ARGB8888,
 406    [MESA_FORMAT_Z16] = _mesa_set_renderbuffer_accessors,
 407    [MESA_FORMAT_X8_Z24] = _mesa_set_renderbuffer_accessors,
 408    [MESA_FORMAT_S8_Z24] = _mesa_set_renderbuffer_accessors,
 409    [MESA_FORMAT_S8] = intel_InitStencilPointers_S8,
 410    [MESA_FORMAT_R8] = _mesa_set_renderbuffer_accessors,
 411    [MESA_FORMAT_RG88] = _mesa_set_renderbuffer_accessors,
 412    [MESA_FORMAT_R16] = _mesa_set_renderbuffer_accessors,
 413    [MESA_FORMAT_RG1616] = _mesa_set_renderbuffer_accessors,
 414    [MESA_FORMAT_RGBA_FLOAT32] = _mesa_set_renderbuffer_accessors,
 415    [MESA_FORMAT_RG_FLOAT32] = _mesa_set_renderbuffer_accessors,
 416    [MESA_FORMAT_R_FLOAT32] = _mesa_set_renderbuffer_accessors,
 417    [MESA_FORMAT_INTENSITY_FLOAT32] = _mesa_set_renderbuffer_accessors,
 418    [MESA_FORMAT_LUMINANCE_FLOAT32] = _mesa_set_renderbuffer_accessors,
 419 };
 420
 421 bool
 422 intel_span_supports_format(gl_format format)
 423 {
 424    /* Rendering to/from integer textures will be done using MapRenderbuffer,
 425     * rather than coding up new paths through GetRow/PutRow(), so claim support
 426     * for those formats in here for now.
 427     */
 428    return (intel_span_init_funcs[format] != NULL ||
 429            _mesa_is_format_integer_color(format));
 430 }
 431
 432 /**
 433  * Plug in appropriate span read/write functions for the given renderbuffer.
 434  * These are used for the software fallbacks.
 435  */
 436 static void
 437 intel_set_span_functions(struct intel_context *intel,
 438                          struct gl_renderbuffer *rb)
 439 {
 440    struct intel_renderbuffer *irb = (struct intel_renderbuffer *) rb;
 441
 442    assert(intel_span_init_funcs[irb->Base.Format]);
 443    intel_span_init_funcs[irb->Base.Format](rb);
 444
 445    if (rb->DataType == GL_NONE) {
 446       _mesa_problem(NULL,
 447                     "renderbuffer format %s is missing "
 448                     "intel_mesa_format_to_rb_datatype() support.",
 449                     _mesa_get_format_name(rb->Format));
 450    }
 451 }