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_mipmap_tree.h"
  43 #include "intel_screen.h"
  44 #include "intel_span.h"
  45 #include "intel_regions.h"
  46 #include "intel_tex.h"
  47
  48 #include "swrast/swrast.h"
  49
  50 static void
  51 intel_set_span_functions(struct intel_context *intel,
  52                          struct gl_renderbuffer *rb);
  53
  54 #undef DBG
  55 #define DBG 0
  56
  57 #define LOCAL_VARS                                                      \
  58    struct intel_renderbuffer *irb = intel_renderbuffer(rb);             \
  59    int minx = 0, miny = 0;                                              \
  60    int maxx = rb->Width;                                                \
  61    int maxy = rb->Height;                                               \
  62    int pitch = rb->RowStride * irb->mt->region->cpp;                    \
  63    void *buf = rb->Data;                                                \
  64    GLuint p;                                                            \
  65    (void) p;
  66
  67 #define HW_CLIPLOOP()
  68 #define HW_ENDCLIPLOOP()
  69
  70 #define Y_FLIP(_y) (_y)
  71
  72 #define HW_LOCK()
  73
  74 #define HW_UNLOCK()
  75
  76 /* r5g6b5 color span and pixel functions */
  77 #define SPANTMP_PIXEL_FMT GL_RGB
  78 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_5_6_5
  79 #define TAG(x) intel_##x##_RGB565
  80 #define TAG2(x,y) intel_##x##y_RGB565
  81 #include "spantmp2.h"
  82
  83 /* a4r4g4b4 color span and pixel functions */
  84 #define SPANTMP_PIXEL_FMT GL_BGRA
  85 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_4_4_4_4_REV
  86 #define TAG(x) intel_##x##_ARGB4444
  87 #define TAG2(x,y) intel_##x##y_ARGB4444
  88 #include "spantmp2.h"
  89
  90 /* a1r5g5b5 color span and pixel functions */
  91 #define SPANTMP_PIXEL_FMT GL_BGRA
  92 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_1_5_5_5_REV
  93 #define TAG(x) intel_##x##_ARGB1555
  94 #define TAG2(x,y) intel_##x##y##_ARGB1555
  95 #include "spantmp2.h"
  96
  97 /* a8r8g8b8 color span and pixel functions */
  98 #define SPANTMP_PIXEL_FMT GL_BGRA
  99 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
 100 #define TAG(x) intel_##x##_ARGB8888
 101 #define TAG2(x,y) intel_##x##y##_ARGB8888
 102 #include "spantmp2.h"
 103
 104 /* x8r8g8b8 color span and pixel functions */
 105 #define SPANTMP_PIXEL_FMT GL_BGR
 106 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
 107 #define TAG(x) intel_##x##_xRGB8888
 108 #define TAG2(x,y) intel_##x##y##_xRGB8888
 109 #include "spantmp2.h"
 110
 111 /* a8 color span and pixel functions */
 112 #define SPANTMP_PIXEL_FMT GL_ALPHA
 113 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_BYTE
 114 #define TAG(x) intel_##x##_A8
 115 #define TAG2(x,y) intel_##x##y##_A8
 116 #include "spantmp2.h"
 117
 118 /**
 119  * \brief Get pointer offset into stencil buffer.
 120  *
 121  * The stencil buffer is W tiled. Since the GTT is incapable of W fencing, we
 122  * must decode the tile's layout in software.
 123  *
 124  * See
 125  *   - PRM, 2011 Sandy Bridge, Volume 1, Part 2, Section 4.5.2.1 W-Major Tile
 126  *     Format.
 127  *   - PRM, 2011 Sandy Bridge, Volume 1, Part 2, Section 4.5.3 Tiling Algorithm
 128  *
 129  * Even though the returned offset is always positive, the return type is
 130  * signed due to
 131  *    commit e8b1c6d6f55f5be3bef25084fdd8b6127517e137
 132  *    mesa: Fix return type of  _mesa_get_format_bytes() (#37351)
 133  */
 134 intptr_t
 135 intel_offset_S8(uint32_t stride, uint32_t x, uint32_t y)
 136 {
 137    uint32_t tile_size = 4096;
 138    uint32_t tile_width = 64;
 139    uint32_t tile_height = 64;
 140    uint32_t row_size = 64 * stride;
 141
 142    uint32_t tile_x = x / tile_width;
 143    uint32_t tile_y = y / tile_height;
 144
 145    /* The byte's address relative to the tile's base addres. */
 146    uint32_t byte_x = x % tile_width;
 147    uint32_t byte_y = y % tile_height;
 148
 149    uintptr_t u = tile_y * row_size
 150                + tile_x * tile_size
 151                + 512 * (byte_x / 8)
 152                +  64 * (byte_y / 8)
 153                +  32 * ((byte_y / 4) % 2)
 154                +  16 * ((byte_x / 4) % 2)
 155                +   8 * ((byte_y / 2) % 2)
 156                +   4 * ((byte_x / 2) % 2)
 157                +   2 * (byte_y % 2)
 158                +   1 * (byte_x % 2);
 159
 160    /*
 161     * Errata for Gen5:
 162     *
 163     * An additional offset is needed which is not documented in the PRM.
 164     *
 165     * if ((byte_x / 8) % 2 == 1) {
 166     *    if ((byte_y / 8) % 2) == 0) {
 167     *       u += 64;
 168     *    } else {
 169     *       u -= 64;
 170     *    }
 171     * }
 172     *
 173     * The offset is expressed more tersely as
 174     * u += ((int) x & 0x8) * (8 - (((int) y & 0x8) << 1));
 175     */
 176
 177    return u;
 178 }
 179
 180 void
 181 intel_renderbuffer_map(struct intel_context *intel, struct gl_renderbuffer *rb)
 182 {
 183    struct gl_context *ctx = &intel->ctx;
 184    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 185    GLubyte *map;
 186    int stride;
 187
 188    if (!irb)
 189       return;
 190
 191    if (rb->Data) {
 192       /* Renderbuffer is already mapped. This usually happens when a single
 193        * buffer is attached to the framebuffer's depth and stencil attachment
 194        * points.
 195        */
 196       return;
 197    }
 198
 199    ctx->Driver.MapRenderbuffer(ctx, rb, 0, 0, rb->Width, rb->Height,
 200                                GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 201                                &map, &stride);
 202    rb->Data = map;
 203    rb->RowStride = stride / _mesa_get_format_bytes(rb->Format);
 204
 205    intel_set_span_functions(intel, rb);
 206 }
 207
 208 void
 209 intel_renderbuffer_unmap(struct intel_context *intel,
 210                          struct gl_renderbuffer *rb)
 211 {
 212    struct gl_context *ctx = &intel->ctx;
 213    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 214
 215    if (!irb)
 216       return;
 217
 218    if (!rb->Data) {
 219       /* Renderbuffer is already unmapped. This usually happens when a single
 220        * buffer is attached to the framebuffer's depth and stencil attachment
 221        * points.
 222        */
 223       return;
 224    }
 225
 226    ctx->Driver.UnmapRenderbuffer(ctx, rb);
 227
 228    rb->GetRow = NULL;
 229    rb->PutRow = NULL;
 230    rb->Data = NULL;
 231    rb->RowStride = 0;
 232 }
 233
 234 static void
 235 intel_framebuffer_map(struct intel_context *intel, struct gl_framebuffer *fb)
 236 {
 237    int i;
 238
 239    for (i = 0; i < BUFFER_COUNT; i++) {
 240       intel_renderbuffer_map(intel, fb->Attachment[i].Renderbuffer);
 241    }
 242
 243    intel_check_front_buffer_rendering(intel);
 244 }
 245
 246 static void
 247 intel_framebuffer_unmap(struct intel_context *intel, struct gl_framebuffer *fb)
 248 {
 249    int i;
 250
 251    for (i = 0; i < BUFFER_COUNT; i++) {
 252       intel_renderbuffer_unmap(intel, fb->Attachment[i].Renderbuffer);
 253    }
 254 }
 255
 256 /**
 257  * Map the regions needed by intelSpanRenderStart().
 258  */
 259 static void
 260 intel_span_map_buffers(struct intel_context *intel)
 261 {
 262    struct gl_context *ctx = &intel->ctx;
 263    struct intel_texture_object *tex_obj;
 264
 265    for (int i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 266       if (!ctx->Texture.Unit[i]._ReallyEnabled)
 267          continue;
 268       tex_obj = intel_texture_object(ctx->Texture.Unit[i]._Current);
 269       intel_finalize_mipmap_tree(intel, i);
 270       intel_tex_map_images(intel, tex_obj,
 271                            GL_MAP_READ_BIT | GL_MAP_WRITE_BIT);
 272    }
 273
 274    intel_framebuffer_map(intel, ctx->DrawBuffer);
 275    if (ctx->ReadBuffer != ctx->DrawBuffer) {
 276       intel_framebuffer_map(intel, ctx->ReadBuffer);
 277    }
 278 }
 279
 280 /**
 281  * Prepare for software rendering.  Map current read/draw framebuffers'
 282  * renderbuffes and all currently bound texture objects.
 283  *
 284  * Old note: Moved locking out to get reasonable span performance.
 285  */
 286 void
 287 intelSpanRenderStart(struct gl_context * ctx)
 288 {
 289    struct intel_context *intel = intel_context(ctx);
 290
 291    intel_flush(&intel->ctx);
 292    intel_prepare_render(intel);
 293    intel_span_map_buffers(intel);
 294 }
 295
 296 /**
 297  * Called when done software rendering.  Unmap the buffers we mapped in
 298  * the above function.
 299  */
 300 void
 301 intelSpanRenderFinish(struct gl_context * ctx)
 302 {
 303    struct intel_context *intel = intel_context(ctx);
 304    GLuint i;
 305
 306    _swrast_flush(ctx);
 307
 308    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 309       if (ctx->Texture.Unit[i]._ReallyEnabled) {
 310          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 311          intel_tex_unmap_images(intel, intel_texture_object(texObj));
 312       }
 313    }
 314
 315    intel_framebuffer_unmap(intel, ctx->DrawBuffer);
 316    if (ctx->ReadBuffer != ctx->DrawBuffer) {
 317       intel_framebuffer_unmap(intel, ctx->ReadBuffer);
 318    }
 319 }
 320
 321
 322 void
 323 intelInitSpanFuncs(struct gl_context * ctx)
 324 {
 325    struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
 326    swdd->SpanRenderStart = intelSpanRenderStart;
 327    swdd->SpanRenderFinish = intelSpanRenderFinish;
 328 }
 329
 330 void
 331 intel_map_vertex_shader_textures(struct gl_context *ctx)
 332 {
 333    struct intel_context *intel = intel_context(ctx);
 334    int i;
 335
 336    if (ctx->VertexProgram._Current == NULL)
 337       return;
 338
 339    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 340       if (ctx->Texture.Unit[i]._ReallyEnabled &&
 341           ctx->VertexProgram._Current->Base.TexturesUsed[i] != 0) {
 342          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 343
 344          intel_tex_map_images(intel, intel_texture_object(texObj),
 345                               GL_MAP_READ_BIT | GL_MAP_WRITE_BIT);
 346       }
 347    }
 348 }
 349
 350 void
 351 intel_unmap_vertex_shader_textures(struct gl_context *ctx)
 352 {
 353    struct intel_context *intel = intel_context(ctx);
 354    int i;
 355
 356    if (ctx->VertexProgram._Current == NULL)
 357       return;
 358
 359    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
 360       if (ctx->Texture.Unit[i]._ReallyEnabled &&
 361           ctx->VertexProgram._Current->Base.TexturesUsed[i] != 0) {
 362          struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
 363
 364          intel_tex_unmap_images(intel, intel_texture_object(texObj));
 365       }
 366    }
 367 }
 368
 369 typedef void (*span_init_func)(struct gl_renderbuffer *rb);
 370
 371 static span_init_func intel_span_init_funcs[MESA_FORMAT_COUNT] =
 372 {
 373    [MESA_FORMAT_A8] = intel_InitPointers_A8,
 374    [MESA_FORMAT_RGB565] = intel_InitPointers_RGB565,
 375    [MESA_FORMAT_ARGB4444] = intel_InitPointers_ARGB4444,
 376    [MESA_FORMAT_ARGB1555] = intel_InitPointers_ARGB1555,
 377    [MESA_FORMAT_XRGB8888] = intel_InitPointers_xRGB8888,
 378    [MESA_FORMAT_ARGB8888] = intel_InitPointers_ARGB8888,
 379    [MESA_FORMAT_SARGB8] = intel_InitPointers_ARGB8888,
 380    [MESA_FORMAT_Z16] = _mesa_set_renderbuffer_accessors,
 381    [MESA_FORMAT_X8_Z24] = _mesa_set_renderbuffer_accessors,
 382    [MESA_FORMAT_S8_Z24] = _mesa_set_renderbuffer_accessors,
 383    [MESA_FORMAT_S8] = _mesa_set_renderbuffer_accessors,
 384    [MESA_FORMAT_R8] = _mesa_set_renderbuffer_accessors,
 385    [MESA_FORMAT_RG88] = _mesa_set_renderbuffer_accessors,
 386    [MESA_FORMAT_R16] = _mesa_set_renderbuffer_accessors,
 387    [MESA_FORMAT_RG1616] = _mesa_set_renderbuffer_accessors,
 388    [MESA_FORMAT_RGBA_FLOAT32] = _mesa_set_renderbuffer_accessors,
 389    [MESA_FORMAT_RG_FLOAT32] = _mesa_set_renderbuffer_accessors,
 390    [MESA_FORMAT_R_FLOAT32] = _mesa_set_renderbuffer_accessors,
 391    [MESA_FORMAT_INTENSITY_FLOAT32] = _mesa_set_renderbuffer_accessors,
 392    [MESA_FORMAT_LUMINANCE_FLOAT32] = _mesa_set_renderbuffer_accessors,
 393 };
 394
 395 bool
 396 intel_span_supports_format(gl_format format)
 397 {
 398    /* Rendering to/from integer textures will be done using MapRenderbuffer,
 399     * rather than coding up new paths through GetRow/PutRow(), so claim support
 400     * for those formats in here for now.
 401     */
 402    return (intel_span_init_funcs[format] != NULL ||
 403            _mesa_is_format_integer_color(format));
 404 }
 405
 406 /**
 407  * Plug in appropriate span read/write functions for the given renderbuffer.
 408  * These are used for the software fallbacks.
 409  */
 410 static void
 411 intel_set_span_functions(struct intel_context *intel,
 412                          struct gl_renderbuffer *rb)
 413 {
 414    struct intel_renderbuffer *irb = (struct intel_renderbuffer *) rb;
 415
 416    assert(intel_span_init_funcs[irb->Base.Format]);
 417    intel_span_init_funcs[irb->Base.Format](rb);
 418
 419    if (rb->DataType == GL_NONE) {
 420       _mesa_problem(NULL,
 421                     "renderbuffer format %s is missing "
 422                     "intel_mesa_format_to_rb_datatype() support.",
 423                     _mesa_get_format_name(rb->Format));
 424    }
 425 }