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