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
46extern "C" {
47#endif
48
49struct pipe_resource;
50struct pipe_sampler_view;
51struct pipe_sampler_state;
52struct pipe_image_view;
53struct util_format_description;
54struct lp_type;
55struct lp_build_context;
56
57
58/**
59 * Helper struct holding all derivatives needed for sampling
60 */
61struct lp_derivatives
62{
63   LLVMValueRef ddx[3];
64   LLVMValueRef ddy[3];
65};
66
67
68enum lp_sampler_lod_property {
69   LP_SAMPLER_LOD_SCALAR,
70   LP_SAMPLER_LOD_PER_ELEMENT,
71   LP_SAMPLER_LOD_PER_QUAD
72};
73
74
75enum lp_sampler_lod_control {
76   LP_SAMPLER_LOD_IMPLICIT,
77   LP_SAMPLER_LOD_BIAS,
78   LP_SAMPLER_LOD_EXPLICIT,
79   LP_SAMPLER_LOD_DERIVATIVES,
80};
81
82
83enum lp_sampler_op_type {
84   LP_SAMPLER_OP_TEXTURE,
85   LP_SAMPLER_OP_FETCH,
86   LP_SAMPLER_OP_GATHER,
87   LP_SAMPLER_OP_LODQ
88};
89
90
91#define LP_SAMPLER_SHADOW             (1 << 0)
92#define LP_SAMPLER_OFFSETS            (1 << 1)
93#define LP_SAMPLER_OP_TYPE_SHIFT            2
94#define LP_SAMPLER_OP_TYPE_MASK       (3 << 2)
95#define LP_SAMPLER_LOD_CONTROL_SHIFT        4
96#define LP_SAMPLER_LOD_CONTROL_MASK   (3 << 4)
97#define LP_SAMPLER_LOD_PROPERTY_SHIFT       6
98#define LP_SAMPLER_LOD_PROPERTY_MASK  (3 << 6)
99#define LP_SAMPLER_GATHER_COMP_SHIFT        8
100#define LP_SAMPLER_GATHER_COMP_MASK   (3 << 8)
101#define LP_SAMPLER_FETCH_MS          (1 << 10)
102
103struct lp_sampler_params
104{
105   struct lp_type type;
106   unsigned texture_index;
107   unsigned sampler_index;
108   LLVMValueRef texture_index_offset;
109   unsigned sample_key;
110   LLVMValueRef context_ptr;
111   LLVMValueRef thread_data_ptr;
112   const LLVMValueRef *coords;
113   const LLVMValueRef *offsets;
114   LLVMValueRef ms_index;
115   LLVMValueRef lod;
116   LLVMValueRef aniso_filter_table;
117   const struct lp_derivatives *derivs;
118   LLVMValueRef *texel;
119};
120
121struct lp_sampler_size_query_params
122{
123   struct lp_type int_type;
124   unsigned texture_unit;
125   LLVMValueRef texture_unit_offset;
126   unsigned target;
127   LLVMValueRef context_ptr;
128   boolean is_sviewinfo;
129   bool samples_only;
130   enum lp_sampler_lod_property lod_property;
131   LLVMValueRef explicit_lod;
132   LLVMValueRef *sizes_out;
133};
134
135#define LP_IMG_LOAD 0
136#define LP_IMG_STORE 1
137#define LP_IMG_ATOMIC 2
138#define LP_IMG_ATOMIC_CAS 3
139
140struct lp_img_params
141{
142   struct lp_type type;
143   unsigned image_index;
144   LLVMValueRef image_index_offset;
145   unsigned img_op;
146   unsigned target;
147   LLVMAtomicRMWBinOp op;
148   LLVMValueRef exec_mask;
149   LLVMValueRef context_ptr;
150   LLVMValueRef thread_data_ptr;
151   const LLVMValueRef *coords;
152   LLVMValueRef ms_index;
153   LLVMValueRef indata[4];
154   LLVMValueRef indata2[4];
155   LLVMValueRef *outdata;
156};
157/**
158 * Texture static state.
159 *
160 * These are the bits of state from pipe_resource/pipe_sampler_view that
161 * are embedded in the generated code.
162 */
163struct lp_static_texture_state
164{
165   /* pipe_sampler_view's state */
166   enum pipe_format format;
167   unsigned swizzle_r:3;     /**< PIPE_SWIZZLE_* */
168   unsigned swizzle_g:3;
169   unsigned swizzle_b:3;
170   unsigned swizzle_a:3;
171
172   /* pipe_texture's state */
173   enum pipe_texture_target target:5;        /**< PIPE_TEXTURE_* */
174   unsigned pot_width:1;     /**< is the width a power of two? */
175   unsigned pot_height:1;
176   unsigned pot_depth:1;
177   unsigned level_zero_only:1;
178};
179
180
181/**
182 * Sampler static state.
183 *
184 * These are the bits of state from pipe_sampler_state that
185 * are embedded in the generated code.
186 */
187struct lp_static_sampler_state
188{
189   /* pipe_sampler_state's state */
190   unsigned wrap_s:3;
191   unsigned wrap_t:3;
192   unsigned wrap_r:3;
193   unsigned min_img_filter:2;
194   unsigned min_mip_filter:2;
195   unsigned mag_img_filter:2;
196   unsigned compare_mode:1;
197   unsigned compare_func:3;
198   unsigned normalized_coords:1;
199   unsigned min_max_lod_equal:1;  /**< min_lod == max_lod ? */
200   unsigned lod_bias_non_zero:1;
201   unsigned max_lod_pos:1;
202   unsigned apply_min_lod:1;  /**< min_lod > 0 ? */
203   unsigned apply_max_lod:1;  /**< max_lod < last_level ? */
204   unsigned seamless_cube_map:1;
205   unsigned aniso:1;
206   unsigned reduction_mode:2;
207};
208
209
210/**
211 * Sampler dynamic state.
212 *
213 * These are the bits of state from pipe_resource/pipe_sampler_view
214 * as well as from sampler state that are computed at runtime.
215 *
216 * There are obtained through callbacks, as we don't want to tie the texture
217 * sampling code generation logic to any particular texture layout or pipe
218 * driver.
219 */
220struct lp_sampler_dynamic_state
221{
222   /* First callbacks for sampler view state */
223
224   /** Obtain the base texture width (or number of elements) (returns int32) */
225   LLVMValueRef
226   (*width)(const struct lp_sampler_dynamic_state *state,
227            struct gallivm_state *gallivm,
228            LLVMValueRef context_ptr,
229            unsigned texture_unit, LLVMValueRef texture_unit_offset);
230
231   /** Obtain the base texture height (returns int32) */
232   LLVMValueRef
233   (*height)(const struct lp_sampler_dynamic_state *state,
234             struct gallivm_state *gallivm,
235             LLVMValueRef context_ptr,
236             unsigned texture_unit, LLVMValueRef texture_unit_offset);
237
238   /** Obtain the base texture depth (or array size) (returns int32) */
239   LLVMValueRef
240   (*depth)(const struct lp_sampler_dynamic_state *state,
241            struct gallivm_state *gallivm,
242            LLVMValueRef context_ptr,
243            unsigned texture_unit, LLVMValueRef texture_unit_offset);
244
245   /** Obtain the first mipmap level (base level) (returns int32) */
246   LLVMValueRef
247   (*first_level)(const struct lp_sampler_dynamic_state *state,
248                  struct gallivm_state *gallivm,
249                  LLVMValueRef context_ptr,
250                  unsigned texture_unit, LLVMValueRef texture_unit_offset);
251
252   /** Obtain the number of mipmap levels minus one (returns int32) */
253   LLVMValueRef
254   (*last_level)(const struct lp_sampler_dynamic_state *state,
255                 struct gallivm_state *gallivm,
256                 LLVMValueRef context_ptr,
257                 unsigned texture_unit, LLVMValueRef texture_unit_offset);
258
259   /** Obtain stride in bytes between image rows/blocks (returns int32) */
260   LLVMValueRef
261   (*row_stride)(const struct lp_sampler_dynamic_state *state,
262                 struct gallivm_state *gallivm,
263                 LLVMValueRef context_ptr,
264                 unsigned texture_unit, LLVMValueRef texture_unit_offset);
265
266   /** Obtain stride in bytes between image slices (returns int32) */
267   LLVMValueRef
268   (*img_stride)(const struct lp_sampler_dynamic_state *state,
269                 struct gallivm_state *gallivm,
270                 LLVMValueRef context_ptr,
271                 unsigned texture_unit, LLVMValueRef texture_unit_offset);
272
273   /** Obtain pointer to base of texture */
274   LLVMValueRef
275   (*base_ptr)(const struct lp_sampler_dynamic_state *state,
276               struct gallivm_state *gallivm,
277               LLVMValueRef context_ptr,
278               unsigned texture_unit, LLVMValueRef texture_unit_offset);
279
280   /** Obtain pointer to array of mipmap offsets */
281   LLVMValueRef
282   (*mip_offsets)(const struct lp_sampler_dynamic_state *state,
283                  struct gallivm_state *gallivm,
284                  LLVMValueRef context_ptr,
285                  unsigned texture_unit, LLVMValueRef texture_unit_offset);
286
287   /** Obtain number of samples (returns int32) */
288   LLVMValueRef
289   (*num_samples)(const struct lp_sampler_dynamic_state *state,
290                  struct gallivm_state *gallivm,
291                  LLVMValueRef context_ptr,
292                  unsigned texture_unit, LLVMValueRef texture_unit_offset);
293
294   /** Obtain multisample stride (returns int32) */
295   LLVMValueRef
296   (*sample_stride)(const struct lp_sampler_dynamic_state *state,
297                    struct gallivm_state *gallivm,
298                    LLVMValueRef context_ptr,
299                    unsigned texture_unit, LLVMValueRef texture_unit_offset);
300
301   /* These are callbacks for sampler state */
302
303   /** Obtain texture min lod (returns float) */
304   LLVMValueRef
305   (*min_lod)(const struct lp_sampler_dynamic_state *state,
306              struct gallivm_state *gallivm,
307              LLVMValueRef context_ptr,
308              unsigned sampler_unit);
309
310   /** Obtain texture max lod (returns float) */
311   LLVMValueRef
312   (*max_lod)(const struct lp_sampler_dynamic_state *state,
313              struct gallivm_state *gallivm,
314              LLVMValueRef context_ptr,
315              unsigned sampler_unit);
316
317   /** Obtain texture lod bias (returns float) */
318   LLVMValueRef
319   (*lod_bias)(const struct lp_sampler_dynamic_state *state,
320               struct gallivm_state *gallivm,
321               LLVMValueRef context_ptr,
322               unsigned sampler_unit);
323
324   /** Obtain texture border color (returns ptr to float[4]) */
325   LLVMValueRef
326   (*border_color)(const struct lp_sampler_dynamic_state *state,
327                   struct gallivm_state *gallivm,
328                   LLVMValueRef context_ptr,
329                   unsigned sampler_unit);
330
331   /** Obtain maximum anisotropy */
332   LLVMValueRef
333   (*max_aniso)(const struct lp_sampler_dynamic_state *state,
334                struct gallivm_state *gallivm,
335                LLVMValueRef context_ptr,
336                unsigned sampler_unit);
337
338   /**
339    * Obtain texture cache (returns ptr to lp_build_format_cache).
340    *
341    * It's optional: no caching will be done if it's NULL.
342    */
343   LLVMValueRef
344   (*cache_ptr)(const struct lp_sampler_dynamic_state *state,
345                struct gallivm_state *gallivm,
346                LLVMValueRef thread_data_ptr,
347                unsigned unit);
348};
349
350
351/**
352 * Keep all information for sampling code generation in a single place.
353 */
354struct lp_build_sample_context
355{
356   struct gallivm_state *gallivm;
357
358   const struct lp_static_texture_state *static_texture_state;
359   const struct lp_static_sampler_state *static_sampler_state;
360
361   struct lp_sampler_dynamic_state *dynamic_state;
362
363   const struct util_format_description *format_desc;
364
365   /* See texture_dims() */
366   unsigned dims;
367
368   /** SIMD vector width */
369   unsigned vector_width;
370
371   /** number of mipmaps (valid are 1, length/4, length) */
372   unsigned num_mips;
373
374   /** number of lod values (valid are 1, length/4, length) */
375   unsigned num_lods;
376
377   unsigned gather_comp;
378   boolean no_quad_lod;
379   boolean no_brilinear;
380   boolean no_rho_approx;
381   boolean fetch_ms;
382
383   /** regular scalar float type */
384   struct lp_type float_type;
385   struct lp_build_context float_bld;
386
387   /** float vector type */
388   struct lp_build_context float_vec_bld;
389
390   /** regular scalar int type */
391   struct lp_type int_type;
392   struct lp_build_context int_bld;
393
394   /** Incoming coordinates type and build context */
395   struct lp_type coord_type;
396   struct lp_build_context coord_bld;
397
398   /** Signed integer coordinates */
399   struct lp_type int_coord_type;
400   struct lp_build_context int_coord_bld;
401
402   /** Unsigned integer texture size */
403   struct lp_type int_size_in_type;
404   struct lp_build_context int_size_in_bld;
405
406   /** Float incoming texture size */
407   struct lp_type float_size_in_type;
408   struct lp_build_context float_size_in_bld;
409
410   /** Unsigned integer texture size (might be per quad) */
411   struct lp_type int_size_type;
412   struct lp_build_context int_size_bld;
413
414   /** Float texture size (might be per quad) */
415   struct lp_type float_size_type;
416   struct lp_build_context float_size_bld;
417
418   /** Output texels type and build context */
419   struct lp_type texel_type;
420   struct lp_build_context texel_bld;
421
422   /** Float level type */
423   struct lp_type levelf_type;
424   struct lp_build_context levelf_bld;
425
426   /** Int level type */
427   struct lp_type leveli_type;
428   struct lp_build_context leveli_bld;
429
430   /** Float lod type */
431   struct lp_type lodf_type;
432   struct lp_build_context lodf_bld;
433
434   /** Int lod type */
435   struct lp_type lodi_type;
436   struct lp_build_context lodi_bld;
437
438   /* Common dynamic state values */
439   LLVMValueRef row_stride_array;
440   LLVMValueRef img_stride_array;
441   LLVMValueRef base_ptr;
442   LLVMValueRef mip_offsets;
443   LLVMValueRef cache;
444   LLVMValueRef sample_stride;
445
446   /** Integer vector with texture width, height, depth */
447   LLVMValueRef int_size;
448
449   LLVMValueRef border_color_clamped;
450
451   LLVMValueRef context_ptr;
452
453   LLVMValueRef aniso_filter_table;
454};
455
456/*
457 * Indirect texture access context
458 *
459 * This is used to store info across building
460 * and indirect texture switch statement.
461 */
462struct lp_build_sample_array_switch {
463   struct gallivm_state *gallivm;
464   struct lp_sampler_params params;
465   unsigned base, range;
466   LLVMValueRef switch_ref;
467   LLVMBasicBlockRef merge_ref;
468   LLVMValueRef phi;
469};
470
471struct lp_build_img_op_array_switch {
472   struct gallivm_state *gallivm;
473   struct lp_img_params params;
474   unsigned base, range;
475   LLVMValueRef switch_ref;
476   LLVMBasicBlockRef merge_ref;
477   LLVMValueRef phi[4];
478};
479
480/**
481 * We only support a few wrap modes in lp_build_sample_wrap_linear_int() at
482 * this time.  Return whether the given mode is supported by that function.
483 */
484static inline boolean
485lp_is_simple_wrap_mode(unsigned mode)
486{
487   switch (mode) {
488   case PIPE_TEX_WRAP_REPEAT:
489   case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
490      return TRUE;
491   default:
492      return FALSE;
493   }
494}
495
496
497static inline void
498apply_sampler_swizzle(struct lp_build_sample_context *bld,
499                      LLVMValueRef *texel)
500{
501   unsigned char swizzles[4];
502
503   swizzles[0] = bld->static_texture_state->swizzle_r;
504   swizzles[1] = bld->static_texture_state->swizzle_g;
505   swizzles[2] = bld->static_texture_state->swizzle_b;
506   swizzles[3] = bld->static_texture_state->swizzle_a;
507
508   lp_build_swizzle_soa_inplace(&bld->texel_bld, texel, swizzles);
509}
510
511/*
512 * not really dimension as such, this indicates the amount of
513 * "normal" texture coords subject to minification, wrapping etc.
514 */
515static inline unsigned
516texture_dims(enum pipe_texture_target tex)
517{
518   switch (tex) {
519   case PIPE_TEXTURE_1D:
520   case PIPE_TEXTURE_1D_ARRAY:
521   case PIPE_BUFFER:
522      return 1;
523   case PIPE_TEXTURE_2D:
524   case PIPE_TEXTURE_2D_ARRAY:
525   case PIPE_TEXTURE_RECT:
526   case PIPE_TEXTURE_CUBE:
527   case PIPE_TEXTURE_CUBE_ARRAY:
528      return 2;
529   case PIPE_TEXTURE_3D:
530      return 3;
531   default:
532      assert(0 && "bad texture target in texture_dims()");
533      return 2;
534   }
535}
536
537static inline boolean
538has_layer_coord(enum pipe_texture_target tex)
539{
540   switch (tex) {
541   case PIPE_TEXTURE_1D_ARRAY:
542   case PIPE_TEXTURE_2D_ARRAY:
543   /* cube is not layered but 3rd coord (after cube mapping) behaves the same */
544   case PIPE_TEXTURE_CUBE:
545   case PIPE_TEXTURE_CUBE_ARRAY:
546      return TRUE;
547   default:
548      return FALSE;
549   }
550}
551
552
553boolean
554lp_sampler_wrap_mode_uses_border_color(unsigned mode,
555                                       unsigned min_img_filter,
556                                       unsigned mag_img_filter);
557
558/**
559 * Derive the sampler static state.
560 */
561void
562lp_sampler_static_sampler_state(struct lp_static_sampler_state *state,
563                                const struct pipe_sampler_state *sampler);
564
565
566void
567lp_sampler_static_texture_state(struct lp_static_texture_state *state,
568                                const struct pipe_sampler_view *view);
569
570void
571lp_sampler_static_texture_state_image(struct lp_static_texture_state *state,
572                                      const struct pipe_image_view *view);
573
574void
575lp_build_lod_selector(struct lp_build_sample_context *bld,
576                      boolean is_lodq,
577                      unsigned texture_index,
578                      unsigned sampler_index,
579                      LLVMValueRef s,
580                      LLVMValueRef t,
581                      LLVMValueRef r,
582                      LLVMValueRef cube_rho,
583                      const struct lp_derivatives *derivs,
584                      LLVMValueRef lod_bias, /* optional */
585                      LLVMValueRef explicit_lod, /* optional */
586                      unsigned mip_filter,
587                      LLVMValueRef max_aniso,
588                      LLVMValueRef *out_lod,
589                      LLVMValueRef *out_lod_ipart,
590                      LLVMValueRef *out_lod_fpart,
591                      LLVMValueRef *out_lod_positive);
592
593void
594lp_build_nearest_mip_level(struct lp_build_sample_context *bld,
595                           unsigned texture_unit,
596                           LLVMValueRef lod,
597                           LLVMValueRef *level_out,
598                           LLVMValueRef *out_of_bounds);
599
600void
601lp_build_linear_mip_levels(struct lp_build_sample_context *bld,
602                           unsigned texture_unit,
603                           LLVMValueRef lod_ipart,
604                           LLVMValueRef *lod_fpart_inout,
605                           LLVMValueRef *level0_out,
606                           LLVMValueRef *level1_out);
607
608LLVMValueRef
609lp_build_get_mipmap_level(struct lp_build_sample_context *bld,
610                          LLVMValueRef level);
611
612
613LLVMValueRef
614lp_build_get_mip_offsets(struct lp_build_sample_context *bld,
615                         LLVMValueRef level);
616
617
618void
619lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld,
620                            LLVMValueRef ilevel,
621                            LLVMValueRef *out_size_vec,
622                            LLVMValueRef *row_stride_vec,
623                            LLVMValueRef *img_stride_vec);
624
625
626void
627lp_build_extract_image_sizes(struct lp_build_sample_context *bld,
628                             struct lp_build_context *size_bld,
629                             struct lp_type coord_type,
630                             LLVMValueRef size,
631                             LLVMValueRef *out_width,
632                             LLVMValueRef *out_height,
633                             LLVMValueRef *out_depth);
634
635
636void
637lp_build_unnormalized_coords(struct lp_build_sample_context *bld,
638                             LLVMValueRef flt_size,
639                             LLVMValueRef *s,
640                             LLVMValueRef *t,
641                             LLVMValueRef *r);
642
643
644void
645lp_build_cube_lookup(struct lp_build_sample_context *bld,
646                     LLVMValueRef *coords,
647                     const struct lp_derivatives *derivs_in, /* optional */
648                     LLVMValueRef *rho,
649                     struct lp_derivatives *derivs_out, /* optional */
650                     boolean need_derivs);
651
652
653void
654lp_build_cube_new_coords(struct lp_build_context *ivec_bld,
655                         LLVMValueRef face,
656                         LLVMValueRef x0,
657                         LLVMValueRef x1,
658                         LLVMValueRef y0,
659                         LLVMValueRef y1,
660                         LLVMValueRef max_coord,
661                         LLVMValueRef new_faces[4],
662                         LLVMValueRef new_xcoords[4][2],
663                         LLVMValueRef new_ycoords[4][2]);
664
665
666void
667lp_build_sample_partial_offset(struct lp_build_context *bld,
668                               unsigned block_length,
669                               LLVMValueRef coord,
670                               LLVMValueRef stride,
671                               LLVMValueRef *out_offset,
672                               LLVMValueRef *out_i);
673
674
675void
676lp_build_sample_offset(struct lp_build_context *bld,
677                       const struct util_format_description *format_desc,
678                       LLVMValueRef x,
679                       LLVMValueRef y,
680                       LLVMValueRef z,
681                       LLVMValueRef y_stride,
682                       LLVMValueRef z_stride,
683                       LLVMValueRef *out_offset,
684                       LLVMValueRef *out_i,
685                       LLVMValueRef *out_j);
686
687
688void
689lp_build_sample_soa(const struct lp_static_texture_state *static_texture_state,
690                    const struct lp_static_sampler_state *static_sampler_state,
691                    struct lp_sampler_dynamic_state *dynamic_texture_state,
692                    struct gallivm_state *gallivm,
693                    const struct lp_sampler_params *params);
694
695
696void
697lp_build_coord_repeat_npot_linear(struct lp_build_sample_context *bld,
698                                  LLVMValueRef coord_f,
699                                  LLVMValueRef length_i,
700                                  LLVMValueRef length_f,
701                                  LLVMValueRef *coord0_i,
702                                  LLVMValueRef *weight_f);
703
704
705void
706lp_build_size_query_soa(struct gallivm_state *gallivm,
707                        const struct lp_static_texture_state *static_state,
708                        struct lp_sampler_dynamic_state *dynamic_state,
709                        const struct lp_sampler_size_query_params *params);
710
711void
712lp_build_sample_nop(struct gallivm_state *gallivm,
713                    struct lp_type type,
714                    const LLVMValueRef *coords,
715                    LLVMValueRef texel_out[4]);
716
717
718LLVMValueRef
719lp_build_minify(struct lp_build_context *bld,
720                LLVMValueRef base_size,
721                LLVMValueRef level,
722                boolean lod_scalar);
723
724void
725lp_build_img_op_soa(const struct lp_static_texture_state *static_texture_state,
726                    struct lp_sampler_dynamic_state *dynamic_state,
727                    struct gallivm_state *gallivm,
728                    const struct lp_img_params *params,
729                    LLVMValueRef outdata[4]);
730
731void
732lp_build_sample_array_init_soa(struct lp_build_sample_array_switch *switch_info,
733                           struct gallivm_state *gallivm,
734                           const struct lp_sampler_params *params,
735                           LLVMValueRef idx,
736                           unsigned base, unsigned range);
737
738void
739lp_build_sample_array_case_soa(struct lp_build_sample_array_switch *switch_info,
740                           int idx,
741                           const struct lp_static_texture_state *static_texture_state,
742                           const struct lp_static_sampler_state *static_sampler_state,
743                           struct lp_sampler_dynamic_state *dynamic_texture_state);
744
745void lp_build_sample_array_fini_soa(struct lp_build_sample_array_switch *switch_info);
746
747void
748lp_build_image_op_switch_soa(struct lp_build_img_op_array_switch *switch_info,
749                             struct gallivm_state *gallivm,
750                             const struct lp_img_params *params,
751                             LLVMValueRef idx,
752                             unsigned base, unsigned range);
753
754void
755lp_build_image_op_array_case(struct lp_build_img_op_array_switch *switch_info,
756			     int idx,
757			     const struct lp_static_texture_state *static_texture_state,
758			     struct lp_sampler_dynamic_state *dynamic_state);
759
760void lp_build_image_op_array_fini_soa(struct lp_build_img_op_array_switch *switch_info);
761
762void
763lp_build_reduce_filter(struct lp_build_context *bld,
764                       enum pipe_tex_reduction_mode mode,
765                       unsigned flags,
766                       unsigned num_chan,
767                       LLVMValueRef x,
768                       LLVMValueRef *v00,
769                       LLVMValueRef *v01,
770                       LLVMValueRef *out);
771void
772lp_build_reduce_filter_2d(struct lp_build_context *bld,
773                          enum pipe_tex_reduction_mode mode,
774                          unsigned flags,
775                          unsigned num_chan,
776                          LLVMValueRef x,
777                          LLVMValueRef y,
778                          LLVMValueRef *v00,
779                          LLVMValueRef *v01,
780                          LLVMValueRef *v10,
781                          LLVMValueRef *v11,
782                          LLVMValueRef *out);
783
784void
785lp_build_reduce_filter_3d(struct lp_build_context *bld,
786                          enum pipe_tex_reduction_mode mode,
787                          unsigned flags,
788                          unsigned num_chan,
789                          LLVMValueRef x,
790                          LLVMValueRef y,
791                          LLVMValueRef z,
792                          LLVMValueRef *v000,
793                          LLVMValueRef *v001,
794                          LLVMValueRef *v010,
795                          LLVMValueRef *v011,
796                          LLVMValueRef *v100,
797                          LLVMValueRef *v101,
798                          LLVMValueRef *v110,
799                          LLVMValueRef *v111,
800                          LLVMValueRef *out);
801
802const float *lp_build_sample_aniso_filter_table(void);
803#ifdef __cplusplus
804}
805#endif
806
807#endif /* LP_BLD_SAMPLE_H */
808