src/gallium/auxiliary/driver_rbug/rbug_context.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include "pipe/p_context.h"
  30 #include "util/u_memory.h"
  31 #include "util/u_inlines.h"
  32 #include "util/simple_list.h"
  33
  34 #include "rbug/rbug_context.h"
  35
  36 #include "rbug_context.h"
  37 #include "rbug_objects.h"
  38
  39
  40 static void
  41 rbug_destroy(struct pipe_context *_pipe)
  42 {
  43    struct rbug_screen *rb_screen = rbug_screen(_pipe->screen);
  44    struct rbug_context *rb_pipe = rbug_context(_pipe);
  45    struct pipe_context *pipe = rb_pipe->pipe;
  46
  47    rbug_screen_remove_from_list(rb_screen, contexts, rb_pipe);
  48
  49    mtx_lock(&rb_pipe->call_mutex);
  50    pipe->destroy(pipe);
  51    rb_pipe->pipe = NULL;
  52    mtx_unlock(&rb_pipe->call_mutex);
  53
  54    FREE(rb_pipe);
  55 }
  56
  57 static void
  58 rbug_draw_block_locked(struct rbug_context *rb_pipe, int flag)
  59 {
  60
  61    if (rb_pipe->draw_blocker & flag) {
  62       rb_pipe->draw_blocked |= flag;
  63    } else if ((rb_pipe->draw_rule.blocker & flag) &&
  64               (rb_pipe->draw_blocker & RBUG_BLOCK_RULE)) {
  65       unsigned k;
  66       bool block = false;
  67       unsigned sh;
  68
  69       debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
  70                    (void *) rb_pipe->draw_rule.shader[PIPE_SHADER_FRAGMENT],
  71                    (void *) rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT],
  72                    (void *) rb_pipe->draw_rule.shader[PIPE_SHADER_VERTEX],
  73                    (void *) rb_pipe->curr.shader[PIPE_SHADER_VERTEX],
  74                    (void *) rb_pipe->draw_rule.surf, 0,
  75                    (void *) rb_pipe->draw_rule.texture, 0);
  76       for (sh = 0; sh < PIPE_SHADER_TYPES; sh++) {
  77          if (rb_pipe->draw_rule.shader[sh] &&
  78              rb_pipe->draw_rule.shader[sh] == rb_pipe->curr.shader[sh])
  79             block = true;
  80       }
  81
  82       if (rb_pipe->draw_rule.surf &&
  83           rb_pipe->draw_rule.surf == rb_pipe->curr.zsbuf)
  84             block = true;
  85       if (rb_pipe->draw_rule.surf)
  86          for (k = 0; k < rb_pipe->curr.nr_cbufs; k++)
  87             if (rb_pipe->draw_rule.surf == rb_pipe->curr.cbufs[k])
  88                block = true;
  89       if (rb_pipe->draw_rule.texture) {
  90          for (sh = 0; sh < ARRAY_SIZE(rb_pipe->curr.num_views); sh++) {
  91             for (k = 0; k < rb_pipe->curr.num_views[sh]; k++) {
  92                if (rb_pipe->draw_rule.texture == rb_pipe->curr.texs[sh][k]) {
  93                   block = true;
  94                   sh = PIPE_SHADER_TYPES; /* to break out of both loops */
  95                   break;
  96                }
  97             }
  98          }
  99       }
 100
 101       if (block)
 102          rb_pipe->draw_blocked |= (flag | RBUG_BLOCK_RULE);
 103    }
 104
 105    if (rb_pipe->draw_blocked)
 106       rbug_notify_draw_blocked(rb_pipe);
 107
 108    /* wait for rbug to clear the blocked flag */
 109    while (rb_pipe->draw_blocked & flag) {
 110       rb_pipe->draw_blocked |= flag;
 111       cnd_wait(&rb_pipe->draw_cond, &rb_pipe->draw_mutex);
 112    }
 113
 114 }
 115
 116 static void
 117 rbug_draw_vbo(struct pipe_context *_pipe, const struct pipe_draw_info *info)
 118 {
 119    struct rbug_context *rb_pipe = rbug_context(_pipe);
 120    struct pipe_context *pipe = rb_pipe->pipe;
 121
 122    mtx_lock(&rb_pipe->draw_mutex);
 123    rbug_draw_block_locked(rb_pipe, RBUG_BLOCK_BEFORE);
 124
 125    mtx_lock(&rb_pipe->call_mutex);
 126    /* XXX loop over PIPE_SHADER_x here */
 127    if (!(rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT] && rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT]->disabled) &&
 128        !(rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY] && rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY]->disabled) &&
 129        !(rb_pipe->curr.shader[PIPE_SHADER_VERTEX] && rb_pipe->curr.shader[PIPE_SHADER_VERTEX]->disabled))
 130       pipe->draw_vbo(pipe, info);
 131    mtx_unlock(&rb_pipe->call_mutex);
 132
 133    rbug_draw_block_locked(rb_pipe, RBUG_BLOCK_AFTER);
 134    mtx_unlock(&rb_pipe->draw_mutex);
 135 }
 136
 137 static struct pipe_query *
 138 rbug_create_query(struct pipe_context *_pipe,
 139                   unsigned query_type,
 140                   unsigned index)
 141 {
 142    struct rbug_context *rb_pipe = rbug_context(_pipe);
 143    struct pipe_context *pipe = rb_pipe->pipe;
 144    struct pipe_query *query;
 145
 146    mtx_lock(&rb_pipe->call_mutex);
 147    query = pipe->create_query(pipe,
 148                               query_type,
 149                               index);
 150    mtx_unlock(&rb_pipe->call_mutex);
 151    return query;
 152 }
 153
 154 static void
 155 rbug_destroy_query(struct pipe_context *_pipe,
 156                    struct pipe_query *query)
 157 {
 158    struct rbug_context *rb_pipe = rbug_context(_pipe);
 159    struct pipe_context *pipe = rb_pipe->pipe;
 160
 161    mtx_lock(&rb_pipe->call_mutex);
 162    pipe->destroy_query(pipe,
 163                        query);
 164    mtx_unlock(&rb_pipe->call_mutex);
 165 }
 166
 167 static bool
 168 rbug_begin_query(struct pipe_context *_pipe,
 169                  struct pipe_query *query)
 170 {
 171    struct rbug_context *rb_pipe = rbug_context(_pipe);
 172    struct pipe_context *pipe = rb_pipe->pipe;
 173    bool ret;
 174
 175    mtx_lock(&rb_pipe->call_mutex);
 176    ret = pipe->begin_query(pipe, query);
 177    mtx_unlock(&rb_pipe->call_mutex);
 178    return ret;
 179 }
 180
 181 static bool
 182 rbug_end_query(struct pipe_context *_pipe,
 183                struct pipe_query *query)
 184 {
 185    struct rbug_context *rb_pipe = rbug_context(_pipe);
 186    struct pipe_context *pipe = rb_pipe->pipe;
 187    bool ret;
 188
 189    mtx_lock(&rb_pipe->call_mutex);
 190    ret = pipe->end_query(pipe,
 191                          query);
 192    mtx_unlock(&rb_pipe->call_mutex);
 193
 194    return ret;
 195 }
 196
 197 static bool
 198 rbug_get_query_result(struct pipe_context *_pipe,
 199                       struct pipe_query *query,
 200                       bool wait,
 201                       union pipe_query_result *result)
 202 {
 203    struct rbug_context *rb_pipe = rbug_context(_pipe);
 204    struct pipe_context *pipe = rb_pipe->pipe;
 205    bool ret;
 206
 207    mtx_lock(&rb_pipe->call_mutex);
 208    ret = pipe->get_query_result(pipe,
 209                                 query,
 210                                 wait,
 211                                 result);
 212    mtx_unlock(&rb_pipe->call_mutex);
 213
 214    return ret;
 215 }
 216
 217 static void
 218 rbug_set_active_query_state(struct pipe_context *_pipe, bool enable)
 219 {
 220    struct rbug_context *rb_pipe = rbug_context(_pipe);
 221    struct pipe_context *pipe = rb_pipe->pipe;
 222
 223    mtx_lock(&rb_pipe->call_mutex);
 224    pipe->set_active_query_state(pipe, enable);
 225    mtx_unlock(&rb_pipe->call_mutex);
 226 }
 227
 228 static void *
 229 rbug_create_blend_state(struct pipe_context *_pipe,
 230                         const struct pipe_blend_state *blend)
 231 {
 232    struct rbug_context *rb_pipe = rbug_context(_pipe);
 233    struct pipe_context *pipe = rb_pipe->pipe;
 234    void *ret;
 235
 236    mtx_lock(&rb_pipe->call_mutex);
 237    ret = pipe->create_blend_state(pipe,
 238                                   blend);
 239    mtx_unlock(&rb_pipe->call_mutex);
 240
 241    return ret;
 242 }
 243
 244 static void
 245 rbug_bind_blend_state(struct pipe_context *_pipe,
 246                       void *blend)
 247 {
 248    struct rbug_context *rb_pipe = rbug_context(_pipe);
 249    struct pipe_context *pipe = rb_pipe->pipe;
 250
 251    mtx_lock(&rb_pipe->call_mutex);
 252    pipe->bind_blend_state(pipe,
 253                           blend);
 254    mtx_unlock(&rb_pipe->call_mutex);
 255 }
 256
 257 static void
 258 rbug_delete_blend_state(struct pipe_context *_pipe,
 259                         void *blend)
 260 {
 261    struct rbug_context *rb_pipe = rbug_context(_pipe);
 262    struct pipe_context *pipe = rb_pipe->pipe;
 263
 264    mtx_lock(&rb_pipe->call_mutex);
 265    pipe->delete_blend_state(pipe,
 266                             blend);
 267    mtx_unlock(&rb_pipe->call_mutex);
 268 }
 269
 270 static void *
 271 rbug_create_sampler_state(struct pipe_context *_pipe,
 272                           const struct pipe_sampler_state *sampler)
 273 {
 274    struct rbug_context *rb_pipe = rbug_context(_pipe);
 275    struct pipe_context *pipe = rb_pipe->pipe;
 276    void *ret;
 277
 278    mtx_lock(&rb_pipe->call_mutex);
 279    ret = pipe->create_sampler_state(pipe,
 280                                     sampler);
 281    mtx_unlock(&rb_pipe->call_mutex);
 282
 283    return ret;
 284 }
 285
 286 static void
 287 rbug_bind_sampler_states(struct pipe_context *_pipe,
 288                          enum pipe_shader_type shader,
 289                          unsigned start, unsigned count,
 290                          void **samplers)
 291 {
 292    struct rbug_context *rb_pipe = rbug_context(_pipe);
 293    struct pipe_context *pipe = rb_pipe->pipe;
 294
 295    mtx_lock(&rb_pipe->call_mutex);
 296    pipe->bind_sampler_states(pipe, shader, start, count, samplers);
 297    mtx_unlock(&rb_pipe->call_mutex);
 298 }
 299
 300 static void
 301 rbug_delete_sampler_state(struct pipe_context *_pipe,
 302                           void *sampler)
 303 {
 304    struct rbug_context *rb_pipe = rbug_context(_pipe);
 305    struct pipe_context *pipe = rb_pipe->pipe;
 306
 307    mtx_lock(&rb_pipe->call_mutex);
 308    pipe->delete_sampler_state(pipe,
 309                               sampler);
 310    mtx_unlock(&rb_pipe->call_mutex);
 311 }
 312
 313 static void *
 314 rbug_create_rasterizer_state(struct pipe_context *_pipe,
 315                              const struct pipe_rasterizer_state *rasterizer)
 316 {
 317    struct rbug_context *rb_pipe = rbug_context(_pipe);
 318    struct pipe_context *pipe = rb_pipe->pipe;
 319    void *ret;
 320
 321    mtx_lock(&rb_pipe->call_mutex);
 322    ret = pipe->create_rasterizer_state(pipe,
 323                                        rasterizer);
 324    mtx_unlock(&rb_pipe->call_mutex);
 325
 326    return ret;
 327 }
 328
 329 static void
 330 rbug_bind_rasterizer_state(struct pipe_context *_pipe,
 331                            void *rasterizer)
 332 {
 333    struct rbug_context *rb_pipe = rbug_context(_pipe);
 334    struct pipe_context *pipe = rb_pipe->pipe;
 335
 336    mtx_lock(&rb_pipe->call_mutex);
 337    pipe->bind_rasterizer_state(pipe,
 338                                rasterizer);
 339    mtx_unlock(&rb_pipe->call_mutex);
 340 }
 341
 342 static void
 343 rbug_delete_rasterizer_state(struct pipe_context *_pipe,
 344                              void *rasterizer)
 345 {
 346    struct rbug_context *rb_pipe = rbug_context(_pipe);
 347    struct pipe_context *pipe = rb_pipe->pipe;
 348
 349    mtx_lock(&rb_pipe->call_mutex);
 350    pipe->delete_rasterizer_state(pipe,
 351                                  rasterizer);
 352    mtx_unlock(&rb_pipe->call_mutex);
 353 }
 354
 355 static void *
 356 rbug_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 357                                       const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha)
 358 {
 359    struct rbug_context *rb_pipe = rbug_context(_pipe);
 360    struct pipe_context *pipe = rb_pipe->pipe;
 361    void *ret;
 362
 363    mtx_lock(&rb_pipe->call_mutex);
 364    ret = pipe->create_depth_stencil_alpha_state(pipe,
 365                                                 depth_stencil_alpha);
 366    mtx_unlock(&rb_pipe->call_mutex);
 367
 368    return ret;
 369 }
 370
 371 static void
 372 rbug_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 373                                     void *depth_stencil_alpha)
 374 {
 375    struct rbug_context *rb_pipe = rbug_context(_pipe);
 376    struct pipe_context *pipe = rb_pipe->pipe;
 377
 378    mtx_lock(&rb_pipe->call_mutex);
 379    pipe->bind_depth_stencil_alpha_state(pipe,
 380                                         depth_stencil_alpha);
 381    mtx_unlock(&rb_pipe->call_mutex);
 382 }
 383
 384 static void
 385 rbug_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 386                                       void *depth_stencil_alpha)
 387 {
 388    struct rbug_context *rb_pipe = rbug_context(_pipe);
 389    struct pipe_context *pipe = rb_pipe->pipe;
 390
 391    mtx_lock(&rb_pipe->call_mutex);
 392    pipe->delete_depth_stencil_alpha_state(pipe,
 393                                           depth_stencil_alpha);
 394    mtx_unlock(&rb_pipe->call_mutex);
 395 }
 396
 397 static void *
 398 rbug_create_fs_state(struct pipe_context *_pipe,
 399                      const struct pipe_shader_state *state)
 400 {
 401    struct rbug_context *rb_pipe = rbug_context(_pipe);
 402    struct pipe_context *pipe = rb_pipe->pipe;
 403    void *result;
 404
 405    mtx_lock(&rb_pipe->call_mutex);
 406    result = pipe->create_fs_state(pipe, state);
 407    mtx_unlock(&rb_pipe->call_mutex);
 408
 409    if (!result)
 410       return NULL;
 411
 412    return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_FRAGMENT);
 413 }
 414
 415 static void
 416 rbug_bind_fs_state(struct pipe_context *_pipe,
 417                    void *_fs)
 418 {
 419    struct rbug_context *rb_pipe = rbug_context(_pipe);
 420    struct pipe_context *pipe = rb_pipe->pipe;
 421    void *fs;
 422
 423    mtx_lock(&rb_pipe->call_mutex);
 424
 425    fs = rbug_shader_unwrap(_fs);
 426    rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT] = rbug_shader(_fs);
 427    pipe->bind_fs_state(pipe,
 428                        fs);
 429
 430    mtx_unlock(&rb_pipe->call_mutex);
 431 }
 432
 433 static void
 434 rbug_delete_fs_state(struct pipe_context *_pipe,
 435                      void *_fs)
 436 {
 437    struct rbug_context *rb_pipe = rbug_context(_pipe);
 438    struct rbug_shader *rb_shader = rbug_shader(_fs);
 439
 440    mtx_lock(&rb_pipe->call_mutex);
 441    rbug_shader_destroy(rb_pipe, rb_shader);
 442    mtx_unlock(&rb_pipe->call_mutex);
 443 }
 444
 445 static void *
 446 rbug_create_vs_state(struct pipe_context *_pipe,
 447                      const struct pipe_shader_state *state)
 448 {
 449    struct rbug_context *rb_pipe = rbug_context(_pipe);
 450    struct pipe_context *pipe = rb_pipe->pipe;
 451    void *result;
 452
 453    mtx_lock(&rb_pipe->call_mutex);
 454    result = pipe->create_vs_state(pipe, state);
 455    mtx_unlock(&rb_pipe->call_mutex);
 456
 457    if (!result)
 458       return NULL;
 459
 460    return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_VERTEX);
 461 }
 462
 463 static void
 464 rbug_bind_vs_state(struct pipe_context *_pipe,
 465                    void *_vs)
 466 {
 467    struct rbug_context *rb_pipe = rbug_context(_pipe);
 468    struct pipe_context *pipe = rb_pipe->pipe;
 469    void *vs;
 470
 471    mtx_lock(&rb_pipe->call_mutex);
 472
 473    vs = rbug_shader_unwrap(_vs);
 474    rb_pipe->curr.shader[PIPE_SHADER_VERTEX] = rbug_shader(_vs);
 475    pipe->bind_vs_state(pipe,
 476                        vs);
 477
 478    mtx_unlock(&rb_pipe->call_mutex);
 479 }
 480
 481 static void
 482 rbug_delete_vs_state(struct pipe_context *_pipe,
 483                      void *_vs)
 484 {
 485    struct rbug_context *rb_pipe = rbug_context(_pipe);
 486    struct rbug_shader *rb_shader = rbug_shader(_vs);
 487
 488    mtx_unlock(&rb_pipe->call_mutex);
 489    rbug_shader_destroy(rb_pipe, rb_shader);
 490    mtx_unlock(&rb_pipe->call_mutex);
 491 }
 492
 493 static void *
 494 rbug_create_gs_state(struct pipe_context *_pipe,
 495                      const struct pipe_shader_state *state)
 496 {
 497    struct rbug_context *rb_pipe = rbug_context(_pipe);
 498    struct pipe_context *pipe = rb_pipe->pipe;
 499    void *result;
 500
 501    mtx_lock(&rb_pipe->call_mutex);
 502    result = pipe->create_gs_state(pipe, state);
 503    mtx_unlock(&rb_pipe->call_mutex);
 504
 505    if (!result)
 506       return NULL;
 507
 508    return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_GEOM);
 509 }
 510
 511 static void
 512 rbug_bind_gs_state(struct pipe_context *_pipe,
 513                    void *_gs)
 514 {
 515    struct rbug_context *rb_pipe = rbug_context(_pipe);
 516    struct pipe_context *pipe = rb_pipe->pipe;
 517    void *gs;
 518
 519    mtx_lock(&rb_pipe->call_mutex);
 520
 521    gs = rbug_shader_unwrap(_gs);
 522    rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY] = rbug_shader(_gs);
 523    pipe->bind_gs_state(pipe,
 524                        gs);
 525
 526    mtx_unlock(&rb_pipe->call_mutex);
 527 }
 528
 529 static void
 530 rbug_delete_gs_state(struct pipe_context *_pipe,
 531                      void *_gs)
 532 {
 533    struct rbug_context *rb_pipe = rbug_context(_pipe);
 534    struct rbug_shader *rb_shader = rbug_shader(_gs);
 535
 536    mtx_lock(&rb_pipe->call_mutex);
 537    rbug_shader_destroy(rb_pipe, rb_shader);
 538    mtx_unlock(&rb_pipe->call_mutex);
 539 }
 540
 541 static void *
 542 rbug_create_vertex_elements_state(struct pipe_context *_pipe,
 543                                   unsigned num_elements,
 544                                   const struct pipe_vertex_element *vertex_elements)
 545 {
 546    struct rbug_context *rb_pipe = rbug_context(_pipe);
 547    struct pipe_context *pipe = rb_pipe->pipe;
 548    void *ret;
 549
 550    mtx_lock(&rb_pipe->call_mutex);
 551    ret = pipe->create_vertex_elements_state(pipe,
 552                                              num_elements,
 553                                              vertex_elements);
 554    mtx_unlock(&rb_pipe->call_mutex);
 555
 556    return ret;
 557 }
 558
 559 static void
 560 rbug_bind_vertex_elements_state(struct pipe_context *_pipe,
 561                                 void *velems)
 562 {
 563    struct rbug_context *rb_pipe = rbug_context(_pipe);
 564    struct pipe_context *pipe = rb_pipe->pipe;
 565
 566    mtx_lock(&rb_pipe->call_mutex);
 567    pipe->bind_vertex_elements_state(pipe,
 568                                     velems);
 569    mtx_unlock(&rb_pipe->call_mutex);
 570 }
 571
 572 static void
 573 rbug_delete_vertex_elements_state(struct pipe_context *_pipe,
 574                                   void *velems)
 575 {
 576    struct rbug_context *rb_pipe = rbug_context(_pipe);
 577    struct pipe_context *pipe = rb_pipe->pipe;
 578
 579    mtx_lock(&rb_pipe->call_mutex);
 580    pipe->delete_vertex_elements_state(pipe,
 581                                       velems);
 582    mtx_unlock(&rb_pipe->call_mutex);
 583 }
 584
 585 static void
 586 rbug_set_blend_color(struct pipe_context *_pipe,
 587                      const struct pipe_blend_color *blend_color)
 588 {
 589    struct rbug_context *rb_pipe = rbug_context(_pipe);
 590    struct pipe_context *pipe = rb_pipe->pipe;
 591
 592    mtx_lock(&rb_pipe->call_mutex);
 593    pipe->set_blend_color(pipe,
 594                          blend_color);
 595    mtx_unlock(&rb_pipe->call_mutex);
 596 }
 597
 598 static void
 599 rbug_set_stencil_ref(struct pipe_context *_pipe,
 600                      const struct pipe_stencil_ref *stencil_ref)
 601 {
 602    struct rbug_context *rb_pipe = rbug_context(_pipe);
 603    struct pipe_context *pipe = rb_pipe->pipe;
 604
 605    mtx_lock(&rb_pipe->call_mutex);
 606    pipe->set_stencil_ref(pipe,
 607                          stencil_ref);
 608    mtx_unlock(&rb_pipe->call_mutex);
 609 }
 610
 611 static void
 612 rbug_set_clip_state(struct pipe_context *_pipe,
 613                     const struct pipe_clip_state *clip)
 614 {
 615    struct rbug_context *rb_pipe = rbug_context(_pipe);
 616    struct pipe_context *pipe = rb_pipe->pipe;
 617
 618    mtx_lock(&rb_pipe->call_mutex);
 619    pipe->set_clip_state(pipe,
 620                         clip);
 621    mtx_unlock(&rb_pipe->call_mutex);
 622 }
 623
 624 static void
 625 rbug_set_constant_buffer(struct pipe_context *_pipe,
 626                          enum pipe_shader_type shader,
 627                          uint index,
 628                          const struct pipe_constant_buffer *_cb)
 629 {
 630    struct rbug_context *rb_pipe = rbug_context(_pipe);
 631    struct pipe_context *pipe = rb_pipe->pipe;
 632    struct pipe_constant_buffer cb;
 633
 634    /* XXX hmm? unwrap the input state */
 635    if (_cb) {
 636       cb = *_cb;
 637       cb.buffer = rbug_resource_unwrap(_cb->buffer);
 638    }
 639
 640    mtx_lock(&rb_pipe->call_mutex);
 641    pipe->set_constant_buffer(pipe,
 642                              shader,
 643                              index,
 644                              _cb ? &cb : NULL);
 645    mtx_unlock(&rb_pipe->call_mutex);
 646 }
 647
 648 static void
 649 rbug_set_framebuffer_state(struct pipe_context *_pipe,
 650                            const struct pipe_framebuffer_state *_state)
 651 {
 652    struct rbug_context *rb_pipe = rbug_context(_pipe);
 653    struct pipe_context *pipe = rb_pipe->pipe;
 654    struct pipe_framebuffer_state unwrapped_state;
 655    struct pipe_framebuffer_state *state = NULL;
 656    unsigned i;
 657
 658    /* must protect curr status */
 659    mtx_lock(&rb_pipe->call_mutex);
 660
 661    rb_pipe->curr.nr_cbufs = 0;
 662    memset(rb_pipe->curr.cbufs, 0, sizeof(rb_pipe->curr.cbufs));
 663    rb_pipe->curr.zsbuf = NULL;
 664
 665    /* unwrap the input state */
 666    if (_state) {
 667       memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
 668
 669       rb_pipe->curr.nr_cbufs = _state->nr_cbufs;
 670       for(i = 0; i < _state->nr_cbufs; i++) {
 671          unwrapped_state.cbufs[i] = rbug_surface_unwrap(_state->cbufs[i]);
 672          if (_state->cbufs[i])
 673             rb_pipe->curr.cbufs[i] = rbug_resource(_state->cbufs[i]->texture);
 674       }
 675       unwrapped_state.zsbuf = rbug_surface_unwrap(_state->zsbuf);
 676       if (_state->zsbuf)
 677          rb_pipe->curr.zsbuf = rbug_resource(_state->zsbuf->texture);
 678       state = &unwrapped_state;
 679    }
 680
 681    pipe->set_framebuffer_state(pipe,
 682                                state);
 683
 684    mtx_unlock(&rb_pipe->call_mutex);
 685 }
 686
 687 static void
 688 rbug_set_polygon_stipple(struct pipe_context *_pipe,
 689                          const struct pipe_poly_stipple *poly_stipple)
 690 {
 691    struct rbug_context *rb_pipe = rbug_context(_pipe);
 692    struct pipe_context *pipe = rb_pipe->pipe;
 693
 694    mtx_lock(&rb_pipe->call_mutex);
 695    pipe->set_polygon_stipple(pipe,
 696                              poly_stipple);
 697    mtx_unlock(&rb_pipe->call_mutex);
 698 }
 699
 700 static void
 701 rbug_set_scissor_states(struct pipe_context *_pipe,
 702                         unsigned start_slot,
 703                         unsigned num_scissors,
 704                         const struct pipe_scissor_state *scissor)
 705 {
 706    struct rbug_context *rb_pipe = rbug_context(_pipe);
 707    struct pipe_context *pipe = rb_pipe->pipe;
 708
 709    mtx_lock(&rb_pipe->call_mutex);
 710    pipe->set_scissor_states(pipe, start_slot, num_scissors, scissor);
 711    mtx_unlock(&rb_pipe->call_mutex);
 712 }
 713
 714 static void
 715 rbug_set_viewport_states(struct pipe_context *_pipe,
 716                          unsigned start_slot,
 717                          unsigned num_viewports,
 718                          const struct pipe_viewport_state *viewport)
 719 {
 720    struct rbug_context *rb_pipe = rbug_context(_pipe);
 721    struct pipe_context *pipe = rb_pipe->pipe;
 722
 723    mtx_lock(&rb_pipe->call_mutex);
 724    pipe->set_viewport_states(pipe, start_slot, num_viewports, viewport);
 725    mtx_unlock(&rb_pipe->call_mutex);
 726 }
 727
 728 static void
 729 rbug_set_sampler_views(struct pipe_context *_pipe,
 730                        enum pipe_shader_type shader,
 731                        unsigned start,
 732                        unsigned num,
 733                        struct pipe_sampler_view **_views)
 734 {
 735    struct rbug_context *rb_pipe = rbug_context(_pipe);
 736    struct pipe_context *pipe = rb_pipe->pipe;
 737    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
 738    struct pipe_sampler_view **views = NULL;
 739    unsigned i;
 740
 741    assert(start == 0); /* XXX fix */
 742
 743    /* must protect curr status */
 744    mtx_lock(&rb_pipe->call_mutex);
 745
 746    rb_pipe->curr.num_views[shader] = 0;
 747    memset(rb_pipe->curr.views[shader], 0, sizeof(rb_pipe->curr.views[shader]));
 748    memset(rb_pipe->curr.texs[shader], 0, sizeof(rb_pipe->curr.texs[shader]));
 749    memset(unwrapped_views, 0, sizeof(unwrapped_views));
 750
 751    if (_views) {
 752       rb_pipe->curr.num_views[shader] = num;
 753       for (i = 0; i < num; i++) {
 754          rb_pipe->curr.views[shader][i] = rbug_sampler_view(_views[i]);
 755          rb_pipe->curr.texs[shader][i] = rbug_resource(_views[i] ? _views[i]->texture : NULL);
 756          unwrapped_views[i] = rbug_sampler_view_unwrap(_views[i]);
 757       }
 758       views = unwrapped_views;
 759    }
 760
 761    pipe->set_sampler_views(pipe, shader, start, num, views);
 762
 763    mtx_unlock(&rb_pipe->call_mutex);
 764 }
 765
 766 static void
 767 rbug_set_vertex_buffers(struct pipe_context *_pipe,
 768                         unsigned start_slot, unsigned num_buffers,
 769                         const struct pipe_vertex_buffer *_buffers)
 770 {
 771    struct rbug_context *rb_pipe = rbug_context(_pipe);
 772    struct pipe_context *pipe = rb_pipe->pipe;
 773    struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
 774    struct pipe_vertex_buffer *buffers = NULL;
 775    unsigned i;
 776
 777    mtx_lock(&rb_pipe->call_mutex);
 778
 779    if (num_buffers && _buffers) {
 780       memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
 781       for (i = 0; i < num_buffers; i++) {
 782          if (!_buffers[i].is_user_buffer)
 783             unwrapped_buffers[i].buffer.resource =
 784                rbug_resource_unwrap(_buffers[i].buffer.resource);
 785       }
 786       buffers = unwrapped_buffers;
 787    }
 788
 789    pipe->set_vertex_buffers(pipe, start_slot,
 790                             num_buffers,
 791                             buffers);
 792
 793    mtx_unlock(&rb_pipe->call_mutex);
 794 }
 795
 796 static void
 797 rbug_set_sample_mask(struct pipe_context *_pipe,
 798                      unsigned sample_mask)
 799 {
 800    struct rbug_context *rb_pipe = rbug_context(_pipe);
 801    struct pipe_context *pipe = rb_pipe->pipe;
 802
 803    mtx_lock(&rb_pipe->call_mutex);
 804    pipe->set_sample_mask(pipe, sample_mask);
 805    mtx_unlock(&rb_pipe->call_mutex);
 806 }
 807
 808 static struct pipe_stream_output_target *
 809 rbug_create_stream_output_target(struct pipe_context *_pipe,
 810                                  struct pipe_resource *_res,
 811                                  unsigned buffer_offset, unsigned buffer_size)
 812 {
 813    struct rbug_context *rb_pipe = rbug_context(_pipe);
 814    struct pipe_context *pipe = rb_pipe->pipe;
 815    struct pipe_resource *res = rbug_resource_unwrap(_res);
 816    struct pipe_stream_output_target *target;
 817
 818    mtx_lock(&rb_pipe->call_mutex);
 819    target = pipe->create_stream_output_target(pipe, res, buffer_offset,
 820                                               buffer_size);
 821    mtx_unlock(&rb_pipe->call_mutex);
 822    return target;
 823 }
 824
 825 static void
 826 rbug_stream_output_target_destroy(struct pipe_context *_pipe,
 827                                   struct pipe_stream_output_target *target)
 828 {
 829    struct rbug_context *rb_pipe = rbug_context(_pipe);
 830    struct pipe_context *pipe = rb_pipe->pipe;
 831
 832    mtx_lock(&rb_pipe->call_mutex);
 833    pipe->stream_output_target_destroy(pipe, target);
 834    mtx_unlock(&rb_pipe->call_mutex);
 835 }
 836
 837 static void
 838 rbug_set_stream_output_targets(struct pipe_context *_pipe,
 839                                unsigned num_targets,
 840                                struct pipe_stream_output_target **targets,
 841                                const unsigned *offsets)
 842 {
 843    struct rbug_context *rb_pipe = rbug_context(_pipe);
 844    struct pipe_context *pipe = rb_pipe->pipe;
 845
 846    mtx_lock(&rb_pipe->call_mutex);
 847    pipe->set_stream_output_targets(pipe, num_targets, targets, offsets);
 848    mtx_unlock(&rb_pipe->call_mutex);
 849 }
 850
 851 static void
 852 rbug_resource_copy_region(struct pipe_context *_pipe,
 853                           struct pipe_resource *_dst,
 854                           unsigned dst_level,
 855                           unsigned dstx,
 856                           unsigned dsty,
 857                           unsigned dstz,
 858                           struct pipe_resource *_src,
 859                           unsigned src_level,
 860                           const struct pipe_box *src_box)
 861 {
 862    struct rbug_context *rb_pipe = rbug_context(_pipe);
 863    struct rbug_resource *rb_resource_dst = rbug_resource(_dst);
 864    struct rbug_resource *rb_resource_src = rbug_resource(_src);
 865    struct pipe_context *pipe = rb_pipe->pipe;
 866    struct pipe_resource *dst = rb_resource_dst->resource;
 867    struct pipe_resource *src = rb_resource_src->resource;
 868
 869    mtx_lock(&rb_pipe->call_mutex);
 870    pipe->resource_copy_region(pipe,
 871                               dst,
 872                               dst_level,
 873                               dstx,
 874                               dsty,
 875                               dstz,
 876                               src,
 877                               src_level,
 878                               src_box);
 879    mtx_unlock(&rb_pipe->call_mutex);
 880 }
 881
 882 static void
 883 rbug_blit(struct pipe_context *_pipe, const struct pipe_blit_info *_blit_info)
 884 {
 885    struct rbug_context *rb_pipe = rbug_context(_pipe);
 886    struct rbug_resource *rb_resource_dst = rbug_resource(_blit_info->dst.resource);
 887    struct rbug_resource *rb_resource_src = rbug_resource(_blit_info->src.resource);
 888    struct pipe_context *pipe = rb_pipe->pipe;
 889    struct pipe_resource *dst = rb_resource_dst->resource;
 890    struct pipe_resource *src = rb_resource_src->resource;
 891    struct pipe_blit_info blit_info;
 892
 893    blit_info = *_blit_info;
 894    blit_info.dst.resource = dst;
 895    blit_info.src.resource = src;
 896
 897    mtx_lock(&rb_pipe->call_mutex);
 898    pipe->blit(pipe, &blit_info);
 899    mtx_unlock(&rb_pipe->call_mutex);
 900 }
 901
 902 static void
 903 rbug_flush_resource(struct pipe_context *_pipe,
 904                     struct pipe_resource *_res)
 905 {
 906    struct rbug_context *rb_pipe = rbug_context(_pipe);
 907    struct rbug_resource *rb_resource_res = rbug_resource(_res);
 908    struct pipe_context *pipe = rb_pipe->pipe;
 909    struct pipe_resource *res = rb_resource_res->resource;
 910
 911    mtx_lock(&rb_pipe->call_mutex);
 912    pipe->flush_resource(pipe, res);
 913    mtx_unlock(&rb_pipe->call_mutex);
 914 }
 915
 916 static void
 917 rbug_clear(struct pipe_context *_pipe,
 918            unsigned buffers,
 919            const union pipe_color_union *color,
 920            double depth,
 921            unsigned stencil)
 922 {
 923    struct rbug_context *rb_pipe = rbug_context(_pipe);
 924    struct pipe_context *pipe = rb_pipe->pipe;
 925
 926    mtx_lock(&rb_pipe->call_mutex);
 927    pipe->clear(pipe,
 928                buffers,
 929                color,
 930                depth,
 931                stencil);
 932    mtx_unlock(&rb_pipe->call_mutex);
 933 }
 934
 935 static void
 936 rbug_clear_render_target(struct pipe_context *_pipe,
 937                          struct pipe_surface *_dst,
 938                          const union pipe_color_union *color,
 939                          unsigned dstx, unsigned dsty,
 940                          unsigned width, unsigned height,
 941                          bool render_condition_enabled)
 942 {
 943    struct rbug_context *rb_pipe = rbug_context(_pipe);
 944    struct rbug_surface *rb_surface_dst = rbug_surface(_dst);
 945    struct pipe_context *pipe = rb_pipe->pipe;
 946    struct pipe_surface *dst = rb_surface_dst->surface;
 947
 948    mtx_lock(&rb_pipe->call_mutex);
 949    pipe->clear_render_target(pipe,
 950                              dst,
 951                              color,
 952                              dstx,
 953                              dsty,
 954                              width,
 955                              height,
 956                              render_condition_enabled);
 957    mtx_unlock(&rb_pipe->call_mutex);
 958 }
 959
 960 static void
 961 rbug_clear_depth_stencil(struct pipe_context *_pipe,
 962                          struct pipe_surface *_dst,
 963                          unsigned clear_flags,
 964                          double depth,
 965                          unsigned stencil,
 966                          unsigned dstx, unsigned dsty,
 967                          unsigned width, unsigned height,
 968                          bool render_condition_enabled)
 969 {
 970    struct rbug_context *rb_pipe = rbug_context(_pipe);
 971    struct rbug_surface *rb_surface_dst = rbug_surface(_dst);
 972    struct pipe_context *pipe = rb_pipe->pipe;
 973    struct pipe_surface *dst = rb_surface_dst->surface;
 974
 975    mtx_lock(&rb_pipe->call_mutex);
 976    pipe->clear_depth_stencil(pipe,
 977                              dst,
 978                              clear_flags,
 979                              depth,
 980                              stencil,
 981                              dstx,
 982                              dsty,
 983                              width,
 984                              height,
 985                              render_condition_enabled);
 986    mtx_unlock(&rb_pipe->call_mutex);
 987 }
 988
 989 static void
 990 rbug_flush(struct pipe_context *_pipe,
 991            struct pipe_fence_handle **fence,
 992            unsigned flags)
 993 {
 994    struct rbug_context *rb_pipe = rbug_context(_pipe);
 995    struct pipe_context *pipe = rb_pipe->pipe;
 996
 997    mtx_lock(&rb_pipe->call_mutex);
 998    pipe->flush(pipe, fence, flags);
 999    mtx_unlock(&rb_pipe->call_mutex);
1000 }
1001
1002 static struct pipe_sampler_view *
1003 rbug_context_create_sampler_view(struct pipe_context *_pipe,
1004                                  struct pipe_resource *_resource,
1005                                  const struct pipe_sampler_view *templ)
1006 {
1007    struct rbug_context *rb_pipe = rbug_context(_pipe);
1008    struct rbug_resource *rb_resource = rbug_resource(_resource);
1009    struct pipe_context *pipe = rb_pipe->pipe;
1010    struct pipe_resource *resource = rb_resource->resource;
1011    struct pipe_sampler_view *result;
1012
1013    mtx_lock(&rb_pipe->call_mutex);
1014    result = pipe->create_sampler_view(pipe,
1015                                       resource,
1016                                       templ);
1017    mtx_unlock(&rb_pipe->call_mutex);
1018
1019    if (result)
1020       return rbug_sampler_view_create(rb_pipe, rb_resource, result);
1021    return NULL;
1022 }
1023
1024 static void
1025 rbug_context_sampler_view_destroy(struct pipe_context *_pipe,
1026                                   struct pipe_sampler_view *_view)
1027 {
1028    rbug_sampler_view_destroy(rbug_context(_pipe),
1029                              rbug_sampler_view(_view));
1030 }
1031
1032 static struct pipe_surface *
1033 rbug_context_create_surface(struct pipe_context *_pipe,
1034                             struct pipe_resource *_resource,
1035                             const struct pipe_surface *surf_tmpl)
1036 {
1037    struct rbug_context *rb_pipe = rbug_context(_pipe);
1038    struct rbug_resource *rb_resource = rbug_resource(_resource);
1039    struct pipe_context *pipe = rb_pipe->pipe;
1040    struct pipe_resource *resource = rb_resource->resource;
1041    struct pipe_surface *result;
1042
1043    mtx_lock(&rb_pipe->call_mutex);
1044    result = pipe->create_surface(pipe,
1045                                  resource,
1046                                  surf_tmpl);
1047    mtx_unlock(&rb_pipe->call_mutex);
1048
1049    if (result)
1050       return rbug_surface_create(rb_pipe, rb_resource, result);
1051    return NULL;
1052 }
1053
1054 static void
1055 rbug_context_surface_destroy(struct pipe_context *_pipe,
1056                              struct pipe_surface *_surface)
1057 {
1058    struct rbug_context *rb_pipe = rbug_context(_pipe);
1059    struct rbug_surface *rb_surface = rbug_surface(_surface);
1060
1061    mtx_lock(&rb_pipe->call_mutex);
1062    rbug_surface_destroy(rb_pipe,
1063                         rb_surface);
1064    mtx_unlock(&rb_pipe->call_mutex);
1065 }
1066
1067
1068
1069 static void *
1070 rbug_context_transfer_map(struct pipe_context *_context,
1071                           struct pipe_resource *_resource,
1072                           unsigned level,
1073                           unsigned usage,
1074                           const struct pipe_box *box,
1075                           struct pipe_transfer **transfer)
1076 {
1077    struct rbug_context *rb_pipe = rbug_context(_context);
1078    struct rbug_resource *rb_resource = rbug_resource(_resource);
1079    struct pipe_context *context = rb_pipe->pipe;
1080    struct pipe_resource *resource = rb_resource->resource;
1081    struct pipe_transfer *result;
1082    void *map;
1083
1084    mtx_lock(&rb_pipe->call_mutex);
1085    map = context->transfer_map(context,
1086                                resource,
1087                                level,
1088                                usage,
1089                                box, &result);
1090    mtx_unlock(&rb_pipe->call_mutex);
1091
1092    *transfer = rbug_transfer_create(rb_pipe, rb_resource, result);
1093    return *transfer ? map : NULL;
1094 }
1095
1096 static void
1097 rbug_context_transfer_flush_region(struct pipe_context *_context,
1098                                    struct pipe_transfer *_transfer,
1099                                    const struct pipe_box *box)
1100 {
1101    struct rbug_context *rb_pipe = rbug_context(_context);
1102    struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
1103    struct pipe_context *context = rb_pipe->pipe;
1104    struct pipe_transfer *transfer = rb_transfer->transfer;
1105
1106    mtx_lock(&rb_pipe->call_mutex);
1107    context->transfer_flush_region(context,
1108                                   transfer,
1109                                   box);
1110    mtx_unlock(&rb_pipe->call_mutex);
1111 }
1112
1113
1114 static void
1115 rbug_context_transfer_unmap(struct pipe_context *_context,
1116                             struct pipe_transfer *_transfer)
1117 {
1118    struct rbug_context *rb_pipe = rbug_context(_context);
1119    struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
1120    struct pipe_context *context = rb_pipe->pipe;
1121    struct pipe_transfer *transfer = rb_transfer->transfer;
1122
1123    mtx_lock(&rb_pipe->call_mutex);
1124    context->transfer_unmap(context,
1125                            transfer);
1126    rbug_transfer_destroy(rb_pipe,
1127                          rb_transfer);
1128    mtx_unlock(&rb_pipe->call_mutex);
1129 }
1130
1131
1132 static void
1133 rbug_context_buffer_subdata(struct pipe_context *_context,
1134                             struct pipe_resource *_resource,
1135                             unsigned usage, unsigned offset,
1136                             unsigned size, const void *data)
1137 {
1138    struct rbug_context *rb_pipe = rbug_context(_context);
1139    struct rbug_resource *rb_resource = rbug_resource(_resource);
1140    struct pipe_context *context = rb_pipe->pipe;
1141    struct pipe_resource *resource = rb_resource->resource;
1142
1143    mtx_lock(&rb_pipe->call_mutex);
1144    context->buffer_subdata(context, resource, usage, offset, size, data);
1145    mtx_unlock(&rb_pipe->call_mutex);
1146 }
1147
1148
1149 static void
1150 rbug_context_texture_subdata(struct pipe_context *_context,
1151                              struct pipe_resource *_resource,
1152                              unsigned level,
1153                              unsigned usage,
1154                              const struct pipe_box *box,
1155                              const void *data,
1156                              unsigned stride,
1157                              unsigned layer_stride)
1158 {
1159    struct rbug_context *rb_pipe = rbug_context(_context);
1160    struct rbug_resource *rb_resource = rbug_resource(_resource);
1161    struct pipe_context *context = rb_pipe->pipe;
1162    struct pipe_resource *resource = rb_resource->resource;
1163
1164    mtx_lock(&rb_pipe->call_mutex);
1165    context->texture_subdata(context,
1166                             resource,
1167                             level,
1168                             usage,
1169                             box,
1170                             data,
1171                             stride,
1172                             layer_stride);
1173    mtx_unlock(&rb_pipe->call_mutex);
1174 }
1175
1176
1177 struct pipe_context *
1178 rbug_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
1179 {
1180    struct rbug_context *rb_pipe;
1181    struct rbug_screen *rb_screen = rbug_screen(_screen);
1182
1183    if (!rb_screen)
1184       return NULL;
1185
1186    rb_pipe = CALLOC_STRUCT(rbug_context);
1187    if (!rb_pipe)
1188       return NULL;
1189
1190    (void) mtx_init(&rb_pipe->draw_mutex, mtx_plain);
1191    cnd_init(&rb_pipe->draw_cond);
1192    (void) mtx_init(&rb_pipe->call_mutex, mtx_plain);
1193    (void) mtx_init(&rb_pipe->list_mutex, mtx_plain);
1194    make_empty_list(&rb_pipe->shaders);
1195
1196    rb_pipe->base.screen = _screen;
1197    rb_pipe->base.priv = pipe->priv; /* expose wrapped data */
1198    rb_pipe->base.draw = NULL;
1199    rb_pipe->base.stream_uploader = pipe->stream_uploader;
1200    rb_pipe->base.const_uploader = pipe->const_uploader;
1201
1202    rb_pipe->base.destroy = rbug_destroy;
1203    rb_pipe->base.draw_vbo = rbug_draw_vbo;
1204    rb_pipe->base.create_query = rbug_create_query;
1205    rb_pipe->base.destroy_query = rbug_destroy_query;
1206    rb_pipe->base.begin_query = rbug_begin_query;
1207    rb_pipe->base.end_query = rbug_end_query;
1208    rb_pipe->base.get_query_result = rbug_get_query_result;
1209    rb_pipe->base.set_active_query_state = rbug_set_active_query_state;
1210    rb_pipe->base.create_blend_state = rbug_create_blend_state;
1211    rb_pipe->base.bind_blend_state = rbug_bind_blend_state;
1212    rb_pipe->base.delete_blend_state = rbug_delete_blend_state;
1213    rb_pipe->base.create_sampler_state = rbug_create_sampler_state;
1214    rb_pipe->base.bind_sampler_states = rbug_bind_sampler_states;
1215    rb_pipe->base.delete_sampler_state = rbug_delete_sampler_state;
1216    rb_pipe->base.create_rasterizer_state = rbug_create_rasterizer_state;
1217    rb_pipe->base.bind_rasterizer_state = rbug_bind_rasterizer_state;
1218    rb_pipe->base.delete_rasterizer_state = rbug_delete_rasterizer_state;
1219    rb_pipe->base.create_depth_stencil_alpha_state = rbug_create_depth_stencil_alpha_state;
1220    rb_pipe->base.bind_depth_stencil_alpha_state = rbug_bind_depth_stencil_alpha_state;
1221    rb_pipe->base.delete_depth_stencil_alpha_state = rbug_delete_depth_stencil_alpha_state;
1222    rb_pipe->base.create_fs_state = rbug_create_fs_state;
1223    rb_pipe->base.bind_fs_state = rbug_bind_fs_state;
1224    rb_pipe->base.delete_fs_state = rbug_delete_fs_state;
1225    rb_pipe->base.create_vs_state = rbug_create_vs_state;
1226    rb_pipe->base.bind_vs_state = rbug_bind_vs_state;
1227    rb_pipe->base.delete_vs_state = rbug_delete_vs_state;
1228    rb_pipe->base.create_gs_state = rbug_create_gs_state;
1229    rb_pipe->base.bind_gs_state = rbug_bind_gs_state;
1230    rb_pipe->base.delete_gs_state = rbug_delete_gs_state;
1231    rb_pipe->base.create_vertex_elements_state = rbug_create_vertex_elements_state;
1232    rb_pipe->base.bind_vertex_elements_state = rbug_bind_vertex_elements_state;
1233    rb_pipe->base.delete_vertex_elements_state = rbug_delete_vertex_elements_state;
1234    rb_pipe->base.set_blend_color = rbug_set_blend_color;
1235    rb_pipe->base.set_stencil_ref = rbug_set_stencil_ref;
1236    rb_pipe->base.set_clip_state = rbug_set_clip_state;
1237    rb_pipe->base.set_constant_buffer = rbug_set_constant_buffer;
1238    rb_pipe->base.set_framebuffer_state = rbug_set_framebuffer_state;
1239    rb_pipe->base.set_polygon_stipple = rbug_set_polygon_stipple;
1240    rb_pipe->base.set_scissor_states = rbug_set_scissor_states;
1241    rb_pipe->base.set_viewport_states = rbug_set_viewport_states;
1242    rb_pipe->base.set_sampler_views = rbug_set_sampler_views;
1243    rb_pipe->base.set_vertex_buffers = rbug_set_vertex_buffers;
1244    rb_pipe->base.set_sample_mask = rbug_set_sample_mask;
1245    rb_pipe->base.create_stream_output_target = rbug_create_stream_output_target;
1246    rb_pipe->base.stream_output_target_destroy = rbug_stream_output_target_destroy;
1247    rb_pipe->base.set_stream_output_targets = rbug_set_stream_output_targets;
1248    rb_pipe->base.resource_copy_region = rbug_resource_copy_region;
1249    rb_pipe->base.blit = rbug_blit;
1250    rb_pipe->base.flush_resource = rbug_flush_resource;
1251    rb_pipe->base.clear = rbug_clear;
1252    rb_pipe->base.clear_render_target = rbug_clear_render_target;
1253    rb_pipe->base.clear_depth_stencil = rbug_clear_depth_stencil;
1254    rb_pipe->base.flush = rbug_flush;
1255    rb_pipe->base.create_sampler_view = rbug_context_create_sampler_view;
1256    rb_pipe->base.sampler_view_destroy = rbug_context_sampler_view_destroy;
1257    rb_pipe->base.create_surface = rbug_context_create_surface;
1258    rb_pipe->base.surface_destroy = rbug_context_surface_destroy;
1259    rb_pipe->base.transfer_map = rbug_context_transfer_map;
1260    rb_pipe->base.transfer_unmap = rbug_context_transfer_unmap;
1261    rb_pipe->base.transfer_flush_region = rbug_context_transfer_flush_region;
1262    rb_pipe->base.buffer_subdata = rbug_context_buffer_subdata;
1263    rb_pipe->base.texture_subdata = rbug_context_texture_subdata;
1264
1265    rb_pipe->pipe = pipe;
1266
1267    rbug_screen_add_to_list(rb_screen, contexts, rb_pipe);
1268
1269    if (debug_get_bool_option("GALLIUM_RBUG_START_BLOCKED", false)) {
1270       rb_pipe->draw_blocked = RBUG_BLOCK_BEFORE;
1271    }
1272
1273    return &rb_pipe->base;
1274 }