• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**************************************************************************
2  *
3  * Copyright 2007 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 #ifndef PIPE_CONTEXT_H
29 #define PIPE_CONTEXT_H
30 
31 #include "p_compiler.h"
32 #include "p_format.h"
33 #include "p_video_enums.h"
34 #include "p_defines.h"
35 #include <stdio.h>
36 
37 #ifdef __cplusplus
38 extern "C" {
39 #endif
40 
41 
42 struct pipe_blend_color;
43 struct pipe_blend_state;
44 struct pipe_blit_info;
45 struct pipe_box;
46 struct pipe_clip_state;
47 struct pipe_constant_buffer;
48 struct pipe_debug_callback;
49 struct pipe_depth_stencil_alpha_state;
50 struct pipe_device_reset_callback;
51 struct pipe_draw_info;
52 struct pipe_draw_start_count;
53 struct pipe_grid_info;
54 struct pipe_fence_handle;
55 struct pipe_framebuffer_state;
56 struct pipe_image_view;
57 struct pipe_query;
58 struct pipe_poly_stipple;
59 struct pipe_rasterizer_state;
60 struct pipe_resolve_info;
61 struct pipe_resource;
62 struct pipe_sampler_state;
63 struct pipe_sampler_view;
64 struct pipe_scissor_state;
65 struct pipe_shader_buffer;
66 struct pipe_shader_state;
67 struct pipe_stencil_ref;
68 struct pipe_stream_output_target;
69 struct pipe_surface;
70 struct pipe_transfer;
71 struct pipe_vertex_buffer;
72 struct pipe_vertex_element;
73 struct pipe_video_buffer;
74 struct pipe_video_codec;
75 struct pipe_viewport_state;
76 struct pipe_compute_state;
77 union pipe_color_union;
78 union pipe_query_result;
79 struct u_log_context;
80 struct u_upload_mgr;
81 
82 /**
83  * Gallium rendering context.  Basically:
84  *  - state setting functions
85  *  - VBO drawing functions
86  *  - surface functions
87  */
88 struct pipe_context {
89    struct pipe_screen *screen;
90 
91    void *priv;  /**< context private data (for DRI for example) */
92    void *draw;  /**< private, for draw module (temporary?) */
93 
94    /**
95     * Stream uploaders created by the driver. All drivers, gallium frontends, and
96     * modules should use them.
97     *
98     * Use u_upload_alloc or u_upload_data as many times as you want.
99     * Once you are done, use u_upload_unmap.
100     */
101    struct u_upload_mgr *stream_uploader; /* everything but shader constants */
102    struct u_upload_mgr *const_uploader;  /* shader constants only */
103 
104    void (*destroy)( struct pipe_context * );
105 
106    /**
107     * VBO drawing
108     */
109    /*@{*/
110    void (*draw_vbo)( struct pipe_context *pipe,
111                      const struct pipe_draw_info *info );
112 
113    /**
114     * Direct multi draw specifying "start" and "count" for each draw.
115     *
116     * For indirect multi draws, use draw_vbo, which supports them through
117     * "info->indirect".
118     *
119     * Differences against draw_vbo:
120     * - "start" and "count" are taken from "draws", not "info"
121     * - "info->has_user_indices" is always false
122     * - "info->indirect" and "info->count_from_stream_output" are always NULL
123     *
124     * Differences against glMultiDraw:
125     * - "info->draw_id" is 0 and should be 0 for every draw
126     *   (we could make this configurable)
127     * - "info->index_bias" is always constant due to hardware performance
128     *   concerns (this is very important) and the lack of apps using
129     *   glMultiDrawElementsBaseVertex.
130     *
131     * The main use case is to optimize applications that submit many
132     * back-to-back draws or when mesa/main or st/mesa eliminates redundant
133     * state changes, resulting in back-to-back draws in the driver. It requires
134     * DrawID = 0 for every draw. u_threaded_context is the module that converts
135     * back-to-back draws into a multi draw. It's done trivially by looking
136     * ahead within a gallium command buffer and collapsing draws.
137     *
138     * \param pipe          context
139     * \param info          draw info
140     * \param draws         array of (start, count) pairs
141     * \param num_draws     number of draws
142     */
143    void (*multi_draw)(struct pipe_context *pipe,
144                       const struct pipe_draw_info *info,
145                       const struct pipe_draw_start_count *draws,
146                       unsigned num_draws);
147    /*@}*/
148 
149    /**
150     * Predicate subsequent rendering on occlusion query result
151     * \param query  the query predicate, or NULL if no predicate
152     * \param condition whether to skip on FALSE or TRUE query results
153     * \param mode  one of PIPE_RENDER_COND_x
154     */
155    void (*render_condition)( struct pipe_context *pipe,
156                              struct pipe_query *query,
157                              bool condition,
158                              enum pipe_render_cond_flag mode );
159 
160    /**
161     * Query objects
162     */
163    /*@{*/
164    struct pipe_query *(*create_query)( struct pipe_context *pipe,
165                                        unsigned query_type,
166                                        unsigned index );
167 
168    /**
169     * Create a query object that queries all given query types simultaneously.
170     *
171     * This can only be used for those query types for which
172     * get_driver_query_info indicates that it must be used. Only one batch
173     * query object may be active at a time.
174     *
175     * There may be additional constraints on which query types can be used
176     * together, in particular those that are implied by
177     * get_driver_query_group_info.
178     *
179     * \param num_queries the number of query types
180     * \param query_types array of \p num_queries query types
181     * \return a query object, or NULL on error.
182     */
183    struct pipe_query *(*create_batch_query)( struct pipe_context *pipe,
184                                              unsigned num_queries,
185                                              unsigned *query_types );
186 
187    void (*destroy_query)(struct pipe_context *pipe,
188                          struct pipe_query *q);
189 
190    bool (*begin_query)(struct pipe_context *pipe, struct pipe_query *q);
191    bool (*end_query)(struct pipe_context *pipe, struct pipe_query *q);
192 
193    /**
194     * Get results of a query.
195     * \param wait  if true, this query will block until the result is ready
196     * \return TRUE if results are ready, FALSE otherwise
197     */
198    bool (*get_query_result)(struct pipe_context *pipe,
199                             struct pipe_query *q,
200                             bool wait,
201                             union pipe_query_result *result);
202 
203    /**
204     * Get results of a query, storing into resource. Note that this may not
205     * be used with batch queries.
206     *
207     * \param wait  if true, this query will block until the result is ready
208     * \param result_type  the type of the value being stored:
209     * \param index  for queries that return multiple pieces of data, which
210     *               item of that data to store (e.g. for
211     *               PIPE_QUERY_PIPELINE_STATISTICS).
212     *               When the index is -1, instead of the value of the query
213     *               the driver should instead write a 1 or 0 to the appropriate
214     *               location with 1 meaning that the query result is available.
215     */
216    void (*get_query_result_resource)(struct pipe_context *pipe,
217                                      struct pipe_query *q,
218                                      bool wait,
219                                      enum pipe_query_value_type result_type,
220                                      int index,
221                                      struct pipe_resource *resource,
222                                      unsigned offset);
223 
224    /**
225     * Set whether all current non-driver queries except TIME_ELAPSED are
226     * active or paused.
227     */
228    void (*set_active_query_state)(struct pipe_context *pipe, bool enable);
229 
230    /**
231     * INTEL Performance Query
232     */
233    /*@{*/
234 
235    unsigned (*init_intel_perf_query_info)(struct pipe_context *pipe);
236 
237    void (*get_intel_perf_query_info)(struct pipe_context *pipe,
238                                      unsigned query_index,
239                                      const char **name,
240                                      uint32_t *data_size,
241                                      uint32_t *n_counters,
242                                      uint32_t *n_active);
243 
244    void (*get_intel_perf_query_counter_info)(struct pipe_context *pipe,
245                                              unsigned query_index,
246                                              unsigned counter_index,
247                                              const char **name,
248                                              const char **desc,
249                                              uint32_t *offset,
250                                              uint32_t *data_size,
251                                              uint32_t *type_enum,
252                                              uint32_t *data_type_enum,
253                                              uint64_t *raw_max);
254 
255    struct pipe_query *(*new_intel_perf_query_obj)(struct pipe_context *pipe,
256                                                  unsigned query_index);
257 
258    bool (*begin_intel_perf_query)(struct pipe_context *pipe, struct pipe_query *q);
259 
260    void (*end_intel_perf_query)(struct pipe_context *pipe, struct pipe_query *q);
261 
262    void (*delete_intel_perf_query)(struct pipe_context *pipe, struct pipe_query *q);
263 
264    void (*wait_intel_perf_query)(struct pipe_context *pipe, struct pipe_query *q);
265 
266    bool (*is_intel_perf_query_ready)(struct pipe_context *pipe, struct pipe_query *q);
267 
268    void (*get_intel_perf_query_data)(struct pipe_context *pipe,
269                                      struct pipe_query *q,
270                                      size_t data_size,
271                                      uint32_t *data,
272                                      uint32_t *bytes_written);
273 
274    /*@}*/
275 
276    /**
277     * State functions (create/bind/destroy state objects)
278     */
279    /*@{*/
280    void * (*create_blend_state)(struct pipe_context *,
281                                 const struct pipe_blend_state *);
282    void   (*bind_blend_state)(struct pipe_context *, void *);
283    void   (*delete_blend_state)(struct pipe_context *, void  *);
284 
285    void * (*create_sampler_state)(struct pipe_context *,
286                                   const struct pipe_sampler_state *);
287    void   (*bind_sampler_states)(struct pipe_context *,
288                                  enum pipe_shader_type shader,
289                                  unsigned start_slot, unsigned num_samplers,
290                                  void **samplers);
291    void   (*delete_sampler_state)(struct pipe_context *, void *);
292 
293    void * (*create_rasterizer_state)(struct pipe_context *,
294                                      const struct pipe_rasterizer_state *);
295    void   (*bind_rasterizer_state)(struct pipe_context *, void *);
296    void   (*delete_rasterizer_state)(struct pipe_context *, void *);
297 
298    void * (*create_depth_stencil_alpha_state)(struct pipe_context *,
299                                         const struct pipe_depth_stencil_alpha_state *);
300    void   (*bind_depth_stencil_alpha_state)(struct pipe_context *, void *);
301    void   (*delete_depth_stencil_alpha_state)(struct pipe_context *, void *);
302 
303    void * (*create_fs_state)(struct pipe_context *,
304                              const struct pipe_shader_state *);
305    void   (*bind_fs_state)(struct pipe_context *, void *);
306    void   (*delete_fs_state)(struct pipe_context *, void *);
307 
308    void * (*create_vs_state)(struct pipe_context *,
309                              const struct pipe_shader_state *);
310    void   (*bind_vs_state)(struct pipe_context *, void *);
311    void   (*delete_vs_state)(struct pipe_context *, void *);
312 
313    void * (*create_gs_state)(struct pipe_context *,
314                              const struct pipe_shader_state *);
315    void   (*bind_gs_state)(struct pipe_context *, void *);
316    void   (*delete_gs_state)(struct pipe_context *, void *);
317 
318    void * (*create_tcs_state)(struct pipe_context *,
319                               const struct pipe_shader_state *);
320    void   (*bind_tcs_state)(struct pipe_context *, void *);
321    void   (*delete_tcs_state)(struct pipe_context *, void *);
322 
323    void * (*create_tes_state)(struct pipe_context *,
324                               const struct pipe_shader_state *);
325    void   (*bind_tes_state)(struct pipe_context *, void *);
326    void   (*delete_tes_state)(struct pipe_context *, void *);
327 
328    void * (*create_vertex_elements_state)(struct pipe_context *,
329                                           unsigned num_elements,
330                                           const struct pipe_vertex_element *);
331    void   (*bind_vertex_elements_state)(struct pipe_context *, void *);
332    void   (*delete_vertex_elements_state)(struct pipe_context *, void *);
333 
334    /*@}*/
335 
336    /**
337     * Parameter-like state (or properties)
338     */
339    /*@{*/
340    void (*set_blend_color)( struct pipe_context *,
341                             const struct pipe_blend_color * );
342 
343    void (*set_stencil_ref)( struct pipe_context *,
344                             const struct pipe_stencil_ref * );
345 
346    void (*set_sample_mask)( struct pipe_context *,
347                             unsigned sample_mask );
348 
349    void (*set_min_samples)( struct pipe_context *,
350                             unsigned min_samples );
351 
352    void (*set_clip_state)( struct pipe_context *,
353                             const struct pipe_clip_state * );
354 
355    void (*set_constant_buffer)( struct pipe_context *,
356                                 enum pipe_shader_type shader, uint index,
357                                 const struct pipe_constant_buffer *buf );
358 
359    /**
360     * Set inlinable constants for constant buffer 0.
361     *
362     * These are constants that the driver would like to inline in the IR
363     * of the current shader and recompile it. Drivers can determine which
364     * constants they prefer to inline in finalize_nir and store that
365     * information in shader_info::*inlinable_uniform*. When the state tracker
366     * or frontend uploads constants to a constant buffer, it can pass
367     * inlinable constants separately via this call.
368     *
369     * Any set_constant_buffer call invalidates this state, so this function
370     * must be called after it. Binding a shader also invalidates this state.
371     *
372     * There is no PIPE_CAP for this. Drivers shouldn't set the shader_info
373     * fields if they don't want this or if they don't implement this.
374     */
375    void (*set_inlinable_constants)( struct pipe_context *,
376                                     enum pipe_shader_type shader,
377                                     uint num_values, uint32_t *values );
378 
379    void (*set_framebuffer_state)( struct pipe_context *,
380                                   const struct pipe_framebuffer_state * );
381 
382    /**
383     * Set the sample locations used during rasterization. When NULL or sized
384     * zero, the default locations are used.
385     *
386     * Note that get_sample_position() still returns the default locations.
387     *
388     * The samples are accessed with
389     * locations[(pixel_y*grid_w+pixel_x)*ms+i],
390     * where:
391     * ms      = the sample count
392     * grid_w  = the pixel grid width for the sample count
393     * grid_w  = the pixel grid height for the sample count
394     * pixel_x = the window x coordinate modulo grid_w
395     * pixel_y = the window y coordinate modulo grid_w
396     * i       = the sample index
397     * This gives a result with the x coordinate as the low 4 bits and the y
398     * coordinate as the high 4 bits. For each coordinate 0 is the left or top
399     * edge of the pixel's rectangle and 16 (not 15) is the right or bottom edge.
400     *
401     * Out of bounds accesses are return undefined values.
402     *
403     * The pixel grid is used to vary sample locations across pixels and its
404     * size can be queried with get_sample_pixel_grid().
405     */
406    void (*set_sample_locations)( struct pipe_context *,
407                                  size_t size, const uint8_t *locations );
408 
409    void (*set_polygon_stipple)( struct pipe_context *,
410                                 const struct pipe_poly_stipple * );
411 
412    void (*set_scissor_states)( struct pipe_context *,
413                                unsigned start_slot,
414                                unsigned num_scissors,
415                                const struct pipe_scissor_state * );
416 
417    void (*set_window_rectangles)( struct pipe_context *,
418                                   bool include,
419                                   unsigned num_rectangles,
420                                   const struct pipe_scissor_state * );
421 
422    void (*set_viewport_states)( struct pipe_context *,
423                                 unsigned start_slot,
424                                 unsigned num_viewports,
425                                 const struct pipe_viewport_state *);
426 
427    void (*set_sampler_views)(struct pipe_context *,
428                              enum pipe_shader_type shader,
429                              unsigned start_slot, unsigned num_views,
430                              struct pipe_sampler_view **views);
431 
432    void (*set_tess_state)(struct pipe_context *,
433                           const float default_outer_level[4],
434                           const float default_inner_level[2]);
435 
436    /**
437     * Sets the debug callback. If the pointer is null, then no callback is
438     * set, otherwise a copy of the data should be made.
439     */
440    void (*set_debug_callback)(struct pipe_context *,
441                               const struct pipe_debug_callback *);
442 
443    /**
444     * Bind an array of shader buffers that will be used by a shader.
445     * Any buffers that were previously bound to the specified range
446     * will be unbound.
447     *
448     * \param shader     selects shader stage
449     * \param start_slot first buffer slot to bind.
450     * \param count      number of consecutive buffers to bind.
451     * \param buffers    array of pointers to the buffers to bind, it
452     *                   should contain at least \a count elements
453     *                   unless it's NULL, in which case no buffers will
454     *                   be bound.
455     * \param writable_bitmask  If bit i is not set, buffers[i] will only be
456     *                          used with loads. If unsure, set to ~0.
457     */
458    void (*set_shader_buffers)(struct pipe_context *,
459                               enum pipe_shader_type shader,
460                               unsigned start_slot, unsigned count,
461                               const struct pipe_shader_buffer *buffers,
462                               unsigned writable_bitmask);
463 
464    /**
465     * Bind an array of hw atomic buffers for use by all shaders.
466     * And buffers that were previously bound to the specified range
467     * will be unbound.
468     *
469     * \param start_slot first buffer slot to bind.
470     * \param count      number of consecutive buffers to bind.
471     * \param buffers    array of pointers to the buffers to bind, it
472     *                   should contain at least \a count elements
473     *                   unless it's NULL, in which case no buffers will
474     *                   be bound.
475     */
476    void (*set_hw_atomic_buffers)(struct pipe_context *,
477                                  unsigned start_slot, unsigned count,
478                                  const struct pipe_shader_buffer *buffers);
479 
480    /**
481     * Bind an array of images that will be used by a shader.
482     * Any images that were previously bound to the specified range
483     * will be unbound.
484     *
485     * \param shader     selects shader stage
486     * \param start_slot first image slot to bind.
487     * \param count      number of consecutive images to bind.
488     * \param buffers    array of the images to bind, it
489     *                   should contain at least \a count elements
490     *                   unless it's NULL, in which case no images will
491     *                   be bound.
492     */
493    void (*set_shader_images)(struct pipe_context *,
494                              enum pipe_shader_type shader,
495                              unsigned start_slot, unsigned count,
496                              const struct pipe_image_view *images);
497 
498    void (*set_vertex_buffers)( struct pipe_context *,
499                                unsigned start_slot,
500                                unsigned num_buffers,
501                                const struct pipe_vertex_buffer * );
502 
503    /*@}*/
504 
505    /**
506     * Stream output functions.
507     */
508    /*@{*/
509 
510    struct pipe_stream_output_target *(*create_stream_output_target)(
511                         struct pipe_context *,
512                         struct pipe_resource *,
513                         unsigned buffer_offset,
514                         unsigned buffer_size);
515 
516    void (*stream_output_target_destroy)(struct pipe_context *,
517                                         struct pipe_stream_output_target *);
518 
519    void (*set_stream_output_targets)(struct pipe_context *,
520                               unsigned num_targets,
521                               struct pipe_stream_output_target **targets,
522                               const unsigned *offsets);
523 
524    /*@}*/
525 
526 
527    /**
528     * INTEL_blackhole_render
529     */
530    /*@{*/
531 
532    void (*set_frontend_noop)(struct pipe_context *,
533                              bool enable);
534 
535    /*@}*/
536 
537 
538    /**
539     * Resource functions for blit-like functionality
540     *
541     * If a driver supports multisampling, blit must implement color resolve.
542     */
543    /*@{*/
544 
545    /**
546     * Copy a block of pixels from one resource to another.
547     * The resource must be of the same format.
548     * Resources with nr_samples > 1 are not allowed.
549     */
550    void (*resource_copy_region)(struct pipe_context *pipe,
551                                 struct pipe_resource *dst,
552                                 unsigned dst_level,
553                                 unsigned dstx, unsigned dsty, unsigned dstz,
554                                 struct pipe_resource *src,
555                                 unsigned src_level,
556                                 const struct pipe_box *src_box);
557 
558    /* Optimal hardware path for blitting pixels.
559     * Scaling, format conversion, up- and downsampling (resolve) are allowed.
560     */
561    void (*blit)(struct pipe_context *pipe,
562                 const struct pipe_blit_info *info);
563 
564    /*@}*/
565 
566    /**
567     * Clear the specified set of currently bound buffers to specified values.
568     * The entire buffers are cleared (no scissor, no colormask, etc).
569     *
570     * \param buffers  bitfield of PIPE_CLEAR_* values.
571     * \param scissor_state  the scissored region to clear
572     * \param color  pointer to a union of fiu array for each of r, g, b, a.
573     * \param depth  depth clear value in [0,1].
574     * \param stencil  stencil clear value
575     */
576    void (*clear)(struct pipe_context *pipe,
577                  unsigned buffers,
578                  const struct pipe_scissor_state *scissor_state,
579                  const union pipe_color_union *color,
580                  double depth,
581                  unsigned stencil);
582 
583    /**
584     * Clear a color rendertarget surface.
585     * \param color  pointer to an union of fiu array for each of r, g, b, a.
586     */
587    void (*clear_render_target)(struct pipe_context *pipe,
588                                struct pipe_surface *dst,
589                                const union pipe_color_union *color,
590                                unsigned dstx, unsigned dsty,
591                                unsigned width, unsigned height,
592                                bool render_condition_enabled);
593 
594    /**
595     * Clear a depth-stencil surface.
596     * \param clear_flags  bitfield of PIPE_CLEAR_DEPTH/STENCIL values.
597     * \param depth  depth clear value in [0,1].
598     * \param stencil  stencil clear value
599     */
600    void (*clear_depth_stencil)(struct pipe_context *pipe,
601                                struct pipe_surface *dst,
602                                unsigned clear_flags,
603                                double depth,
604                                unsigned stencil,
605                                unsigned dstx, unsigned dsty,
606                                unsigned width, unsigned height,
607                                bool render_condition_enabled);
608 
609    /**
610     * Clear the texture with the specified texel. Not guaranteed to be a
611     * renderable format. Data provided in the resource's format.
612     */
613    void (*clear_texture)(struct pipe_context *pipe,
614                          struct pipe_resource *res,
615                          unsigned level,
616                          const struct pipe_box *box,
617                          const void *data);
618 
619    /**
620     * Clear a buffer. Runs a memset over the specified region with the element
621     * value passed in through clear_value of size clear_value_size.
622     */
623    void (*clear_buffer)(struct pipe_context *pipe,
624                         struct pipe_resource *res,
625                         unsigned offset,
626                         unsigned size,
627                         const void *clear_value,
628                         int clear_value_size);
629 
630    /**
631     * If a depth buffer is rendered with different sample location state than
632     * what is current at the time of reading, the values may differ because
633     * depth buffer compression can depend the sample locations.
634     *
635     * This function is a hint to decompress the current depth buffer to avoid
636     * such problems.
637     */
638    void (*evaluate_depth_buffer)(struct pipe_context *pipe);
639 
640    /**
641     * Flush draw commands.
642     *
643     * This guarantees that the new fence (if any) will finish in finite time,
644     * unless PIPE_FLUSH_DEFERRED is used.
645     *
646     * Subsequent operations on other contexts of the same screen are guaranteed
647     * to execute after the flushed commands, unless PIPE_FLUSH_ASYNC is used.
648     *
649     * NOTE: use screen->fence_reference() (or equivalent) to transfer
650     * new fence ref to **fence, to ensure that previous fence is unref'd
651     *
652     * \param fence  if not NULL, an old fence to unref and transfer a
653     *    new fence reference to
654     * \param flags  bitfield of enum pipe_flush_flags values.
655     */
656    void (*flush)(struct pipe_context *pipe,
657                  struct pipe_fence_handle **fence,
658                  unsigned flags);
659 
660    /**
661     * Create a fence from a fd.
662     *
663     * This is used for importing a foreign/external fence fd.
664     *
665     * \param fence  if not NULL, an old fence to unref and transfer a
666     *    new fence reference to
667     * \param fd     fd representing the fence object
668     * \param type   indicates which fence types backs fd
669     */
670    void (*create_fence_fd)(struct pipe_context *pipe,
671                            struct pipe_fence_handle **fence,
672                            int fd,
673                            enum pipe_fd_type type);
674 
675    /**
676     * Insert commands to have GPU wait for fence to be signaled.
677     */
678    void (*fence_server_sync)(struct pipe_context *pipe,
679                              struct pipe_fence_handle *fence);
680 
681    /**
682     * Insert commands to have the GPU signal a fence.
683     */
684    void (*fence_server_signal)(struct pipe_context *pipe,
685                                struct pipe_fence_handle *fence);
686 
687    /**
688     * Create a view on a texture to be used by a shader stage.
689     */
690    struct pipe_sampler_view * (*create_sampler_view)(struct pipe_context *ctx,
691                                                      struct pipe_resource *texture,
692                                                      const struct pipe_sampler_view *templat);
693 
694    /**
695     * Destroy a view on a texture.
696     *
697     * \param ctx the current context
698     * \param view the view to be destroyed
699     *
700     * \note The current context may not be the context in which the view was
701     *       created (view->context). However, the caller must guarantee that
702     *       the context which created the view is still alive.
703     */
704    void (*sampler_view_destroy)(struct pipe_context *ctx,
705                                 struct pipe_sampler_view *view);
706 
707 
708    /**
709     * Get a surface which is a "view" into a resource, used by
710     * render target / depth stencil stages.
711     */
712    struct pipe_surface *(*create_surface)(struct pipe_context *ctx,
713                                           struct pipe_resource *resource,
714                                           const struct pipe_surface *templat);
715 
716    void (*surface_destroy)(struct pipe_context *ctx,
717                            struct pipe_surface *);
718 
719 
720    /**
721     * Map a resource.
722     *
723     * Transfers are (by default) context-private and allow uploads to be
724     * interleaved with rendering.
725     *
726     * out_transfer will contain the transfer object that must be passed
727     * to all the other transfer functions. It also contains useful
728     * information (like texture strides).
729     */
730    void *(*transfer_map)(struct pipe_context *,
731                          struct pipe_resource *resource,
732                          unsigned level,
733                          unsigned usage,  /* a combination of PIPE_MAP_x */
734                          const struct pipe_box *,
735                          struct pipe_transfer **out_transfer);
736 
737    /* If transfer was created with WRITE|FLUSH_EXPLICIT, only the
738     * regions specified with this call are guaranteed to be written to
739     * the resource.
740     */
741    void (*transfer_flush_region)( struct pipe_context *,
742 				  struct pipe_transfer *transfer,
743 				  const struct pipe_box *);
744 
745    void (*transfer_unmap)(struct pipe_context *,
746                           struct pipe_transfer *transfer);
747 
748    /* One-shot transfer operation with data supplied in a user
749     * pointer.
750     */
751    void (*buffer_subdata)(struct pipe_context *,
752                           struct pipe_resource *,
753                           unsigned usage, /* a combination of PIPE_MAP_x */
754                           unsigned offset,
755                           unsigned size,
756                           const void *data);
757 
758    void (*texture_subdata)(struct pipe_context *,
759                            struct pipe_resource *,
760                            unsigned level,
761                            unsigned usage, /* a combination of PIPE_MAP_x */
762                            const struct pipe_box *,
763                            const void *data,
764                            unsigned stride,
765                            unsigned layer_stride);
766 
767    /**
768     * Flush any pending framebuffer writes and invalidate texture caches.
769     */
770    void (*texture_barrier)(struct pipe_context *, unsigned flags);
771 
772    /**
773     * Flush caches according to flags.
774     */
775    void (*memory_barrier)(struct pipe_context *, unsigned flags);
776 
777    /**
778     * Change the commitment status of a part of the given resource, which must
779     * have been created with the PIPE_RESOURCE_FLAG_SPARSE bit.
780     *
781     * \param level The texture level whose commitment should be changed.
782     * \param box The region of the resource whose commitment should be changed.
783     * \param commit Whether memory should be committed or un-committed.
784     *
785     * \return false if out of memory, true on success.
786     */
787    bool (*resource_commit)(struct pipe_context *, struct pipe_resource *,
788                            unsigned level, struct pipe_box *box, bool commit);
789 
790    /**
791     * Creates a video codec for a specific video format/profile
792     */
793    struct pipe_video_codec *(*create_video_codec)( struct pipe_context *context,
794                                                    const struct pipe_video_codec *templat );
795 
796    /**
797     * Creates a video buffer as decoding target
798     */
799    struct pipe_video_buffer *(*create_video_buffer)( struct pipe_context *context,
800                                                      const struct pipe_video_buffer *templat );
801 
802    /**
803     * Compute kernel execution
804     */
805    /*@{*/
806    /**
807     * Define the compute program and parameters to be used by
808     * pipe_context::launch_grid.
809     */
810    void *(*create_compute_state)(struct pipe_context *context,
811 				 const struct pipe_compute_state *);
812    void (*bind_compute_state)(struct pipe_context *, void *);
813    void (*delete_compute_state)(struct pipe_context *, void *);
814 
815    /**
816     * Bind an array of shader resources that will be used by the
817     * compute program.  Any resources that were previously bound to
818     * the specified range will be unbound after this call.
819     *
820     * \param start      first resource to bind.
821     * \param count      number of consecutive resources to bind.
822     * \param resources  array of pointers to the resources to bind, it
823     *                   should contain at least \a count elements
824     *                   unless it's NULL, in which case no new
825     *                   resources will be bound.
826     */
827    void (*set_compute_resources)(struct pipe_context *,
828                                  unsigned start, unsigned count,
829                                  struct pipe_surface **resources);
830 
831    /**
832     * Bind an array of buffers to be mapped into the address space of
833     * the GLOBAL resource.  Any buffers that were previously bound
834     * between [first, first + count - 1] are unbound after this call.
835     *
836     * \param first      first buffer to map.
837     * \param count      number of consecutive buffers to map.
838     * \param resources  array of pointers to the buffers to map, it
839     *                   should contain at least \a count elements
840     *                   unless it's NULL, in which case no new
841     *                   resources will be bound.
842     * \param handles    array of pointers to the memory locations that
843     *                   will be updated with the address each buffer
844     *                   will be mapped to.  The base memory address of
845     *                   each of the buffers will be added to the value
846     *                   pointed to by its corresponding handle to form
847     *                   the final address argument.  It should contain
848     *                   at least \a count elements, unless \a
849     *                   resources is NULL in which case \a handles
850     *                   should be NULL as well.
851     *
852     * Note that the driver isn't required to make any guarantees about
853     * the contents of the \a handles array being valid anytime except
854     * during the subsequent calls to pipe_context::launch_grid.  This
855     * means that the only sensible location handles[i] may point to is
856     * somewhere within the INPUT buffer itself.  This is so to
857     * accommodate implementations that lack virtual memory but
858     * nevertheless migrate buffers on the fly, leading to resource
859     * base addresses that change on each kernel invocation or are
860     * unknown to the pipe driver.
861     */
862    void (*set_global_binding)(struct pipe_context *context,
863                               unsigned first, unsigned count,
864                               struct pipe_resource **resources,
865                               uint32_t **handles);
866 
867    /**
868     * Launch the compute kernel starting from instruction \a pc of the
869     * currently bound compute program.
870     */
871    void (*launch_grid)(struct pipe_context *context,
872                        const struct pipe_grid_info *info);
873    /*@}*/
874 
875    /**
876     * Get the default sample position for an individual sample point.
877     *
878     * \param sample_count - total number of samples
879     * \param sample_index - sample to get the position values for
880     * \param out_value - return value of 2 floats for x and y position for
881     *                    requested sample.
882     */
883    void (*get_sample_position)(struct pipe_context *context,
884                                unsigned sample_count,
885                                unsigned sample_index,
886                                float *out_value);
887 
888    /**
889     * Query a timestamp in nanoseconds.  This is completely equivalent to
890     * pipe_screen::get_timestamp() but takes a context handle for drivers
891     * that require a context.
892     */
893    uint64_t (*get_timestamp)(struct pipe_context *);
894 
895    /**
896     * Flush the resource cache, so that the resource can be used
897     * by an external client. Possible usage:
898     * - flushing a resource before presenting it on the screen
899     * - flushing a resource if some other process or device wants to use it
900     * This shouldn't be used to flush caches if the resource is only managed
901     * by a single pipe_screen and is not shared with another process.
902     * (i.e. you shouldn't use it to flush caches explicitly if you want to e.g.
903     * use the resource for texturing)
904     */
905    void (*flush_resource)(struct pipe_context *ctx,
906                           struct pipe_resource *resource);
907 
908    /**
909     * Invalidate the contents of the resource. This is used to
910     *
911     * (1) implement EGL's semantic of undefined depth/stencil
912     * contents after a swapbuffers.  This allows a tiled renderer (for
913     * example) to not store the depth buffer.
914     *
915     * (2) implement GL's InvalidateBufferData. For backwards compatibility,
916     * you must only rely on the usability for this purpose when
917     * PIPE_CAP_INVALIDATE_BUFFER is enabled.
918     */
919    void (*invalidate_resource)(struct pipe_context *ctx,
920                                struct pipe_resource *resource);
921 
922    /**
923     * Return information about unexpected device resets.
924     */
925    enum pipe_reset_status (*get_device_reset_status)(struct pipe_context *ctx);
926 
927    /**
928     * Sets the reset status callback. If the pointer is null, then no callback
929     * is set, otherwise a copy of the data should be made.
930     */
931    void (*set_device_reset_callback)(struct pipe_context *ctx,
932                                      const struct pipe_device_reset_callback *cb);
933 
934    /**
935     * Dump driver-specific debug information into a stream. This is
936     * used by debugging tools.
937     *
938     * \param ctx        pipe context
939     * \param stream     where the output should be written to
940     * \param flags      a mask of PIPE_DUMP_* flags
941     */
942    void (*dump_debug_state)(struct pipe_context *ctx, FILE *stream,
943                             unsigned flags);
944 
945    /**
946     * Set the log context to which the driver should write internal debug logs
947     * (internal states, command streams).
948     *
949     * The caller must ensure that the log context is destroyed and reset to
950     * NULL before the pipe context is destroyed, and that log context functions
951     * are only called from the driver thread.
952     *
953     * \param ctx pipe context
954     * \param log logging context
955     */
956    void (*set_log_context)(struct pipe_context *ctx, struct u_log_context *log);
957 
958    /**
959     * Emit string marker in cmdstream
960     */
961    void (*emit_string_marker)(struct pipe_context *ctx,
962                               const char *string,
963                               int len);
964 
965    /**
966     * Generate mipmap.
967     * \return TRUE if mipmap generation succeeds, FALSE otherwise
968     */
969    bool (*generate_mipmap)(struct pipe_context *ctx,
970                            struct pipe_resource *resource,
971                            enum pipe_format format,
972                            unsigned base_level,
973                            unsigned last_level,
974                            unsigned first_layer,
975                            unsigned last_layer);
976 
977    /**
978     * Create a 64-bit texture handle.
979     *
980     * \param ctx        pipe context
981     * \param view       pipe sampler view object
982     * \param state      pipe sampler state template
983     * \return           a 64-bit texture handle if success, 0 otherwise
984     */
985    uint64_t (*create_texture_handle)(struct pipe_context *ctx,
986                                      struct pipe_sampler_view *view,
987                                      const struct pipe_sampler_state *state);
988 
989    /**
990     * Delete a texture handle.
991     *
992     * \param ctx        pipe context
993     * \param handle     64-bit texture handle
994     */
995    void (*delete_texture_handle)(struct pipe_context *ctx, uint64_t handle);
996 
997    /**
998     * Make a texture handle resident.
999     *
1000     * \param ctx        pipe context
1001     * \param handle     64-bit texture handle
1002     * \param resident   TRUE for resident, FALSE otherwise
1003     */
1004    void (*make_texture_handle_resident)(struct pipe_context *ctx,
1005                                         uint64_t handle, bool resident);
1006 
1007    /**
1008     * Create a 64-bit image handle.
1009     *
1010     * \param ctx        pipe context
1011     * \param image      pipe image view template
1012     * \return           a 64-bit image handle if success, 0 otherwise
1013     */
1014    uint64_t (*create_image_handle)(struct pipe_context *ctx,
1015                                    const struct pipe_image_view *image);
1016 
1017    /**
1018     * Delete an image handle.
1019     *
1020     * \param ctx        pipe context
1021     * \param handle     64-bit image handle
1022     */
1023    void (*delete_image_handle)(struct pipe_context *ctx, uint64_t handle);
1024 
1025    /**
1026     * Make an image handle resident.
1027     *
1028     * \param ctx        pipe context
1029     * \param handle     64-bit image handle
1030     * \param access     GL_READ_ONLY, GL_WRITE_ONLY or GL_READ_WRITE
1031     * \param resident   TRUE for resident, FALSE otherwise
1032     */
1033    void (*make_image_handle_resident)(struct pipe_context *ctx, uint64_t handle,
1034                                       unsigned access, bool resident);
1035 
1036    /**
1037     * Call the given function from the driver thread.
1038     *
1039     * This is set by threaded contexts for use by debugging wrappers.
1040     *
1041     * \param asap if true, run the callback immediately if there are no pending
1042     *             commands to be processed by the driver thread
1043     */
1044    void (*callback)(struct pipe_context *ctx, void (*fn)(void *), void *data,
1045                     bool asap);
1046 
1047    /**
1048     * Set a context parameter See enum pipe_context_param for more details.
1049     */
1050    void (*set_context_param)(struct pipe_context *ctx,
1051                              enum pipe_context_param param,
1052                              unsigned value);
1053 };
1054 
1055 
1056 #ifdef __cplusplus
1057 }
1058 #endif
1059 
1060 #endif /* PIPE_CONTEXT_H */
1061