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 bool
 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 bool
 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
 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
 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
 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                                              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 *
 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,
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 *
 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 }