src/gallium/auxiliary/gallivm/lp_bld_sample.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   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 VMWARE 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  * @file
  30  * Texture sampling.
  31  *
  32  * @author Jose Fonseca <jfonseca@vmware.com>
  33  */
  34
  35 #ifndef LP_BLD_SAMPLE_H
  36 #define LP_BLD_SAMPLE_H
  37
  38
  39 #include "pipe/p_format.h"
  40 #include "util/u_debug.h"
  41 #include "gallivm/lp_bld.h"
  42 #include "gallivm/lp_bld_type.h"
  43 #include "gallivm/lp_bld_swizzle.h"
  44
  45 #ifdef __cplusplus
  46 extern "C" {
  47 #endif
  48
  49 struct pipe_resource;
  50 struct pipe_sampler_view;
  51 struct pipe_sampler_state;
  52 struct util_format_description;
  53 struct lp_type;
  54 struct lp_build_context;
  55
  56
  57 /**
  58  * Helper struct holding all derivatives needed for sampling
  59  */
  60 struct lp_derivatives
  61 {
  62    LLVMValueRef ddx[3];
  63    LLVMValueRef ddy[3];
  64 };
  65
  66
  67 enum lp_sampler_lod_property {
  68    LP_SAMPLER_LOD_SCALAR,
  69    LP_SAMPLER_LOD_PER_ELEMENT,
  70    LP_SAMPLER_LOD_PER_QUAD
  71 };
  72
  73
  74 enum lp_sampler_lod_control {
  75    LP_SAMPLER_LOD_IMPLICIT,
  76    LP_SAMPLER_LOD_BIAS,
  77    LP_SAMPLER_LOD_EXPLICIT,
  78    LP_SAMPLER_LOD_DERIVATIVES,
  79 };
  80
  81
  82 enum lp_sampler_op_type {
  83    LP_SAMPLER_OP_TEXTURE,
  84    LP_SAMPLER_OP_FETCH,
  85    LP_SAMPLER_OP_GATHER,
  86    LP_SAMPLER_OP_LODQ
  87 };
  88
  89
  90 #define LP_SAMPLER_SHADOW             (1 << 0)
  91 #define LP_SAMPLER_OFFSETS            (1 << 1)
  92 #define LP_SAMPLER_OP_TYPE_SHIFT            2
  93 #define LP_SAMPLER_OP_TYPE_MASK       (3 << 2)
  94 #define LP_SAMPLER_LOD_CONTROL_SHIFT        4
  95 #define LP_SAMPLER_LOD_CONTROL_MASK   (3 << 4)
  96 #define LP_SAMPLER_LOD_PROPERTY_SHIFT       6
  97 #define LP_SAMPLER_LOD_PROPERTY_MASK  (3 << 6)
  98
  99 struct lp_sampler_params
 100 {
 101    struct lp_type type;
 102    unsigned texture_index;
 103    unsigned sampler_index;
 104    unsigned sample_key;
 105    LLVMValueRef context_ptr;
 106    LLVMValueRef thread_data_ptr;
 107    const LLVMValueRef *coords;
 108    const LLVMValueRef *offsets;
 109    LLVMValueRef lod;
 110    const struct lp_derivatives *derivs;
 111    LLVMValueRef *texel;
 112 };
 113
 114 struct lp_sampler_size_query_params
 115 {
 116    struct lp_type int_type;
 117    unsigned texture_unit;
 118    unsigned target;
 119    LLVMValueRef context_ptr;
 120    boolean is_sviewinfo;
 121    enum lp_sampler_lod_property lod_property;
 122    LLVMValueRef explicit_lod;
 123    LLVMValueRef *sizes_out;
 124 };
 125 /**
 126  * Texture static state.
 127  *
 128  * These are the bits of state from pipe_resource/pipe_sampler_view that
 129  * are embedded in the generated code.
 130  */
 131 struct lp_static_texture_state
 132 {
 133    /* pipe_sampler_view's state */
 134    enum pipe_format format;
 135    unsigned swizzle_r:3;     /**< PIPE_SWIZZLE_* */
 136    unsigned swizzle_g:3;
 137    unsigned swizzle_b:3;
 138    unsigned swizzle_a:3;
 139
 140    /* pipe_texture's state */
 141    unsigned target:4;        /**< PIPE_TEXTURE_* */
 142    unsigned pot_width:1;     /**< is the width a power of two? */
 143    unsigned pot_height:1;
 144    unsigned pot_depth:1;
 145    unsigned level_zero_only:1;
 146 };
 147
 148
 149 /**
 150  * Sampler static state.
 151  *
 152  * These are the bits of state from pipe_sampler_state that
 153  * are embedded in the generated code.
 154  */
 155 struct lp_static_sampler_state
 156 {
 157    /* pipe_sampler_state's state */
 158    unsigned wrap_s:3;
 159    unsigned wrap_t:3;
 160    unsigned wrap_r:3;
 161    unsigned min_img_filter:2;
 162    unsigned min_mip_filter:2;
 163    unsigned mag_img_filter:2;
 164    unsigned compare_mode:1;
 165    unsigned compare_func:3;
 166    unsigned normalized_coords:1;
 167    unsigned min_max_lod_equal:1;  /**< min_lod == max_lod ? */
 168    unsigned lod_bias_non_zero:1;
 169    unsigned max_lod_pos:1;
 170    unsigned apply_min_lod:1;  /**< min_lod > 0 ? */
 171    unsigned apply_max_lod:1;  /**< max_lod < last_level ? */
 172    unsigned seamless_cube_map:1;
 173
 174    /* Hacks */
 175    unsigned force_nearest_s:1;
 176    unsigned force_nearest_t:1;
 177 };
 178
 179
 180 /**
 181  * Sampler dynamic state.
 182  *
 183  * These are the bits of state from pipe_resource/pipe_sampler_view
 184  * as well as from sampler state that are computed at runtime.
 185  *
 186  * There are obtained through callbacks, as we don't want to tie the texture
 187  * sampling code generation logic to any particular texture layout or pipe
 188  * driver.
 189  */
 190 struct lp_sampler_dynamic_state
 191 {
 192    /* First callbacks for sampler view state */
 193
 194    /** Obtain the base texture width (or number of elements) (returns int32) */
 195    LLVMValueRef
 196    (*width)(const struct lp_sampler_dynamic_state *state,
 197             struct gallivm_state *gallivm,
 198             LLVMValueRef context_ptr,
 199             unsigned texture_unit);
 200
 201    /** Obtain the base texture height (returns int32) */
 202    LLVMValueRef
 203    (*height)(const struct lp_sampler_dynamic_state *state,
 204              struct gallivm_state *gallivm,
 205              LLVMValueRef context_ptr,
 206              unsigned texture_unit);
 207
 208    /** Obtain the base texture depth (or array size) (returns int32) */
 209    LLVMValueRef
 210    (*depth)(const struct lp_sampler_dynamic_state *state,
 211             struct gallivm_state *gallivm,
 212             LLVMValueRef context_ptr,
 213             unsigned texture_unit);
 214
 215    /** Obtain the first mipmap level (base level) (returns int32) */
 216    LLVMValueRef
 217    (*first_level)(const struct lp_sampler_dynamic_state *state,
 218                   struct gallivm_state *gallivm,
 219                   LLVMValueRef context_ptr,
 220                   unsigned texture_unit);
 221
 222    /** Obtain the number of mipmap levels minus one (returns int32) */
 223    LLVMValueRef
 224    (*last_level)(const struct lp_sampler_dynamic_state *state,
 225                  struct gallivm_state *gallivm,
 226                  LLVMValueRef context_ptr,
 227                  unsigned texture_unit);
 228
 229    /** Obtain stride in bytes between image rows/blocks (returns int32) */
 230    LLVMValueRef
 231    (*row_stride)(const struct lp_sampler_dynamic_state *state,
 232                  struct gallivm_state *gallivm,
 233                  LLVMValueRef context_ptr,
 234                  unsigned texture_unit);
 235
 236    /** Obtain stride in bytes between image slices (returns int32) */
 237    LLVMValueRef
 238    (*img_stride)(const struct lp_sampler_dynamic_state *state,
 239                  struct gallivm_state *gallivm,
 240                  LLVMValueRef context_ptr,
 241                  unsigned texture_unit);
 242
 243    /** Obtain pointer to base of texture */
 244    LLVMValueRef
 245    (*base_ptr)(const struct lp_sampler_dynamic_state *state,
 246                struct gallivm_state *gallivm,
 247                LLVMValueRef context_ptr,
 248                unsigned texture_unit);
 249
 250    /** Obtain pointer to array of mipmap offsets */
 251    LLVMValueRef
 252    (*mip_offsets)(const struct lp_sampler_dynamic_state *state,
 253                   struct gallivm_state *gallivm,
 254                   LLVMValueRef context_ptr,
 255                   unsigned texture_unit);
 256
 257    /* These are callbacks for sampler state */
 258
 259    /** Obtain texture min lod (returns float) */
 260    LLVMValueRef
 261    (*min_lod)(const struct lp_sampler_dynamic_state *state,
 262               struct gallivm_state *gallivm,
 263               LLVMValueRef context_ptr,
 264               unsigned sampler_unit);
 265
 266    /** Obtain texture max lod (returns float) */
 267    LLVMValueRef
 268    (*max_lod)(const struct lp_sampler_dynamic_state *state,
 269               struct gallivm_state *gallivm,
 270               LLVMValueRef context_ptr,
 271               unsigned sampler_unit);
 272
 273    /** Obtain texture lod bias (returns float) */
 274    LLVMValueRef
 275    (*lod_bias)(const struct lp_sampler_dynamic_state *state,
 276                struct gallivm_state *gallivm,
 277                LLVMValueRef context_ptr,
 278                unsigned sampler_unit);
 279
 280    /** Obtain texture border color (returns ptr to float[4]) */
 281    LLVMValueRef
 282    (*border_color)(const struct lp_sampler_dynamic_state *state,
 283                    struct gallivm_state *gallivm,
 284                    LLVMValueRef context_ptr,
 285                    unsigned sampler_unit);
 286
 287    /**
 288     * Obtain texture cache (returns ptr to lp_build_format_cache).
 289     *
 290     * It's optional: no caching will be done if it's NULL.
 291     */
 292    LLVMValueRef
 293    (*cache_ptr)(const struct lp_sampler_dynamic_state *state,
 294                 struct gallivm_state *gallivm,
 295                 LLVMValueRef thread_data_ptr,
 296                 unsigned unit);
 297 };
 298
 299
 300 /**
 301  * Keep all information for sampling code generation in a single place.
 302  */
 303 struct lp_build_sample_context
 304 {
 305    struct gallivm_state *gallivm;
 306
 307    const struct lp_static_texture_state *static_texture_state;
 308    const struct lp_static_sampler_state *static_sampler_state;
 309
 310    struct lp_sampler_dynamic_state *dynamic_state;
 311
 312    const struct util_format_description *format_desc;
 313
 314    /* See texture_dims() */
 315    unsigned dims;
 316
 317    /** SIMD vector width */
 318    unsigned vector_width;
 319
 320    /** number of mipmaps (valid are 1, length/4, length) */
 321    unsigned num_mips;
 322
 323    /** number of lod values (valid are 1, length/4, length) */
 324    unsigned num_lods;
 325
 326    boolean no_quad_lod;
 327    boolean no_brilinear;
 328    boolean no_rho_approx;
 329
 330    /** regular scalar float type */
 331    struct lp_type float_type;
 332    struct lp_build_context float_bld;
 333
 334    /** float vector type */
 335    struct lp_build_context float_vec_bld;
 336
 337    /** regular scalar int type */
 338    struct lp_type int_type;
 339    struct lp_build_context int_bld;
 340
 341    /** Incoming coordinates type and build context */
 342    struct lp_type coord_type;
 343    struct lp_build_context coord_bld;
 344
 345    /** Signed integer coordinates */
 346    struct lp_type int_coord_type;
 347    struct lp_build_context int_coord_bld;
 348
 349    /** Unsigned integer texture size */
 350    struct lp_type int_size_in_type;
 351    struct lp_build_context int_size_in_bld;
 352
 353    /** Float incoming texture size */
 354    struct lp_type float_size_in_type;
 355    struct lp_build_context float_size_in_bld;
 356
 357    /** Unsigned integer texture size (might be per quad) */
 358    struct lp_type int_size_type;
 359    struct lp_build_context int_size_bld;
 360
 361    /** Float texture size (might be per quad) */
 362    struct lp_type float_size_type;
 363    struct lp_build_context float_size_bld;
 364
 365    /** Output texels type and build context */
 366    struct lp_type texel_type;
 367    struct lp_build_context texel_bld;
 368
 369    /** Float level type */
 370    struct lp_type levelf_type;
 371    struct lp_build_context levelf_bld;
 372
 373    /** Int level type */
 374    struct lp_type leveli_type;
 375    struct lp_build_context leveli_bld;
 376
 377    /** Float lod type */
 378    struct lp_type lodf_type;
 379    struct lp_build_context lodf_bld;
 380
 381    /** Int lod type */
 382    struct lp_type lodi_type;
 383    struct lp_build_context lodi_bld;
 384
 385    /* Common dynamic state values */
 386    LLVMValueRef row_stride_array;
 387    LLVMValueRef img_stride_array;
 388    LLVMValueRef base_ptr;
 389    LLVMValueRef mip_offsets;
 390    LLVMValueRef cache;
 391
 392    /** Integer vector with texture width, height, depth */
 393    LLVMValueRef int_size;
 394
 395    LLVMValueRef border_color_clamped;
 396
 397    LLVMValueRef context_ptr;
 398 };
 399
 400
 401
 402 /**
 403  * We only support a few wrap modes in lp_build_sample_wrap_linear_int() at
 404  * this time.  Return whether the given mode is supported by that function.
 405  */
 406 static inline boolean
 407 lp_is_simple_wrap_mode(unsigned mode)
 408 {
 409    switch (mode) {
 410    case PIPE_TEX_WRAP_REPEAT:
 411    case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
 412       return TRUE;
 413    default:
 414       return FALSE;
 415    }
 416 }
 417
 418
 419 static inline void
 420 apply_sampler_swizzle(struct lp_build_sample_context *bld,
 421                       LLVMValueRef *texel)
 422 {
 423    unsigned char swizzles[4];
 424
 425    swizzles[0] = bld->static_texture_state->swizzle_r;
 426    swizzles[1] = bld->static_texture_state->swizzle_g;
 427    swizzles[2] = bld->static_texture_state->swizzle_b;
 428    swizzles[3] = bld->static_texture_state->swizzle_a;
 429
 430    lp_build_swizzle_soa_inplace(&bld->texel_bld, texel, swizzles);
 431 }
 432
 433 /*
 434  * not really dimension as such, this indicates the amount of
 435  * "normal" texture coords subject to minification, wrapping etc.
 436  */
 437 static inline unsigned
 438 texture_dims(enum pipe_texture_target tex)
 439 {
 440    switch (tex) {
 441    case PIPE_TEXTURE_1D:
 442    case PIPE_TEXTURE_1D_ARRAY:
 443    case PIPE_BUFFER:
 444       return 1;
 445    case PIPE_TEXTURE_2D:
 446    case PIPE_TEXTURE_2D_ARRAY:
 447    case PIPE_TEXTURE_RECT:
 448    case PIPE_TEXTURE_CUBE:
 449    case PIPE_TEXTURE_CUBE_ARRAY:
 450       return 2;
 451    case PIPE_TEXTURE_3D:
 452       return 3;
 453    default:
 454       assert(0 && "bad texture target in texture_dims()");
 455       return 2;
 456    }
 457 }
 458
 459 static inline boolean
 460 has_layer_coord(enum pipe_texture_target tex)
 461 {
 462    switch (tex) {
 463    case PIPE_TEXTURE_1D_ARRAY:
 464    case PIPE_TEXTURE_2D_ARRAY:
 465    /* cube is not layered but 3rd coord (after cube mapping) behaves the same */
 466    case PIPE_TEXTURE_CUBE:
 467    case PIPE_TEXTURE_CUBE_ARRAY:
 468       return TRUE;
 469    default:
 470       return FALSE;
 471    }
 472 }
 473
 474
 475 boolean
 476 lp_sampler_wrap_mode_uses_border_color(unsigned mode,
 477                                        unsigned min_img_filter,
 478                                        unsigned mag_img_filter);
 479
 480 /**
 481  * Derive the sampler static state.
 482  */
 483 void
 484 lp_sampler_static_sampler_state(struct lp_static_sampler_state *state,
 485                                 const struct pipe_sampler_state *sampler);
 486
 487
 488 void
 489 lp_sampler_static_texture_state(struct lp_static_texture_state *state,
 490                                 const struct pipe_sampler_view *view);
 491
 492
 493 void
 494 lp_build_lod_selector(struct lp_build_sample_context *bld,
 495                       boolean is_lodq,
 496                       unsigned texture_index,
 497                       unsigned sampler_index,
 498                       LLVMValueRef s,
 499                       LLVMValueRef t,
 500                       LLVMValueRef r,
 501                       LLVMValueRef cube_rho,
 502                       const struct lp_derivatives *derivs,
 503                       LLVMValueRef lod_bias, /* optional */
 504                       LLVMValueRef explicit_lod, /* optional */
 505                       unsigned mip_filter,
 506                       LLVMValueRef *out_lod,
 507                       LLVMValueRef *out_lod_ipart,
 508                       LLVMValueRef *out_lod_fpart,
 509                       LLVMValueRef *out_lod_positive);
 510
 511 void
 512 lp_build_nearest_mip_level(struct lp_build_sample_context *bld,
 513                            unsigned texture_unit,
 514                            LLVMValueRef lod,
 515                            LLVMValueRef *level_out,
 516                            LLVMValueRef *out_of_bounds);
 517
 518 void
 519 lp_build_linear_mip_levels(struct lp_build_sample_context *bld,
 520                            unsigned texture_unit,
 521                            LLVMValueRef lod_ipart,
 522                            LLVMValueRef *lod_fpart_inout,
 523                            LLVMValueRef *level0_out,
 524                            LLVMValueRef *level1_out);
 525
 526 LLVMValueRef
 527 lp_build_get_mipmap_level(struct lp_build_sample_context *bld,
 528                           LLVMValueRef level);
 529
 530
 531 LLVMValueRef
 532 lp_build_get_mip_offsets(struct lp_build_sample_context *bld,
 533                          LLVMValueRef level);
 534
 535
 536 void
 537 lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld,
 538                             LLVMValueRef ilevel,
 539                             LLVMValueRef *out_size_vec,
 540                             LLVMValueRef *row_stride_vec,
 541                             LLVMValueRef *img_stride_vec);
 542
 543
 544 void
 545 lp_build_extract_image_sizes(struct lp_build_sample_context *bld,
 546                              struct lp_build_context *size_bld,
 547                              struct lp_type coord_type,
 548                              LLVMValueRef size,
 549                              LLVMValueRef *out_width,
 550                              LLVMValueRef *out_height,
 551                              LLVMValueRef *out_depth);
 552
 553
 554 void
 555 lp_build_unnormalized_coords(struct lp_build_sample_context *bld,
 556                              LLVMValueRef flt_size,
 557                              LLVMValueRef *s,
 558                              LLVMValueRef *t,
 559                              LLVMValueRef *r);
 560
 561
 562 void
 563 lp_build_cube_lookup(struct lp_build_sample_context *bld,
 564                      LLVMValueRef *coords,
 565                      const struct lp_derivatives *derivs_in, /* optional */
 566                      LLVMValueRef *rho,
 567                      struct lp_derivatives *derivs_out, /* optional */
 568                      boolean need_derivs);
 569
 570
 571 void
 572 lp_build_cube_new_coords(struct lp_build_context *ivec_bld,
 573                          LLVMValueRef face,
 574                          LLVMValueRef x0,
 575                          LLVMValueRef x1,
 576                          LLVMValueRef y0,
 577                          LLVMValueRef y1,
 578                          LLVMValueRef max_coord,
 579                          LLVMValueRef new_faces[4],
 580                          LLVMValueRef new_xcoords[4][2],
 581                          LLVMValueRef new_ycoords[4][2]);
 582
 583
 584 void
 585 lp_build_sample_partial_offset(struct lp_build_context *bld,
 586                                unsigned block_length,
 587                                LLVMValueRef coord,
 588                                LLVMValueRef stride,
 589                                LLVMValueRef *out_offset,
 590                                LLVMValueRef *out_i);
 591
 592
 593 void
 594 lp_build_sample_offset(struct lp_build_context *bld,
 595                        const struct util_format_description *format_desc,
 596                        LLVMValueRef x,
 597                        LLVMValueRef y,
 598                        LLVMValueRef z,
 599                        LLVMValueRef y_stride,
 600                        LLVMValueRef z_stride,
 601                        LLVMValueRef *out_offset,
 602                        LLVMValueRef *out_i,
 603                        LLVMValueRef *out_j);
 604
 605
 606 void
 607 lp_build_sample_soa(const struct lp_static_texture_state *static_texture_state,
 608                     const struct lp_static_sampler_state *static_sampler_state,
 609                     struct lp_sampler_dynamic_state *dynamic_texture_state,
 610                     struct gallivm_state *gallivm,
 611                     const struct lp_sampler_params *params);
 612
 613
 614 void
 615 lp_build_coord_repeat_npot_linear(struct lp_build_sample_context *bld,
 616                                   LLVMValueRef coord_f,
 617                                   LLVMValueRef length_i,
 618                                   LLVMValueRef length_f,
 619                                   LLVMValueRef *coord0_i,
 620                                   LLVMValueRef *weight_f);
 621
 622
 623 void
 624 lp_build_size_query_soa(struct gallivm_state *gallivm,
 625                         const struct lp_static_texture_state *static_state,
 626                         struct lp_sampler_dynamic_state *dynamic_state,
 627                         const struct lp_sampler_size_query_params *params);
 628
 629 void
 630 lp_build_sample_nop(struct gallivm_state *gallivm,
 631                     struct lp_type type,
 632                     const LLVMValueRef *coords,
 633                     LLVMValueRef texel_out[4]);
 634
 635
 636 LLVMValueRef
 637 lp_build_minify(struct lp_build_context *bld,
 638                 LLVMValueRef base_size,
 639                 LLVMValueRef level,
 640                 boolean lod_scalar);
 641
 642 #ifdef __cplusplus
 643 }
 644 #endif
 645
 646 #endif /* LP_BLD_SAMPLE_H */