rbug_context.c revision 96d882939d612fcc8332f107befec470ed4359de 
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
40static void
41rbug_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
55static void
56rbug_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
109static void
110rbug_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
129static struct pipe_query *
130rbug_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
142static void
143rbug_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
155static void
156rbug_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
168static void
169rbug_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
181static boolean
182rbug_get_query_result(struct pipe_context *_pipe,
183                      struct pipe_query *query,
184                      boolean wait,
185                      void *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
201static void *
202rbug_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
217static void
218rbug_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
230static void
231rbug_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
243static void *
244rbug_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
259static void
260rbug_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
274static void
275rbug_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
289static void
290rbug_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
302static void *
303rbug_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
318static void
319rbug_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
331static void
332rbug_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
344static void *
345rbug_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
360static void
361rbug_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
373static void
374rbug_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
386static void *
387rbug_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
404static void
405rbug_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
422static void
423rbug_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
434static void *
435rbug_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
452static void
453rbug_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
470static void
471rbug_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
482static void *
483rbug_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
500static void
501rbug_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
518static void
519rbug_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
530static void *
531rbug_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
548static void
549rbug_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
561static void
562rbug_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
574static void
575rbug_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
587static void
588rbug_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
600static void
601rbug_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
613static void
614rbug_set_constant_buffer(struct pipe_context *_pipe,
615                         uint shader,
616                         uint index,
617                         struct pipe_resource *_resource)
618{
619   struct rbug_context *rb_pipe = rbug_context(_pipe);
620   struct pipe_context *pipe = rb_pipe->pipe;
621   struct pipe_resource *unwrapped_resource;
622   struct pipe_resource *resource = NULL;
623
624   /* XXX hmm? unwrap the input state */
625   if (_resource) {
626      unwrapped_resource = rbug_resource_unwrap(_resource);
627      resource = unwrapped_resource;
628   }
629
630   pipe_mutex_lock(rb_pipe->call_mutex);
631   pipe->set_constant_buffer(pipe,
632                             shader,
633                             index,
634                             resource);
635   pipe_mutex_unlock(rb_pipe->call_mutex);
636}
637
638static void
639rbug_set_framebuffer_state(struct pipe_context *_pipe,
640                           const struct pipe_framebuffer_state *_state)
641{
642   struct rbug_context *rb_pipe = rbug_context(_pipe);
643   struct pipe_context *pipe = rb_pipe->pipe;
644   struct pipe_framebuffer_state unwrapped_state;
645   struct pipe_framebuffer_state *state = NULL;
646   unsigned i;
647
648   /* must protect curr status */
649   pipe_mutex_lock(rb_pipe->call_mutex);
650
651   rb_pipe->curr.nr_cbufs = 0;
652   memset(rb_pipe->curr.cbufs, 0, sizeof(rb_pipe->curr.cbufs));
653   rb_pipe->curr.zsbuf = NULL;
654
655   /* unwrap the input state */
656   if (_state) {
657      memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
658
659      rb_pipe->curr.nr_cbufs = _state->nr_cbufs;
660      for(i = 0; i < _state->nr_cbufs; i++) {
661         unwrapped_state.cbufs[i] = rbug_surface_unwrap(_state->cbufs[i]);
662         if (_state->cbufs[i])
663            rb_pipe->curr.cbufs[i] = rbug_resource(_state->cbufs[i]->texture);
664      }
665      unwrapped_state.zsbuf = rbug_surface_unwrap(_state->zsbuf);
666      if (_state->zsbuf)
667         rb_pipe->curr.zsbuf = rbug_resource(_state->zsbuf->texture);
668      state = &unwrapped_state;
669   }
670
671   pipe->set_framebuffer_state(pipe,
672                               state);
673
674   pipe_mutex_unlock(rb_pipe->call_mutex);
675}
676
677static void
678rbug_set_polygon_stipple(struct pipe_context *_pipe,
679                         const struct pipe_poly_stipple *poly_stipple)
680{
681   struct rbug_context *rb_pipe = rbug_context(_pipe);
682   struct pipe_context *pipe = rb_pipe->pipe;
683
684   pipe_mutex_lock(rb_pipe->call_mutex);
685   pipe->set_polygon_stipple(pipe,
686                             poly_stipple);
687   pipe_mutex_unlock(rb_pipe->call_mutex);
688}
689
690static void
691rbug_set_scissor_state(struct pipe_context *_pipe,
692                       const struct pipe_scissor_state *scissor)
693{
694   struct rbug_context *rb_pipe = rbug_context(_pipe);
695   struct pipe_context *pipe = rb_pipe->pipe;
696
697   pipe_mutex_lock(rb_pipe->call_mutex);
698   pipe->set_scissor_state(pipe,
699                           scissor);
700   pipe_mutex_unlock(rb_pipe->call_mutex);
701}
702
703static void
704rbug_set_viewport_state(struct pipe_context *_pipe,
705                        const struct pipe_viewport_state *viewport)
706{
707   struct rbug_context *rb_pipe = rbug_context(_pipe);
708   struct pipe_context *pipe = rb_pipe->pipe;
709
710   pipe_mutex_lock(rb_pipe->call_mutex);
711   pipe->set_viewport_state(pipe,
712                            viewport);
713   pipe_mutex_unlock(rb_pipe->call_mutex);
714}
715
716static void
717rbug_set_fragment_sampler_views(struct pipe_context *_pipe,
718                                unsigned num,
719                                struct pipe_sampler_view **_views)
720{
721   struct rbug_context *rb_pipe = rbug_context(_pipe);
722   struct pipe_context *pipe = rb_pipe->pipe;
723   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
724   struct pipe_sampler_view **views = NULL;
725   unsigned i;
726
727   /* must protect curr status */
728   pipe_mutex_lock(rb_pipe->call_mutex);
729
730   rb_pipe->curr.num_fs_views = 0;
731   memset(rb_pipe->curr.fs_views, 0, sizeof(rb_pipe->curr.fs_views));
732   memset(rb_pipe->curr.fs_texs, 0, sizeof(rb_pipe->curr.fs_texs));
733   memset(unwrapped_views, 0, sizeof(unwrapped_views));
734
735   if (_views) {
736      rb_pipe->curr.num_fs_views = num;
737      for (i = 0; i < num; i++) {
738         rb_pipe->curr.fs_views[i] = rbug_sampler_view(_views[i]);
739         rb_pipe->curr.fs_texs[i] = rbug_resource(_views[i] ? _views[i]->texture : NULL);
740         unwrapped_views[i] = rbug_sampler_view_unwrap(_views[i]);
741      }
742      views = unwrapped_views;
743   }
744
745   pipe->set_fragment_sampler_views(pipe, num, views);
746
747   pipe_mutex_unlock(rb_pipe->call_mutex);
748}
749
750static void
751rbug_set_vertex_sampler_views(struct pipe_context *_pipe,
752                              unsigned num,
753                              struct pipe_sampler_view **_views)
754{
755   struct rbug_context *rb_pipe = rbug_context(_pipe);
756   struct pipe_context *pipe = rb_pipe->pipe;
757   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
758   struct pipe_sampler_view **views = NULL;
759   unsigned i;
760
761   /* must protect curr status */
762   pipe_mutex_lock(rb_pipe->call_mutex);
763
764   rb_pipe->curr.num_vs_views = 0;
765   memset(rb_pipe->curr.vs_views, 0, sizeof(rb_pipe->curr.vs_views));
766   memset(rb_pipe->curr.vs_texs, 0, sizeof(rb_pipe->curr.vs_texs));
767   memset(unwrapped_views, 0, sizeof(unwrapped_views));
768
769   if (_views) {
770      rb_pipe->curr.num_vs_views = num;
771      for (i = 0; i < num; i++) {
772         rb_pipe->curr.vs_views[i] = rbug_sampler_view(_views[i]);
773         rb_pipe->curr.vs_texs[i] = rbug_resource(_views[i]->texture);
774         unwrapped_views[i] = rbug_sampler_view_unwrap(_views[i]);
775      }
776      views = unwrapped_views;
777   }
778
779   pipe->set_vertex_sampler_views(pipe, num, views);
780
781   pipe_mutex_unlock(rb_pipe->call_mutex);
782}
783
784static void
785rbug_set_vertex_buffers(struct pipe_context *_pipe,
786                        unsigned num_buffers,
787                        const struct pipe_vertex_buffer *_buffers)
788{
789   struct rbug_context *rb_pipe = rbug_context(_pipe);
790   struct pipe_context *pipe = rb_pipe->pipe;
791   struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
792   struct pipe_vertex_buffer *buffers = NULL;
793   unsigned i;
794
795   pipe_mutex_lock(rb_pipe->call_mutex);
796
797   if (num_buffers) {
798      memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
799      for (i = 0; i < num_buffers; i++)
800         unwrapped_buffers[i].buffer = rbug_resource_unwrap(_buffers[i].buffer);
801      buffers = unwrapped_buffers;
802   }
803
804   pipe->set_vertex_buffers(pipe,
805                            num_buffers,
806                            buffers);
807
808   pipe_mutex_unlock(rb_pipe->call_mutex);
809}
810
811static void
812rbug_set_index_buffer(struct pipe_context *_pipe,
813                      const struct pipe_index_buffer *_ib)
814{
815   struct rbug_context *rb_pipe = rbug_context(_pipe);
816   struct pipe_context *pipe = rb_pipe->pipe;
817   struct pipe_index_buffer unwrapped_ib, *ib = NULL;
818
819   if (_ib) {
820      unwrapped_ib = *_ib;
821      unwrapped_ib.buffer = rbug_resource_unwrap(_ib->buffer);
822      ib = &unwrapped_ib;
823   }
824
825   pipe_mutex_lock(rb_pipe->call_mutex);
826   pipe->set_index_buffer(pipe, ib);
827   pipe_mutex_unlock(rb_pipe->call_mutex);
828}
829
830static void
831rbug_set_sample_mask(struct pipe_context *_pipe,
832                     unsigned sample_mask)
833{
834   struct rbug_context *rb_pipe = rbug_context(_pipe);
835   struct pipe_context *pipe = rb_pipe->pipe;
836
837   pipe_mutex_lock(rb_pipe->call_mutex);
838   pipe->set_sample_mask(pipe, sample_mask);
839   pipe_mutex_unlock(rb_pipe->call_mutex);
840}
841
842static void
843rbug_resource_copy_region(struct pipe_context *_pipe,
844                          struct pipe_resource *_dst,
845                          unsigned dst_level,
846                          unsigned dstx,
847                          unsigned dsty,
848                          unsigned dstz,
849                          struct pipe_resource *_src,
850                          unsigned src_level,
851                          const struct pipe_box *src_box)
852{
853   struct rbug_context *rb_pipe = rbug_context(_pipe);
854   struct rbug_resource *rb_resource_dst = rbug_resource(_dst);
855   struct rbug_resource *rb_resource_src = rbug_resource(_src);
856   struct pipe_context *pipe = rb_pipe->pipe;
857   struct pipe_resource *dst = rb_resource_dst->resource;
858   struct pipe_resource *src = rb_resource_src->resource;
859
860   pipe_mutex_lock(rb_pipe->call_mutex);
861   pipe->resource_copy_region(pipe,
862                              dst,
863                              dst_level,
864                              dstx,
865                              dsty,
866                              dstz,
867                              src,
868                              src_level,
869                              src_box);
870   pipe_mutex_unlock(rb_pipe->call_mutex);
871}
872
873static void
874rbug_clear(struct pipe_context *_pipe,
875           unsigned buffers,
876           const union pipe_color_union *color,
877           double depth,
878           unsigned stencil)
879{
880   struct rbug_context *rb_pipe = rbug_context(_pipe);
881   struct pipe_context *pipe = rb_pipe->pipe;
882
883   pipe_mutex_lock(rb_pipe->call_mutex);
884   pipe->clear(pipe,
885               buffers,
886               color,
887               depth,
888               stencil);
889   pipe_mutex_unlock(rb_pipe->call_mutex);
890}
891
892static void
893rbug_clear_render_target(struct pipe_context *_pipe,
894                         struct pipe_surface *_dst,
895                         const union pipe_color_union *color,
896                         unsigned dstx, unsigned dsty,
897                         unsigned width, unsigned height)
898{
899   struct rbug_context *rb_pipe = rbug_context(_pipe);
900   struct rbug_surface *rb_surface_dst = rbug_surface(_dst);
901   struct pipe_context *pipe = rb_pipe->pipe;
902   struct pipe_surface *dst = rb_surface_dst->surface;
903
904   pipe_mutex_lock(rb_pipe->call_mutex);
905   pipe->clear_render_target(pipe,
906                             dst,
907                             color,
908                             dstx,
909                             dsty,
910                             width,
911                             height);
912   pipe_mutex_unlock(rb_pipe->call_mutex);
913}
914
915static void
916rbug_clear_depth_stencil(struct pipe_context *_pipe,
917                         struct pipe_surface *_dst,
918                         unsigned clear_flags,
919                         double depth,
920                         unsigned stencil,
921                         unsigned dstx, unsigned dsty,
922                         unsigned width, unsigned height)
923{
924   struct rbug_context *rb_pipe = rbug_context(_pipe);
925   struct rbug_surface *rb_surface_dst = rbug_surface(_dst);
926   struct pipe_context *pipe = rb_pipe->pipe;
927   struct pipe_surface *dst = rb_surface_dst->surface;
928
929   pipe_mutex_lock(rb_pipe->call_mutex);
930   pipe->clear_depth_stencil(pipe,
931                             dst,
932                             clear_flags,
933                             depth,
934                             stencil,
935                             dstx,
936                             dsty,
937                             width,
938                             height);
939   pipe_mutex_unlock(rb_pipe->call_mutex);
940}
941
942static void
943rbug_flush(struct pipe_context *_pipe,
944           struct pipe_fence_handle **fence)
945{
946   struct rbug_context *rb_pipe = rbug_context(_pipe);
947   struct pipe_context *pipe = rb_pipe->pipe;
948
949   pipe_mutex_lock(rb_pipe->call_mutex);
950   pipe->flush(pipe,
951               fence);
952   pipe_mutex_unlock(rb_pipe->call_mutex);
953}
954
955static struct pipe_sampler_view *
956rbug_context_create_sampler_view(struct pipe_context *_pipe,
957                                 struct pipe_resource *_resource,
958                                 const struct pipe_sampler_view *templ)
959{
960   struct rbug_context *rb_pipe = rbug_context(_pipe);
961   struct rbug_resource *rb_resource = rbug_resource(_resource);
962   struct pipe_context *pipe = rb_pipe->pipe;
963   struct pipe_resource *resource = rb_resource->resource;
964   struct pipe_sampler_view *result;
965
966   pipe_mutex_lock(rb_pipe->call_mutex);
967   result = pipe->create_sampler_view(pipe,
968                                      resource,
969                                      templ);
970   pipe_mutex_unlock(rb_pipe->call_mutex);
971
972   if (result)
973      return rbug_sampler_view_create(rb_pipe, rb_resource, result);
974   return NULL;
975}
976
977static void
978rbug_context_sampler_view_destroy(struct pipe_context *_pipe,
979                                  struct pipe_sampler_view *_view)
980{
981   rbug_sampler_view_destroy(rbug_context(_pipe),
982                             rbug_sampler_view(_view));
983}
984
985static struct pipe_surface *
986rbug_context_create_surface(struct pipe_context *_pipe,
987                            struct pipe_resource *_resource,
988                            const struct pipe_surface *surf_tmpl)
989{
990   struct rbug_context *rb_pipe = rbug_context(_pipe);
991   struct rbug_resource *rb_resource = rbug_resource(_resource);
992   struct pipe_context *pipe = rb_pipe->pipe;
993   struct pipe_resource *resource = rb_resource->resource;
994   struct pipe_surface *result;
995
996   pipe_mutex_lock(rb_pipe->call_mutex);
997   result = pipe->create_surface(pipe,
998                                 resource,
999                                 surf_tmpl);
1000   pipe_mutex_unlock(rb_pipe->call_mutex);
1001
1002   if (result)
1003      return rbug_surface_create(rb_pipe, rb_resource, result);
1004   return NULL;
1005}
1006
1007static void
1008rbug_context_surface_destroy(struct pipe_context *_pipe,
1009                             struct pipe_surface *_surface)
1010{
1011   struct rbug_context *rb_pipe = rbug_context(_pipe);
1012   struct rbug_surface *rb_surface = rbug_surface(_surface);
1013
1014   pipe_mutex_lock(rb_pipe->call_mutex);
1015   rbug_surface_destroy(rb_pipe,
1016                        rb_surface);
1017   pipe_mutex_unlock(rb_pipe->call_mutex);
1018}
1019
1020
1021
1022static struct pipe_transfer *
1023rbug_context_get_transfer(struct pipe_context *_context,
1024                          struct pipe_resource *_resource,
1025                          unsigned level,
1026                          unsigned usage,
1027                          const struct pipe_box *box)
1028{
1029   struct rbug_context *rb_pipe = rbug_context(_context);
1030   struct rbug_resource *rb_resource = rbug_resource(_resource);
1031   struct pipe_context *context = rb_pipe->pipe;
1032   struct pipe_resource *resource = rb_resource->resource;
1033   struct pipe_transfer *result;
1034
1035   pipe_mutex_lock(rb_pipe->call_mutex);
1036   result = context->get_transfer(context,
1037                                  resource,
1038                                  level,
1039                                  usage,
1040                                  box);
1041   pipe_mutex_unlock(rb_pipe->call_mutex);
1042
1043   if (result)
1044      return rbug_transfer_create(rb_pipe, rb_resource, result);
1045   return NULL;
1046}
1047
1048static void
1049rbug_context_transfer_destroy(struct pipe_context *_pipe,
1050                              struct pipe_transfer *_transfer)
1051{
1052   struct rbug_context *rb_pipe = rbug_context(_pipe);
1053   struct rbug_transfer *rb_transfer =rbug_transfer(_transfer);
1054
1055   pipe_mutex_lock(rb_pipe->call_mutex);
1056   rbug_transfer_destroy(rb_pipe,
1057                         rb_transfer);
1058   pipe_mutex_unlock(rb_pipe->call_mutex);
1059}
1060
1061static void *
1062rbug_context_transfer_map(struct pipe_context *_context,
1063                          struct pipe_transfer *_transfer)
1064{
1065   struct rbug_context *rb_pipe = rbug_context(_context);
1066   struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
1067   struct pipe_context *context = rb_pipe->pipe;
1068   struct pipe_transfer *transfer = rb_transfer->transfer;
1069   void *ret;
1070
1071   pipe_mutex_lock(rb_pipe->call_mutex);
1072   ret = context->transfer_map(context,
1073                                transfer);
1074   pipe_mutex_unlock(rb_pipe->call_mutex);
1075
1076   return ret;
1077}
1078
1079
1080
1081static void
1082rbug_context_transfer_flush_region(struct pipe_context *_context,
1083                                   struct pipe_transfer *_transfer,
1084                                   const struct pipe_box *box)
1085{
1086   struct rbug_context *rb_pipe = rbug_context(_context);
1087   struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
1088   struct pipe_context *context = rb_pipe->pipe;
1089   struct pipe_transfer *transfer = rb_transfer->transfer;
1090
1091   pipe_mutex_lock(rb_pipe->call_mutex);
1092   context->transfer_flush_region(context,
1093                                  transfer,
1094                                  box);
1095   pipe_mutex_unlock(rb_pipe->call_mutex);
1096}
1097
1098
1099static void
1100rbug_context_transfer_unmap(struct pipe_context *_context,
1101                            struct pipe_transfer *_transfer)
1102{
1103   struct rbug_context *rb_pipe = rbug_context(_context);
1104   struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
1105   struct pipe_context *context = rb_pipe->pipe;
1106   struct pipe_transfer *transfer = rb_transfer->transfer;
1107
1108   pipe_mutex_lock(rb_pipe->call_mutex);
1109   context->transfer_unmap(context,
1110                           transfer);
1111   pipe_mutex_unlock(rb_pipe->call_mutex);
1112}
1113
1114
1115static void
1116rbug_context_transfer_inline_write(struct pipe_context *_context,
1117                                   struct pipe_resource *_resource,
1118                                   unsigned level,
1119                                   unsigned usage,
1120                                   const struct pipe_box *box,
1121                                   const void *data,
1122                                   unsigned stride,
1123                                   unsigned layer_stride)
1124{
1125   struct rbug_context *rb_pipe = rbug_context(_context);
1126   struct rbug_resource *rb_resource = rbug_resource(_resource);
1127   struct pipe_context *context = rb_pipe->pipe;
1128   struct pipe_resource *resource = rb_resource->resource;
1129
1130   pipe_mutex_lock(rb_pipe->call_mutex);
1131   context->transfer_inline_write(context,
1132                                  resource,
1133                                  level,
1134                                  usage,
1135                                  box,
1136                                  data,
1137                                  stride,
1138                                  layer_stride);
1139   pipe_mutex_unlock(rb_pipe->call_mutex);
1140}
1141
1142
1143static void rbug_redefine_user_buffer(struct pipe_context *_context,
1144                                      struct pipe_resource *_resource,
1145                                      unsigned offset, unsigned size)
1146{
1147   struct rbug_context *rb_pipe = rbug_context(_context);
1148   struct rbug_resource *rb_resource = rbug_resource(_resource);
1149   struct pipe_context *context = rb_pipe->pipe;
1150   struct pipe_resource *resource = rb_resource->resource;
1151
1152   pipe_mutex_lock(rb_pipe->call_mutex);
1153   context->redefine_user_buffer(context, resource, offset, size);
1154   pipe_mutex_unlock(rb_pipe->call_mutex);
1155}
1156
1157
1158struct pipe_context *
1159rbug_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
1160{
1161   struct rbug_context *rb_pipe;
1162   struct rbug_screen *rb_screen = rbug_screen(_screen);
1163
1164   if (!rb_screen)
1165      return NULL;
1166
1167   rb_pipe = CALLOC_STRUCT(rbug_context);
1168   if (!rb_pipe)
1169      return NULL;
1170
1171   pipe_mutex_init(rb_pipe->draw_mutex);
1172   pipe_condvar_init(rb_pipe->draw_cond);
1173   pipe_mutex_init(rb_pipe->call_mutex);
1174   pipe_mutex_init(rb_pipe->list_mutex);
1175   make_empty_list(&rb_pipe->shaders);
1176
1177   rb_pipe->base.screen = _screen;
1178   rb_pipe->base.priv = pipe->priv; /* expose wrapped data */
1179   rb_pipe->base.draw = NULL;
1180
1181   rb_pipe->base.destroy = rbug_destroy;
1182   rb_pipe->base.draw_vbo = rbug_draw_vbo;
1183   rb_pipe->base.create_query = rbug_create_query;
1184   rb_pipe->base.destroy_query = rbug_destroy_query;
1185   rb_pipe->base.begin_query = rbug_begin_query;
1186   rb_pipe->base.end_query = rbug_end_query;
1187   rb_pipe->base.get_query_result = rbug_get_query_result;
1188   rb_pipe->base.create_blend_state = rbug_create_blend_state;
1189   rb_pipe->base.bind_blend_state = rbug_bind_blend_state;
1190   rb_pipe->base.delete_blend_state = rbug_delete_blend_state;
1191   rb_pipe->base.create_sampler_state = rbug_create_sampler_state;
1192   rb_pipe->base.bind_fragment_sampler_states = rbug_bind_fragment_sampler_states;
1193   rb_pipe->base.bind_vertex_sampler_states = rbug_bind_vertex_sampler_states;
1194   rb_pipe->base.delete_sampler_state = rbug_delete_sampler_state;
1195   rb_pipe->base.create_rasterizer_state = rbug_create_rasterizer_state;
1196   rb_pipe->base.bind_rasterizer_state = rbug_bind_rasterizer_state;
1197   rb_pipe->base.delete_rasterizer_state = rbug_delete_rasterizer_state;
1198   rb_pipe->base.create_depth_stencil_alpha_state = rbug_create_depth_stencil_alpha_state;
1199   rb_pipe->base.bind_depth_stencil_alpha_state = rbug_bind_depth_stencil_alpha_state;
1200   rb_pipe->base.delete_depth_stencil_alpha_state = rbug_delete_depth_stencil_alpha_state;
1201   rb_pipe->base.create_fs_state = rbug_create_fs_state;
1202   rb_pipe->base.bind_fs_state = rbug_bind_fs_state;
1203   rb_pipe->base.delete_fs_state = rbug_delete_fs_state;
1204   rb_pipe->base.create_vs_state = rbug_create_vs_state;
1205   rb_pipe->base.bind_vs_state = rbug_bind_vs_state;
1206   rb_pipe->base.delete_vs_state = rbug_delete_vs_state;
1207   rb_pipe->base.create_gs_state = rbug_create_gs_state;
1208   rb_pipe->base.bind_gs_state = rbug_bind_gs_state;
1209   rb_pipe->base.delete_gs_state = rbug_delete_gs_state;
1210   rb_pipe->base.create_vertex_elements_state = rbug_create_vertex_elements_state;
1211   rb_pipe->base.bind_vertex_elements_state = rbug_bind_vertex_elements_state;
1212   rb_pipe->base.delete_vertex_elements_state = rbug_delete_vertex_elements_state;
1213   rb_pipe->base.set_blend_color = rbug_set_blend_color;
1214   rb_pipe->base.set_stencil_ref = rbug_set_stencil_ref;
1215   rb_pipe->base.set_clip_state = rbug_set_clip_state;
1216   rb_pipe->base.set_constant_buffer = rbug_set_constant_buffer;
1217   rb_pipe->base.set_framebuffer_state = rbug_set_framebuffer_state;
1218   rb_pipe->base.set_polygon_stipple = rbug_set_polygon_stipple;
1219   rb_pipe->base.set_scissor_state = rbug_set_scissor_state;
1220   rb_pipe->base.set_viewport_state = rbug_set_viewport_state;
1221   rb_pipe->base.set_fragment_sampler_views = rbug_set_fragment_sampler_views;
1222   rb_pipe->base.set_vertex_sampler_views = rbug_set_vertex_sampler_views;
1223   rb_pipe->base.set_vertex_buffers = rbug_set_vertex_buffers;
1224   rb_pipe->base.set_index_buffer = rbug_set_index_buffer;
1225   rb_pipe->base.set_sample_mask = rbug_set_sample_mask;
1226   rb_pipe->base.resource_copy_region = rbug_resource_copy_region;
1227   rb_pipe->base.clear = rbug_clear;
1228   rb_pipe->base.clear_render_target = rbug_clear_render_target;
1229   rb_pipe->base.clear_depth_stencil = rbug_clear_depth_stencil;
1230   rb_pipe->base.flush = rbug_flush;
1231   rb_pipe->base.create_sampler_view = rbug_context_create_sampler_view;
1232   rb_pipe->base.sampler_view_destroy = rbug_context_sampler_view_destroy;
1233   rb_pipe->base.create_surface = rbug_context_create_surface;
1234   rb_pipe->base.surface_destroy = rbug_context_surface_destroy;
1235   rb_pipe->base.get_transfer = rbug_context_get_transfer;
1236   rb_pipe->base.transfer_destroy = rbug_context_transfer_destroy;
1237   rb_pipe->base.transfer_map = rbug_context_transfer_map;
1238   rb_pipe->base.transfer_unmap = rbug_context_transfer_unmap;
1239   rb_pipe->base.transfer_flush_region = rbug_context_transfer_flush_region;
1240   rb_pipe->base.transfer_inline_write = rbug_context_transfer_inline_write;
1241   rb_pipe->base.redefine_user_buffer = rbug_redefine_user_buffer;
1242
1243   rb_pipe->pipe = pipe;
1244
1245   rbug_screen_add_to_list(rb_screen, contexts, rb_pipe);
1246
1247   if (debug_get_bool_option("GALLIUM_RBUG_START_BLOCKED", FALSE)) {
1248      rb_pipe->draw_blocked = RBUG_BLOCK_BEFORE;
1249   }
1250
1251   return &rb_pipe->base;
1252}
1253