15efeccf87970cbf71d9b900e58f3d3c929eba30
[mesa.git] / src / gallium / auxiliary / driver_ddebug / dd_context.c
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
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 *
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 *
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
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 boolean
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
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 boolean
128 dd_context_get_query_result(struct pipe_context *_pipe,
129 struct pipe_query *query, boolean 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
138 dd_context_set_active_query_state(struct pipe_context *_pipe, boolean 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
146 dd_context_render_condition(struct pipe_context *_pipe,
147 struct pipe_query *query, boolean 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
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 *
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
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
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
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
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
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
413 static void dd_context_set_window_rectangles(struct pipe_context *_pipe,
414 boolean 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 *
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
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 *
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
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 *
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
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
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
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
537 dd_context_set_shader_buffers(struct pipe_context *_pipe, unsigned shader,
538 unsigned start, unsigned num_buffers,
539 const struct pipe_shader_buffer *buffers)
540 {
541 struct dd_context *dctx = dd_context(_pipe);
542 struct pipe_context *pipe = dctx->pipe;
543
544 safe_memcpy(&dctx->draw_state.shader_buffers[shader][start], buffers,
545 sizeof(buffers[0]) * num_buffers);
546 pipe->set_shader_buffers(pipe, shader, start, num_buffers, buffers);
547 }
548
549 static void
550 dd_context_set_vertex_buffers(struct pipe_context *_pipe,
551 unsigned start, unsigned num_buffers,
552 const struct pipe_vertex_buffer *buffers)
553 {
554 struct dd_context *dctx = dd_context(_pipe);
555 struct pipe_context *pipe = dctx->pipe;
556
557 safe_memcpy(&dctx->draw_state.vertex_buffers[start], buffers,
558 sizeof(buffers[0]) * num_buffers);
559 pipe->set_vertex_buffers(pipe, start, num_buffers, buffers);
560 }
561
562 static void
563 dd_context_set_stream_output_targets(struct pipe_context *_pipe,
564 unsigned num_targets,
565 struct pipe_stream_output_target **tgs,
566 const unsigned *offsets)
567 {
568 struct dd_context *dctx = dd_context(_pipe);
569 struct pipe_context *pipe = dctx->pipe;
570 struct dd_draw_state *dstate = &dctx->draw_state;
571
572 dstate->num_so_targets = num_targets;
573 safe_memcpy(dstate->so_targets, tgs, sizeof(*tgs) * num_targets);
574 safe_memcpy(dstate->so_offsets, offsets, sizeof(*offsets) * num_targets);
575 pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
576 }
577
578 void
579 dd_thread_join(struct dd_context *dctx)
580 {
581 mtx_lock(&dctx->mutex);
582 dctx->kill_thread = true;
583 cnd_signal(&dctx->cond);
584 mtx_unlock(&dctx->mutex);
585 thrd_join(dctx->thread, NULL);
586 }
587
588 static void
589 dd_context_destroy(struct pipe_context *_pipe)
590 {
591 struct dd_context *dctx = dd_context(_pipe);
592 struct pipe_context *pipe = dctx->pipe;
593
594 dd_thread_join(dctx);
595 mtx_destroy(&dctx->mutex);
596 cnd_destroy(&dctx->cond);
597
598 assert(list_empty(&dctx->records));
599
600 if (pipe->set_log_context) {
601 pipe->set_log_context(pipe, NULL);
602
603 if (dd_screen(dctx->base.screen)->dump_mode == DD_DUMP_ALL_CALLS) {
604 FILE *f = dd_get_file_stream(dd_screen(dctx->base.screen), 0);
605 if (f) {
606 fprintf(f, "Remainder of driver log:\n\n");
607 }
608
609 u_log_new_page_print(&dctx->log, f);
610 fclose(f);
611 }
612 }
613 u_log_context_destroy(&dctx->log);
614
615 pipe->destroy(pipe);
616 FREE(dctx);
617 }
618
619
620 /********************************************************************
621 * miscellaneous
622 */
623
624 static void
625 dd_context_texture_barrier(struct pipe_context *_pipe, unsigned flags)
626 {
627 struct pipe_context *pipe = dd_context(_pipe)->pipe;
628
629 pipe->texture_barrier(pipe, flags);
630 }
631
632 static void
633 dd_context_memory_barrier(struct pipe_context *_pipe, unsigned flags)
634 {
635 struct pipe_context *pipe = dd_context(_pipe)->pipe;
636
637 pipe->memory_barrier(pipe, flags);
638 }
639
640 static bool
641 dd_context_resource_commit(struct pipe_context *_pipe,
642 struct pipe_resource *resource,
643 unsigned level, struct pipe_box *box, bool commit)
644 {
645 struct pipe_context *pipe = dd_context(_pipe)->pipe;
646
647 return pipe->resource_commit(pipe, resource, level, box, commit);
648 }
649
650 static void
651 dd_context_get_sample_position(struct pipe_context *_pipe,
652 unsigned sample_count, unsigned sample_index,
653 float *out_value)
654 {
655 struct pipe_context *pipe = dd_context(_pipe)->pipe;
656
657 return pipe->get_sample_position(pipe, sample_count, sample_index,
658 out_value);
659 }
660
661 static void
662 dd_context_invalidate_resource(struct pipe_context *_pipe,
663 struct pipe_resource *resource)
664 {
665 struct pipe_context *pipe = dd_context(_pipe)->pipe;
666
667 pipe->invalidate_resource(pipe, resource);
668 }
669
670 static enum pipe_reset_status
671 dd_context_get_device_reset_status(struct pipe_context *_pipe)
672 {
673 struct pipe_context *pipe = dd_context(_pipe)->pipe;
674
675 return pipe->get_device_reset_status(pipe);
676 }
677
678 static void
679 dd_context_set_device_reset_callback(struct pipe_context *_pipe,
680 const struct pipe_device_reset_callback *cb)
681 {
682 struct pipe_context *pipe = dd_context(_pipe)->pipe;
683
684 return pipe->set_device_reset_callback(pipe, cb);
685 }
686
687 static void
688 dd_context_emit_string_marker(struct pipe_context *_pipe,
689 const char *string, int len)
690 {
691 struct dd_context *dctx = dd_context(_pipe);
692 struct pipe_context *pipe = dctx->pipe;
693
694 pipe->emit_string_marker(pipe, string, len);
695 dd_parse_apitrace_marker(string, len, &dctx->draw_state.apitrace_call_number);
696 }
697
698 static void
699 dd_context_dump_debug_state(struct pipe_context *_pipe, FILE *stream,
700 unsigned flags)
701 {
702 struct pipe_context *pipe = dd_context(_pipe)->pipe;
703
704 return pipe->dump_debug_state(pipe, stream, flags);
705 }
706
707 static uint64_t
708 dd_context_create_texture_handle(struct pipe_context *_pipe,
709 struct pipe_sampler_view *view,
710 const struct pipe_sampler_state *state)
711 {
712 struct pipe_context *pipe = dd_context(_pipe)->pipe;
713
714 return pipe->create_texture_handle(pipe, view, state);
715 }
716
717 static void
718 dd_context_delete_texture_handle(struct pipe_context *_pipe, uint64_t handle)
719 {
720 struct pipe_context *pipe = dd_context(_pipe)->pipe;
721
722 pipe->delete_texture_handle(pipe, handle);
723 }
724
725 static void
726 dd_context_make_texture_handle_resident(struct pipe_context *_pipe,
727 uint64_t handle, bool resident)
728 {
729 struct pipe_context *pipe = dd_context(_pipe)->pipe;
730
731 pipe->make_texture_handle_resident(pipe, handle, resident);
732 }
733
734 static uint64_t
735 dd_context_create_image_handle(struct pipe_context *_pipe,
736 const struct pipe_image_view *image)
737 {
738 struct pipe_context *pipe = dd_context(_pipe)->pipe;
739
740 return pipe->create_image_handle(pipe, image);
741 }
742
743 static void
744 dd_context_delete_image_handle(struct pipe_context *_pipe, uint64_t handle)
745 {
746 struct pipe_context *pipe = dd_context(_pipe)->pipe;
747
748 pipe->delete_image_handle(pipe, handle);
749 }
750
751 static void
752 dd_context_make_image_handle_resident(struct pipe_context *_pipe,
753 uint64_t handle, unsigned access,
754 bool resident)
755 {
756 struct pipe_context *pipe = dd_context(_pipe)->pipe;
757
758 pipe->make_image_handle_resident(pipe, handle, access, resident);
759 }
760
761 static void
762 dd_context_set_context_param(struct pipe_context *_pipe,
763 enum pipe_context_param param,
764 unsigned value)
765 {
766 struct pipe_context *pipe = dd_context(_pipe)->pipe;
767
768 pipe->set_context_param(pipe, param, value);
769 }
770
771 struct pipe_context *
772 dd_context_create(struct dd_screen *dscreen, struct pipe_context *pipe)
773 {
774 struct dd_context *dctx;
775
776 if (!pipe)
777 return NULL;
778
779 dctx = CALLOC_STRUCT(dd_context);
780 if (!dctx)
781 goto fail;
782
783 dctx->pipe = pipe;
784 dctx->base.priv = pipe->priv; /* expose wrapped priv data */
785 dctx->base.screen = &dscreen->base;
786 dctx->base.stream_uploader = pipe->stream_uploader;
787 dctx->base.const_uploader = pipe->const_uploader;
788
789 dctx->base.destroy = dd_context_destroy;
790
791 CTX_INIT(render_condition);
792 CTX_INIT(create_query);
793 CTX_INIT(create_batch_query);
794 CTX_INIT(destroy_query);
795 CTX_INIT(begin_query);
796 CTX_INIT(end_query);
797 CTX_INIT(get_query_result);
798 CTX_INIT(set_active_query_state);
799 CTX_INIT(create_blend_state);
800 CTX_INIT(bind_blend_state);
801 CTX_INIT(delete_blend_state);
802 CTX_INIT(create_sampler_state);
803 CTX_INIT(bind_sampler_states);
804 CTX_INIT(delete_sampler_state);
805 CTX_INIT(create_rasterizer_state);
806 CTX_INIT(bind_rasterizer_state);
807 CTX_INIT(delete_rasterizer_state);
808 CTX_INIT(create_depth_stencil_alpha_state);
809 CTX_INIT(bind_depth_stencil_alpha_state);
810 CTX_INIT(delete_depth_stencil_alpha_state);
811 CTX_INIT(create_fs_state);
812 CTX_INIT(bind_fs_state);
813 CTX_INIT(delete_fs_state);
814 CTX_INIT(create_vs_state);
815 CTX_INIT(bind_vs_state);
816 CTX_INIT(delete_vs_state);
817 CTX_INIT(create_gs_state);
818 CTX_INIT(bind_gs_state);
819 CTX_INIT(delete_gs_state);
820 CTX_INIT(create_tcs_state);
821 CTX_INIT(bind_tcs_state);
822 CTX_INIT(delete_tcs_state);
823 CTX_INIT(create_tes_state);
824 CTX_INIT(bind_tes_state);
825 CTX_INIT(delete_tes_state);
826 CTX_INIT(create_compute_state);
827 CTX_INIT(bind_compute_state);
828 CTX_INIT(delete_compute_state);
829 CTX_INIT(create_vertex_elements_state);
830 CTX_INIT(bind_vertex_elements_state);
831 CTX_INIT(delete_vertex_elements_state);
832 CTX_INIT(set_blend_color);
833 CTX_INIT(set_stencil_ref);
834 CTX_INIT(set_sample_mask);
835 CTX_INIT(set_min_samples);
836 CTX_INIT(set_clip_state);
837 CTX_INIT(set_constant_buffer);
838 CTX_INIT(set_framebuffer_state);
839 CTX_INIT(set_polygon_stipple);
840 CTX_INIT(set_scissor_states);
841 CTX_INIT(set_viewport_states);
842 CTX_INIT(set_sampler_views);
843 CTX_INIT(set_tess_state);
844 CTX_INIT(set_shader_buffers);
845 CTX_INIT(set_shader_images);
846 CTX_INIT(set_vertex_buffers);
847 CTX_INIT(set_window_rectangles);
848 CTX_INIT(create_stream_output_target);
849 CTX_INIT(stream_output_target_destroy);
850 CTX_INIT(set_stream_output_targets);
851 CTX_INIT(create_sampler_view);
852 CTX_INIT(sampler_view_destroy);
853 CTX_INIT(create_surface);
854 CTX_INIT(surface_destroy);
855 CTX_INIT(texture_barrier);
856 CTX_INIT(memory_barrier);
857 CTX_INIT(resource_commit);
858 /* create_video_codec */
859 /* create_video_buffer */
860 /* set_compute_resources */
861 /* set_global_binding */
862 CTX_INIT(get_sample_position);
863 CTX_INIT(invalidate_resource);
864 CTX_INIT(get_device_reset_status);
865 CTX_INIT(set_device_reset_callback);
866 CTX_INIT(dump_debug_state);
867 CTX_INIT(emit_string_marker);
868 CTX_INIT(create_texture_handle);
869 CTX_INIT(delete_texture_handle);
870 CTX_INIT(make_texture_handle_resident);
871 CTX_INIT(create_image_handle);
872 CTX_INIT(delete_image_handle);
873 CTX_INIT(make_image_handle_resident);
874 CTX_INIT(set_context_param);
875
876 dd_init_draw_functions(dctx);
877
878 u_log_context_init(&dctx->log);
879 if (pipe->set_log_context)
880 pipe->set_log_context(pipe, &dctx->log);
881
882 dctx->draw_state.sample_mask = ~0;
883
884 list_inithead(&dctx->records);
885 (void) mtx_init(&dctx->mutex, mtx_plain);
886 (void) cnd_init(&dctx->cond);
887 dctx->thread = u_thread_create(dd_thread_main, dctx);
888 if (!dctx->thread) {
889 mtx_destroy(&dctx->mutex);
890 goto fail;
891 }
892
893 return &dctx->base;
894
895 fail:
896 FREE(dctx);
897 pipe->destroy(pipe);
898 return NULL;
899 }