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