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