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