1 /**************************************************************************
2 *
3 * Copyright 2015 Advanced Micro Devices, Inc.
4 * Copyright 2008 VMware, Inc.
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * on the rights to use, copy, modify, merge, publish, distribute, sub
11 * license, and/or sell copies of the Software, and to permit persons to whom
12 * the Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "dd_pipe.h"
29 #include "tgsi/tgsi_parse.h"
30 #include "util/u_inlines.h"
31 #include "util/u_memory.h"
32
33
34 static void
safe_memcpy(void * dst,const void * src,size_t size)35 safe_memcpy(void *dst, const void *src, size_t size)
36 {
37 if (src)
38 memcpy(dst, src, size);
39 else
40 memset(dst, 0, size);
41 }
42
43
44 /********************************************************************
45 * queries
46 */
47
48 static struct pipe_query *
dd_context_create_query(struct pipe_context * _pipe,unsigned query_type,unsigned index)49 dd_context_create_query(struct pipe_context *_pipe, unsigned query_type,
50 unsigned index)
51 {
52 struct pipe_context *pipe = dd_context(_pipe)->pipe;
53 struct pipe_query *query;
54
55 query = pipe->create_query(pipe, query_type, index);
56
57 /* Wrap query object. */
58 if (query) {
59 struct dd_query *dd_query = CALLOC_STRUCT(dd_query);
60 if (dd_query) {
61 dd_query->type = query_type;
62 dd_query->query = query;
63 query = (struct pipe_query *)dd_query;
64 } else {
65 pipe->destroy_query(pipe, query);
66 query = NULL;
67 }
68 }
69
70 return query;
71 }
72
73 static struct pipe_query *
dd_context_create_batch_query(struct pipe_context * _pipe,unsigned num_queries,unsigned * query_types)74 dd_context_create_batch_query(struct pipe_context *_pipe, unsigned num_queries,
75 unsigned *query_types)
76 {
77 struct pipe_context *pipe = dd_context(_pipe)->pipe;
78 struct pipe_query *query;
79
80 query = pipe->create_batch_query(pipe, num_queries, query_types);
81
82 /* Wrap query object. */
83 if (query) {
84 struct dd_query *dd_query = CALLOC_STRUCT(dd_query);
85 if (dd_query) {
86 /* no special handling for batch queries yet */
87 dd_query->type = query_types[0];
88 dd_query->query = query;
89 query = (struct pipe_query *)dd_query;
90 } else {
91 pipe->destroy_query(pipe, query);
92 query = NULL;
93 }
94 }
95
96 return query;
97 }
98
99 static void
dd_context_destroy_query(struct pipe_context * _pipe,struct pipe_query * query)100 dd_context_destroy_query(struct pipe_context *_pipe,
101 struct pipe_query *query)
102 {
103 struct pipe_context *pipe = dd_context(_pipe)->pipe;
104
105 pipe->destroy_query(pipe, dd_query_unwrap(query));
106 FREE(query);
107 }
108
109 static bool
dd_context_begin_query(struct pipe_context * _pipe,struct pipe_query * query)110 dd_context_begin_query(struct pipe_context *_pipe, struct pipe_query *query)
111 {
112 struct dd_context *dctx = dd_context(_pipe);
113 struct pipe_context *pipe = dctx->pipe;
114
115 return pipe->begin_query(pipe, dd_query_unwrap(query));
116 }
117
118 static bool
dd_context_end_query(struct pipe_context * _pipe,struct pipe_query * query)119 dd_context_end_query(struct pipe_context *_pipe, struct pipe_query *query)
120 {
121 struct dd_context *dctx = dd_context(_pipe);
122 struct pipe_context *pipe = dctx->pipe;
123
124 return pipe->end_query(pipe, dd_query_unwrap(query));
125 }
126
127 static bool
dd_context_get_query_result(struct pipe_context * _pipe,struct pipe_query * query,bool wait,union pipe_query_result * result)128 dd_context_get_query_result(struct pipe_context *_pipe,
129 struct pipe_query *query, bool wait,
130 union pipe_query_result *result)
131 {
132 struct pipe_context *pipe = dd_context(_pipe)->pipe;
133
134 return pipe->get_query_result(pipe, dd_query_unwrap(query), wait, result);
135 }
136
137 static void
dd_context_set_active_query_state(struct pipe_context * _pipe,bool enable)138 dd_context_set_active_query_state(struct pipe_context *_pipe, bool enable)
139 {
140 struct pipe_context *pipe = dd_context(_pipe)->pipe;
141
142 pipe->set_active_query_state(pipe, enable);
143 }
144
145 static void
dd_context_render_condition(struct pipe_context * _pipe,struct pipe_query * query,bool condition,enum pipe_render_cond_flag mode)146 dd_context_render_condition(struct pipe_context *_pipe,
147 struct pipe_query *query, bool condition,
148 enum pipe_render_cond_flag mode)
149 {
150 struct dd_context *dctx = dd_context(_pipe);
151 struct pipe_context *pipe = dctx->pipe;
152 struct dd_draw_state *dstate = &dctx->draw_state;
153
154 pipe->render_condition(pipe, dd_query_unwrap(query), condition, mode);
155 dstate->render_cond.query = dd_query(query);
156 dstate->render_cond.condition = condition;
157 dstate->render_cond.mode = mode;
158 }
159
160
161 /********************************************************************
162 * constant (immutable) non-shader states
163 */
164
165 #define DD_CSO_CREATE(name, shortname) \
166 static void * \
167 dd_context_create_##name##_state(struct pipe_context *_pipe, \
168 const struct pipe_##name##_state *state) \
169 { \
170 struct pipe_context *pipe = dd_context(_pipe)->pipe; \
171 struct dd_state *hstate = CALLOC_STRUCT(dd_state); \
172 \
173 if (!hstate) \
174 return NULL; \
175 hstate->cso = pipe->create_##name##_state(pipe, state); \
176 hstate->state.shortname = *state; \
177 return hstate; \
178 }
179
180 #define DD_CSO_BIND(name, shortname) \
181 static void \
182 dd_context_bind_##name##_state(struct pipe_context *_pipe, void *state) \
183 { \
184 struct dd_context *dctx = dd_context(_pipe); \
185 struct pipe_context *pipe = dctx->pipe; \
186 struct dd_state *hstate = state; \
187 \
188 dctx->draw_state.shortname = hstate; \
189 pipe->bind_##name##_state(pipe, hstate ? hstate->cso : NULL); \
190 }
191
192 #define DD_CSO_DELETE(name) \
193 static void \
194 dd_context_delete_##name##_state(struct pipe_context *_pipe, void *state) \
195 { \
196 struct dd_context *dctx = dd_context(_pipe); \
197 struct pipe_context *pipe = dctx->pipe; \
198 struct dd_state *hstate = state; \
199 \
200 pipe->delete_##name##_state(pipe, hstate->cso); \
201 FREE(hstate); \
202 }
203
204 #define DD_CSO_WHOLE(name, shortname) \
205 DD_CSO_CREATE(name, shortname) \
206 DD_CSO_BIND(name, shortname) \
207 DD_CSO_DELETE(name)
208
DD_CSO_WHOLE(blend,blend)209 DD_CSO_WHOLE(blend, blend)
210 DD_CSO_WHOLE(rasterizer, rs)
211 DD_CSO_WHOLE(depth_stencil_alpha, dsa)
212
213 DD_CSO_CREATE(sampler, sampler)
214 DD_CSO_DELETE(sampler)
215
216 static void
217 dd_context_bind_sampler_states(struct pipe_context *_pipe,
218 enum pipe_shader_type shader,
219 unsigned start, unsigned count, void **states)
220 {
221 struct dd_context *dctx = dd_context(_pipe);
222 struct pipe_context *pipe = dctx->pipe;
223
224 memcpy(&dctx->draw_state.sampler_states[shader][start], states,
225 sizeof(void*) * count);
226
227 if (states) {
228 void *samp[PIPE_MAX_SAMPLERS];
229 int i;
230
231 for (i = 0; i < count; i++) {
232 struct dd_state *s = states[i];
233 samp[i] = s ? s->cso : NULL;
234 }
235
236 pipe->bind_sampler_states(pipe, shader, start, count, samp);
237 }
238 else
239 pipe->bind_sampler_states(pipe, shader, start, count, NULL);
240 }
241
242 static void *
dd_context_create_vertex_elements_state(struct pipe_context * _pipe,unsigned num_elems,const struct pipe_vertex_element * elems)243 dd_context_create_vertex_elements_state(struct pipe_context *_pipe,
244 unsigned num_elems,
245 const struct pipe_vertex_element *elems)
246 {
247 struct pipe_context *pipe = dd_context(_pipe)->pipe;
248 struct dd_state *hstate = CALLOC_STRUCT(dd_state);
249
250 if (!hstate)
251 return NULL;
252 hstate->cso = pipe->create_vertex_elements_state(pipe, num_elems, elems);
253 memcpy(hstate->state.velems.velems, elems, sizeof(elems[0]) * num_elems);
254 hstate->state.velems.count = num_elems;
255 return hstate;
256 }
257
DD_CSO_BIND(vertex_elements,velems)258 DD_CSO_BIND(vertex_elements, velems)
259 DD_CSO_DELETE(vertex_elements)
260
261
262 /********************************************************************
263 * shaders
264 */
265
266 #define DD_SHADER_NOCREATE(NAME, name) \
267 static void \
268 dd_context_bind_##name##_state(struct pipe_context *_pipe, void *state) \
269 { \
270 struct dd_context *dctx = dd_context(_pipe); \
271 struct pipe_context *pipe = dctx->pipe; \
272 struct dd_state *hstate = state; \
273 \
274 dctx->draw_state.shaders[PIPE_SHADER_##NAME] = hstate; \
275 pipe->bind_##name##_state(pipe, hstate ? hstate->cso : NULL); \
276 } \
277 \
278 static void \
279 dd_context_delete_##name##_state(struct pipe_context *_pipe, void *state) \
280 { \
281 struct dd_context *dctx = dd_context(_pipe); \
282 struct pipe_context *pipe = dctx->pipe; \
283 struct dd_state *hstate = state; \
284 \
285 pipe->delete_##name##_state(pipe, hstate->cso); \
286 if (hstate->state.shader.type == PIPE_SHADER_IR_TGSI) \
287 tgsi_free_tokens(hstate->state.shader.tokens); \
288 FREE(hstate); \
289 }
290
291 #define DD_SHADER(NAME, name) \
292 static void * \
293 dd_context_create_##name##_state(struct pipe_context *_pipe, \
294 const struct pipe_shader_state *state) \
295 { \
296 struct pipe_context *pipe = dd_context(_pipe)->pipe; \
297 struct dd_state *hstate = CALLOC_STRUCT(dd_state); \
298 \
299 if (!hstate) \
300 return NULL; \
301 hstate->cso = pipe->create_##name##_state(pipe, state); \
302 hstate->state.shader = *state; \
303 if (hstate->state.shader.type == PIPE_SHADER_IR_TGSI) \
304 hstate->state.shader.tokens = tgsi_dup_tokens(state->tokens); \
305 return hstate; \
306 } \
307 \
308 DD_SHADER_NOCREATE(NAME, name)
309
310 DD_SHADER(FRAGMENT, fs)
311 DD_SHADER(VERTEX, vs)
312 DD_SHADER(GEOMETRY, gs)
313 DD_SHADER(TESS_CTRL, tcs)
314 DD_SHADER(TESS_EVAL, tes)
315
316 static void * \
317 dd_context_create_compute_state(struct pipe_context *_pipe,
318 const struct pipe_compute_state *state)
319 {
320 struct pipe_context *pipe = dd_context(_pipe)->pipe;
321 struct dd_state *hstate = CALLOC_STRUCT(dd_state);
322
323 if (!hstate)
324 return NULL;
325 hstate->cso = pipe->create_compute_state(pipe, state);
326
327 hstate->state.shader.type = state->ir_type;
328
329 if (state->ir_type == PIPE_SHADER_IR_TGSI)
330 hstate->state.shader.tokens = tgsi_dup_tokens(state->prog);
331
332 return hstate;
333 }
334
DD_SHADER_NOCREATE(COMPUTE,compute)335 DD_SHADER_NOCREATE(COMPUTE, compute)
336
337 /********************************************************************
338 * immediate states
339 */
340
341 #define DD_IMM_STATE(name, type, deref, ref) \
342 static void \
343 dd_context_set_##name(struct pipe_context *_pipe, type deref) \
344 { \
345 struct dd_context *dctx = dd_context(_pipe); \
346 struct pipe_context *pipe = dctx->pipe; \
347 \
348 dctx->draw_state.name = deref; \
349 pipe->set_##name(pipe, ref); \
350 }
351
352 DD_IMM_STATE(blend_color, const struct pipe_blend_color, *state, state)
353 DD_IMM_STATE(stencil_ref, const struct pipe_stencil_ref, *state, state)
354 DD_IMM_STATE(clip_state, const struct pipe_clip_state, *state, state)
355 DD_IMM_STATE(sample_mask, unsigned, sample_mask, sample_mask)
356 DD_IMM_STATE(min_samples, unsigned, min_samples, min_samples)
357 DD_IMM_STATE(framebuffer_state, const struct pipe_framebuffer_state, *state, state)
358 DD_IMM_STATE(polygon_stipple, const struct pipe_poly_stipple, *state, state)
359
360 static void
361 dd_context_set_constant_buffer(struct pipe_context *_pipe,
362 enum pipe_shader_type shader, uint index,
363 const struct pipe_constant_buffer *constant_buffer)
364 {
365 struct dd_context *dctx = dd_context(_pipe);
366 struct pipe_context *pipe = dctx->pipe;
367
368 safe_memcpy(&dctx->draw_state.constant_buffers[shader][index],
369 constant_buffer, sizeof(*constant_buffer));
370 pipe->set_constant_buffer(pipe, shader, index, constant_buffer);
371 }
372
373 static void
dd_context_set_scissor_states(struct pipe_context * _pipe,unsigned start_slot,unsigned num_scissors,const struct pipe_scissor_state * states)374 dd_context_set_scissor_states(struct pipe_context *_pipe,
375 unsigned start_slot, unsigned num_scissors,
376 const struct pipe_scissor_state *states)
377 {
378 struct dd_context *dctx = dd_context(_pipe);
379 struct pipe_context *pipe = dctx->pipe;
380
381 safe_memcpy(&dctx->draw_state.scissors[start_slot], states,
382 sizeof(*states) * num_scissors);
383 pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
384 }
385
386 static void
dd_context_set_viewport_states(struct pipe_context * _pipe,unsigned start_slot,unsigned num_viewports,const struct pipe_viewport_state * states)387 dd_context_set_viewport_states(struct pipe_context *_pipe,
388 unsigned start_slot, unsigned num_viewports,
389 const struct pipe_viewport_state *states)
390 {
391 struct dd_context *dctx = dd_context(_pipe);
392 struct pipe_context *pipe = dctx->pipe;
393
394 safe_memcpy(&dctx->draw_state.viewports[start_slot], states,
395 sizeof(*states) * num_viewports);
396 pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
397 }
398
dd_context_set_tess_state(struct pipe_context * _pipe,const float default_outer_level[4],const float default_inner_level[2])399 static void dd_context_set_tess_state(struct pipe_context *_pipe,
400 const float default_outer_level[4],
401 const float default_inner_level[2])
402 {
403 struct dd_context *dctx = dd_context(_pipe);
404 struct pipe_context *pipe = dctx->pipe;
405
406 memcpy(dctx->draw_state.tess_default_levels, default_outer_level,
407 sizeof(float) * 4);
408 memcpy(dctx->draw_state.tess_default_levels+4, default_inner_level,
409 sizeof(float) * 2);
410 pipe->set_tess_state(pipe, default_outer_level, default_inner_level);
411 }
412
dd_context_set_window_rectangles(struct pipe_context * _pipe,bool include,unsigned num_rectangles,const struct pipe_scissor_state * rects)413 static void dd_context_set_window_rectangles(struct pipe_context *_pipe,
414 bool include,
415 unsigned num_rectangles,
416 const struct pipe_scissor_state *rects)
417 {
418 struct dd_context *dctx = dd_context(_pipe);
419 struct pipe_context *pipe = dctx->pipe;
420
421 pipe->set_window_rectangles(pipe, include, num_rectangles, rects);
422 }
423
424
425 /********************************************************************
426 * views
427 */
428
429 static struct pipe_surface *
dd_context_create_surface(struct pipe_context * _pipe,struct pipe_resource * resource,const struct pipe_surface * surf_tmpl)430 dd_context_create_surface(struct pipe_context *_pipe,
431 struct pipe_resource *resource,
432 const struct pipe_surface *surf_tmpl)
433 {
434 struct pipe_context *pipe = dd_context(_pipe)->pipe;
435 struct pipe_surface *view =
436 pipe->create_surface(pipe, resource, surf_tmpl);
437
438 if (!view)
439 return NULL;
440 view->context = _pipe;
441 return view;
442 }
443
444 static void
dd_context_surface_destroy(struct pipe_context * _pipe,struct pipe_surface * surf)445 dd_context_surface_destroy(struct pipe_context *_pipe,
446 struct pipe_surface *surf)
447 {
448 struct pipe_context *pipe = dd_context(_pipe)->pipe;
449
450 pipe->surface_destroy(pipe, surf);
451 }
452
453 static struct pipe_sampler_view *
dd_context_create_sampler_view(struct pipe_context * _pipe,struct pipe_resource * resource,const struct pipe_sampler_view * templ)454 dd_context_create_sampler_view(struct pipe_context *_pipe,
455 struct pipe_resource *resource,
456 const struct pipe_sampler_view *templ)
457 {
458 struct pipe_context *pipe = dd_context(_pipe)->pipe;
459 struct pipe_sampler_view *view =
460 pipe->create_sampler_view(pipe, resource, templ);
461
462 if (!view)
463 return NULL;
464 view->context = _pipe;
465 return view;
466 }
467
468 static void
dd_context_sampler_view_destroy(struct pipe_context * _pipe,struct pipe_sampler_view * view)469 dd_context_sampler_view_destroy(struct pipe_context *_pipe,
470 struct pipe_sampler_view *view)
471 {
472 struct pipe_context *pipe = dd_context(_pipe)->pipe;
473
474 pipe->sampler_view_destroy(pipe, view);
475 }
476
477 static struct pipe_stream_output_target *
dd_context_create_stream_output_target(struct pipe_context * _pipe,struct pipe_resource * res,unsigned buffer_offset,unsigned buffer_size)478 dd_context_create_stream_output_target(struct pipe_context *_pipe,
479 struct pipe_resource *res,
480 unsigned buffer_offset,
481 unsigned buffer_size)
482 {
483 struct pipe_context *pipe = dd_context(_pipe)->pipe;
484 struct pipe_stream_output_target *view =
485 pipe->create_stream_output_target(pipe, res, buffer_offset,
486 buffer_size);
487
488 if (!view)
489 return NULL;
490 view->context = _pipe;
491 return view;
492 }
493
494 static void
dd_context_stream_output_target_destroy(struct pipe_context * _pipe,struct pipe_stream_output_target * target)495 dd_context_stream_output_target_destroy(struct pipe_context *_pipe,
496 struct pipe_stream_output_target *target)
497 {
498 struct pipe_context *pipe = dd_context(_pipe)->pipe;
499
500 pipe->stream_output_target_destroy(pipe, target);
501 }
502
503
504 /********************************************************************
505 * set states
506 */
507
508 static void
dd_context_set_sampler_views(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num,struct pipe_sampler_view ** views)509 dd_context_set_sampler_views(struct pipe_context *_pipe,
510 enum pipe_shader_type shader,
511 unsigned start, unsigned num,
512 struct pipe_sampler_view **views)
513 {
514 struct dd_context *dctx = dd_context(_pipe);
515 struct pipe_context *pipe = dctx->pipe;
516
517 safe_memcpy(&dctx->draw_state.sampler_views[shader][start], views,
518 sizeof(views[0]) * num);
519 pipe->set_sampler_views(pipe, shader, start, num, views);
520 }
521
522 static void
dd_context_set_shader_images(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num,const struct pipe_image_view * views)523 dd_context_set_shader_images(struct pipe_context *_pipe,
524 enum pipe_shader_type shader,
525 unsigned start, unsigned num,
526 const struct pipe_image_view *views)
527 {
528 struct dd_context *dctx = dd_context(_pipe);
529 struct pipe_context *pipe = dctx->pipe;
530
531 safe_memcpy(&dctx->draw_state.shader_images[shader][start], views,
532 sizeof(views[0]) * num);
533 pipe->set_shader_images(pipe, shader, start, num, views);
534 }
535
536 static void
dd_context_set_shader_buffers(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num_buffers,const struct pipe_shader_buffer * buffers,unsigned writable_bitmask)537 dd_context_set_shader_buffers(struct pipe_context *_pipe,
538 enum pipe_shader_type shader,
539 unsigned start, unsigned num_buffers,
540 const struct pipe_shader_buffer *buffers,
541 unsigned writable_bitmask)
542 {
543 struct dd_context *dctx = dd_context(_pipe);
544 struct pipe_context *pipe = dctx->pipe;
545
546 safe_memcpy(&dctx->draw_state.shader_buffers[shader][start], buffers,
547 sizeof(buffers[0]) * num_buffers);
548 pipe->set_shader_buffers(pipe, shader, start, num_buffers, buffers,
549 writable_bitmask);
550 }
551
552 static void
dd_context_set_vertex_buffers(struct pipe_context * _pipe,unsigned start,unsigned num_buffers,const struct pipe_vertex_buffer * buffers)553 dd_context_set_vertex_buffers(struct pipe_context *_pipe,
554 unsigned start, unsigned num_buffers,
555 const struct pipe_vertex_buffer *buffers)
556 {
557 struct dd_context *dctx = dd_context(_pipe);
558 struct pipe_context *pipe = dctx->pipe;
559
560 safe_memcpy(&dctx->draw_state.vertex_buffers[start], buffers,
561 sizeof(buffers[0]) * num_buffers);
562 pipe->set_vertex_buffers(pipe, start, num_buffers, buffers);
563 }
564
565 static void
dd_context_set_stream_output_targets(struct pipe_context * _pipe,unsigned num_targets,struct pipe_stream_output_target ** tgs,const unsigned * offsets)566 dd_context_set_stream_output_targets(struct pipe_context *_pipe,
567 unsigned num_targets,
568 struct pipe_stream_output_target **tgs,
569 const unsigned *offsets)
570 {
571 struct dd_context *dctx = dd_context(_pipe);
572 struct pipe_context *pipe = dctx->pipe;
573 struct dd_draw_state *dstate = &dctx->draw_state;
574
575 dstate->num_so_targets = num_targets;
576 safe_memcpy(dstate->so_targets, tgs, sizeof(*tgs) * num_targets);
577 safe_memcpy(dstate->so_offsets, offsets, sizeof(*offsets) * num_targets);
578 pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
579 }
580
581
582 static void
dd_context_fence_server_sync(struct pipe_context * _pipe,struct pipe_fence_handle * fence)583 dd_context_fence_server_sync(struct pipe_context *_pipe,
584 struct pipe_fence_handle *fence)
585 {
586 struct dd_context *dctx = dd_context(_pipe);
587 struct pipe_context *pipe = dctx->pipe;
588
589 pipe->fence_server_sync(pipe, fence);
590 }
591
592
593 static void
dd_context_create_fence_fd(struct pipe_context * _pipe,struct pipe_fence_handle ** fence,int fd,enum pipe_fd_type type)594 dd_context_create_fence_fd(struct pipe_context *_pipe,
595 struct pipe_fence_handle **fence,
596 int fd,
597 enum pipe_fd_type type)
598 {
599 struct dd_context *dctx = dd_context(_pipe);
600 struct pipe_context *pipe = dctx->pipe;
601
602 pipe->create_fence_fd(pipe, fence, fd, type);
603 }
604
605
606 void
dd_thread_join(struct dd_context * dctx)607 dd_thread_join(struct dd_context *dctx)
608 {
609 mtx_lock(&dctx->mutex);
610 dctx->kill_thread = true;
611 cnd_signal(&dctx->cond);
612 mtx_unlock(&dctx->mutex);
613 thrd_join(dctx->thread, NULL);
614 }
615
616 static void
dd_context_destroy(struct pipe_context * _pipe)617 dd_context_destroy(struct pipe_context *_pipe)
618 {
619 struct dd_context *dctx = dd_context(_pipe);
620 struct pipe_context *pipe = dctx->pipe;
621
622 dd_thread_join(dctx);
623 mtx_destroy(&dctx->mutex);
624 cnd_destroy(&dctx->cond);
625
626 assert(list_is_empty(&dctx->records));
627
628 if (pipe->set_log_context) {
629 pipe->set_log_context(pipe, NULL);
630
631 if (dd_screen(dctx->base.screen)->dump_mode == DD_DUMP_ALL_CALLS) {
632 FILE *f = dd_get_file_stream(dd_screen(dctx->base.screen), 0);
633 if (f) {
634 fprintf(f, "Remainder of driver log:\n\n");
635 }
636
637 u_log_new_page_print(&dctx->log, f);
638 fclose(f);
639 }
640 }
641 u_log_context_destroy(&dctx->log);
642
643 pipe->destroy(pipe);
644 FREE(dctx);
645 }
646
647
648 /********************************************************************
649 * miscellaneous
650 */
651
652 static void
dd_context_texture_barrier(struct pipe_context * _pipe,unsigned flags)653 dd_context_texture_barrier(struct pipe_context *_pipe, unsigned flags)
654 {
655 struct pipe_context *pipe = dd_context(_pipe)->pipe;
656
657 pipe->texture_barrier(pipe, flags);
658 }
659
660 static void
dd_context_memory_barrier(struct pipe_context * _pipe,unsigned flags)661 dd_context_memory_barrier(struct pipe_context *_pipe, unsigned flags)
662 {
663 struct pipe_context *pipe = dd_context(_pipe)->pipe;
664
665 pipe->memory_barrier(pipe, flags);
666 }
667
668 static bool
dd_context_resource_commit(struct pipe_context * _pipe,struct pipe_resource * resource,unsigned level,struct pipe_box * box,bool commit)669 dd_context_resource_commit(struct pipe_context *_pipe,
670 struct pipe_resource *resource,
671 unsigned level, struct pipe_box *box, bool commit)
672 {
673 struct pipe_context *pipe = dd_context(_pipe)->pipe;
674
675 return pipe->resource_commit(pipe, resource, level, box, commit);
676 }
677
678 static void
dd_context_set_compute_resources(struct pipe_context * _pipe,unsigned start,unsigned count,struct pipe_surface ** resources)679 dd_context_set_compute_resources(struct pipe_context *_pipe,
680 unsigned start, unsigned count,
681 struct pipe_surface **resources)
682 {
683 struct pipe_context *pipe = dd_context(_pipe)->pipe;
684 pipe->set_compute_resources(pipe, start, count, resources);
685 }
686
687 static void
dd_context_set_global_binding(struct pipe_context * _pipe,unsigned first,unsigned count,struct pipe_resource ** resources,uint32_t ** handles)688 dd_context_set_global_binding(struct pipe_context *_pipe,
689 unsigned first, unsigned count,
690 struct pipe_resource **resources,
691 uint32_t **handles)
692 {
693 struct pipe_context *pipe = dd_context(_pipe)->pipe;
694 pipe->set_global_binding(pipe, first, count, resources, handles);
695 }
696
697 static void
dd_context_get_sample_position(struct pipe_context * _pipe,unsigned sample_count,unsigned sample_index,float * out_value)698 dd_context_get_sample_position(struct pipe_context *_pipe,
699 unsigned sample_count, unsigned sample_index,
700 float *out_value)
701 {
702 struct pipe_context *pipe = dd_context(_pipe)->pipe;
703
704 pipe->get_sample_position(pipe, sample_count, sample_index,
705 out_value);
706 }
707
708 static void
dd_context_invalidate_resource(struct pipe_context * _pipe,struct pipe_resource * resource)709 dd_context_invalidate_resource(struct pipe_context *_pipe,
710 struct pipe_resource *resource)
711 {
712 struct pipe_context *pipe = dd_context(_pipe)->pipe;
713
714 pipe->invalidate_resource(pipe, resource);
715 }
716
717 static enum pipe_reset_status
dd_context_get_device_reset_status(struct pipe_context * _pipe)718 dd_context_get_device_reset_status(struct pipe_context *_pipe)
719 {
720 struct pipe_context *pipe = dd_context(_pipe)->pipe;
721
722 return pipe->get_device_reset_status(pipe);
723 }
724
725 static void
dd_context_set_device_reset_callback(struct pipe_context * _pipe,const struct pipe_device_reset_callback * cb)726 dd_context_set_device_reset_callback(struct pipe_context *_pipe,
727 const struct pipe_device_reset_callback *cb)
728 {
729 struct pipe_context *pipe = dd_context(_pipe)->pipe;
730
731 pipe->set_device_reset_callback(pipe, cb);
732 }
733
734 static void
dd_context_emit_string_marker(struct pipe_context * _pipe,const char * string,int len)735 dd_context_emit_string_marker(struct pipe_context *_pipe,
736 const char *string, int len)
737 {
738 struct dd_context *dctx = dd_context(_pipe);
739 struct pipe_context *pipe = dctx->pipe;
740
741 pipe->emit_string_marker(pipe, string, len);
742 dd_parse_apitrace_marker(string, len, &dctx->draw_state.apitrace_call_number);
743 }
744
745 static void
dd_context_dump_debug_state(struct pipe_context * _pipe,FILE * stream,unsigned flags)746 dd_context_dump_debug_state(struct pipe_context *_pipe, FILE *stream,
747 unsigned flags)
748 {
749 struct pipe_context *pipe = dd_context(_pipe)->pipe;
750
751 pipe->dump_debug_state(pipe, stream, flags);
752 }
753
754 static uint64_t
dd_context_create_texture_handle(struct pipe_context * _pipe,struct pipe_sampler_view * view,const struct pipe_sampler_state * state)755 dd_context_create_texture_handle(struct pipe_context *_pipe,
756 struct pipe_sampler_view *view,
757 const struct pipe_sampler_state *state)
758 {
759 struct pipe_context *pipe = dd_context(_pipe)->pipe;
760
761 return pipe->create_texture_handle(pipe, view, state);
762 }
763
764 static void
dd_context_delete_texture_handle(struct pipe_context * _pipe,uint64_t handle)765 dd_context_delete_texture_handle(struct pipe_context *_pipe, uint64_t handle)
766 {
767 struct pipe_context *pipe = dd_context(_pipe)->pipe;
768
769 pipe->delete_texture_handle(pipe, handle);
770 }
771
772 static void
dd_context_make_texture_handle_resident(struct pipe_context * _pipe,uint64_t handle,bool resident)773 dd_context_make_texture_handle_resident(struct pipe_context *_pipe,
774 uint64_t handle, bool resident)
775 {
776 struct pipe_context *pipe = dd_context(_pipe)->pipe;
777
778 pipe->make_texture_handle_resident(pipe, handle, resident);
779 }
780
781 static uint64_t
dd_context_create_image_handle(struct pipe_context * _pipe,const struct pipe_image_view * image)782 dd_context_create_image_handle(struct pipe_context *_pipe,
783 const struct pipe_image_view *image)
784 {
785 struct pipe_context *pipe = dd_context(_pipe)->pipe;
786
787 return pipe->create_image_handle(pipe, image);
788 }
789
790 static void
dd_context_delete_image_handle(struct pipe_context * _pipe,uint64_t handle)791 dd_context_delete_image_handle(struct pipe_context *_pipe, uint64_t handle)
792 {
793 struct pipe_context *pipe = dd_context(_pipe)->pipe;
794
795 pipe->delete_image_handle(pipe, handle);
796 }
797
798 static void
dd_context_make_image_handle_resident(struct pipe_context * _pipe,uint64_t handle,unsigned access,bool resident)799 dd_context_make_image_handle_resident(struct pipe_context *_pipe,
800 uint64_t handle, unsigned access,
801 bool resident)
802 {
803 struct pipe_context *pipe = dd_context(_pipe)->pipe;
804
805 pipe->make_image_handle_resident(pipe, handle, access, resident);
806 }
807
808 static void
dd_context_set_context_param(struct pipe_context * _pipe,enum pipe_context_param param,unsigned value)809 dd_context_set_context_param(struct pipe_context *_pipe,
810 enum pipe_context_param param,
811 unsigned value)
812 {
813 struct pipe_context *pipe = dd_context(_pipe)->pipe;
814
815 pipe->set_context_param(pipe, param, value);
816 }
817
818 struct pipe_context *
dd_context_create(struct dd_screen * dscreen,struct pipe_context * pipe)819 dd_context_create(struct dd_screen *dscreen, struct pipe_context *pipe)
820 {
821 struct dd_context *dctx;
822
823 if (!pipe)
824 return NULL;
825
826 dctx = CALLOC_STRUCT(dd_context);
827 if (!dctx)
828 goto fail;
829
830 dctx->pipe = pipe;
831 dctx->base.priv = pipe->priv; /* expose wrapped priv data */
832 dctx->base.screen = &dscreen->base;
833 dctx->base.stream_uploader = pipe->stream_uploader;
834 dctx->base.const_uploader = pipe->const_uploader;
835
836 dctx->base.destroy = dd_context_destroy;
837
838 CTX_INIT(render_condition);
839 CTX_INIT(create_query);
840 CTX_INIT(create_batch_query);
841 CTX_INIT(destroy_query);
842 CTX_INIT(begin_query);
843 CTX_INIT(end_query);
844 CTX_INIT(get_query_result);
845 CTX_INIT(set_active_query_state);
846 CTX_INIT(create_blend_state);
847 CTX_INIT(bind_blend_state);
848 CTX_INIT(delete_blend_state);
849 CTX_INIT(create_sampler_state);
850 CTX_INIT(bind_sampler_states);
851 CTX_INIT(delete_sampler_state);
852 CTX_INIT(create_rasterizer_state);
853 CTX_INIT(bind_rasterizer_state);
854 CTX_INIT(delete_rasterizer_state);
855 CTX_INIT(create_depth_stencil_alpha_state);
856 CTX_INIT(bind_depth_stencil_alpha_state);
857 CTX_INIT(delete_depth_stencil_alpha_state);
858 CTX_INIT(create_fs_state);
859 CTX_INIT(bind_fs_state);
860 CTX_INIT(delete_fs_state);
861 CTX_INIT(create_vs_state);
862 CTX_INIT(bind_vs_state);
863 CTX_INIT(delete_vs_state);
864 CTX_INIT(create_gs_state);
865 CTX_INIT(bind_gs_state);
866 CTX_INIT(delete_gs_state);
867 CTX_INIT(create_tcs_state);
868 CTX_INIT(bind_tcs_state);
869 CTX_INIT(delete_tcs_state);
870 CTX_INIT(create_tes_state);
871 CTX_INIT(bind_tes_state);
872 CTX_INIT(delete_tes_state);
873 CTX_INIT(create_compute_state);
874 CTX_INIT(bind_compute_state);
875 CTX_INIT(delete_compute_state);
876 CTX_INIT(create_vertex_elements_state);
877 CTX_INIT(bind_vertex_elements_state);
878 CTX_INIT(delete_vertex_elements_state);
879 CTX_INIT(set_blend_color);
880 CTX_INIT(set_stencil_ref);
881 CTX_INIT(set_sample_mask);
882 CTX_INIT(set_min_samples);
883 CTX_INIT(set_clip_state);
884 CTX_INIT(set_constant_buffer);
885 CTX_INIT(set_framebuffer_state);
886 CTX_INIT(set_polygon_stipple);
887 CTX_INIT(set_scissor_states);
888 CTX_INIT(set_viewport_states);
889 CTX_INIT(set_sampler_views);
890 CTX_INIT(set_tess_state);
891 CTX_INIT(set_shader_buffers);
892 CTX_INIT(set_shader_images);
893 CTX_INIT(set_vertex_buffers);
894 CTX_INIT(set_window_rectangles);
895 CTX_INIT(create_stream_output_target);
896 CTX_INIT(stream_output_target_destroy);
897 CTX_INIT(set_stream_output_targets);
898 CTX_INIT(create_fence_fd);
899 CTX_INIT(fence_server_sync);
900 CTX_INIT(create_sampler_view);
901 CTX_INIT(sampler_view_destroy);
902 CTX_INIT(create_surface);
903 CTX_INIT(surface_destroy);
904 CTX_INIT(texture_barrier);
905 CTX_INIT(memory_barrier);
906 CTX_INIT(resource_commit);
907 CTX_INIT(set_compute_resources);
908 CTX_INIT(set_global_binding);
909 /* create_video_codec */
910 /* create_video_buffer */
911 CTX_INIT(get_sample_position);
912 CTX_INIT(invalidate_resource);
913 CTX_INIT(get_device_reset_status);
914 CTX_INIT(set_device_reset_callback);
915 CTX_INIT(dump_debug_state);
916 CTX_INIT(emit_string_marker);
917 CTX_INIT(create_texture_handle);
918 CTX_INIT(delete_texture_handle);
919 CTX_INIT(make_texture_handle_resident);
920 CTX_INIT(create_image_handle);
921 CTX_INIT(delete_image_handle);
922 CTX_INIT(make_image_handle_resident);
923 CTX_INIT(set_context_param);
924
925 dd_init_draw_functions(dctx);
926
927 u_log_context_init(&dctx->log);
928 if (pipe->set_log_context)
929 pipe->set_log_context(pipe, &dctx->log);
930
931 dctx->draw_state.sample_mask = ~0;
932
933 list_inithead(&dctx->records);
934 (void) mtx_init(&dctx->mutex, mtx_plain);
935 (void) cnd_init(&dctx->cond);
936 dctx->thread = u_thread_create(dd_thread_main, dctx);
937 if (!dctx->thread) {
938 mtx_destroy(&dctx->mutex);
939 goto fail;
940 }
941
942 return &dctx->base;
943
944 fail:
945 FREE(dctx);
946 pipe->destroy(pipe);
947 return NULL;
948 }
949