1/*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 2010 LunarG Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 *    Chia-I Wu <olv@lunarg.com>
26 */
27
28#include "xm_api.h"
29#include "xm_st.h"
30
31#include "util/u_inlines.h"
32#include "util/u_atomic.h"
33
34struct xmesa_st_framebuffer {
35   XMesaDisplay display;
36   XMesaBuffer buffer;
37   struct pipe_screen *screen;
38
39   struct st_visual stvis;
40   enum pipe_texture_target target;
41
42   unsigned texture_width, texture_height, texture_mask;
43   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
44
45   struct pipe_resource *display_resource;
46};
47
48
49static inline struct xmesa_st_framebuffer *
50xmesa_st_framebuffer(struct st_framebuffer_iface *stfbi)
51{
52   return (struct xmesa_st_framebuffer *) stfbi->st_manager_private;
53}
54
55
56/**
57 * Display (present) an attachment to the xlib_drawable of the framebuffer.
58 */
59static boolean
60xmesa_st_framebuffer_display(struct st_framebuffer_iface *stfbi,
61                             enum st_attachment_type statt)
62{
63   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
64   struct pipe_resource *ptex = xstfb->textures[statt];
65   struct pipe_resource *pres;
66
67   if (!ptex)
68      return TRUE;
69
70   pres = xstfb->display_resource;
71   /* (re)allocate the surface for the texture to be displayed */
72   if (!pres || pres != ptex) {
73      pipe_resource_reference(&xstfb->display_resource, ptex);
74      pres = xstfb->display_resource;
75   }
76
77   xstfb->screen->flush_frontbuffer(xstfb->screen, pres, 0, 0, &xstfb->buffer->ws, NULL);
78   return TRUE;
79}
80
81
82/**
83 * Copy the contents between the attachments.
84 */
85static void
86xmesa_st_framebuffer_copy_textures(struct st_framebuffer_iface *stfbi,
87                                   enum st_attachment_type src_statt,
88                                   enum st_attachment_type dst_statt,
89                                   unsigned x, unsigned y,
90                                   unsigned width, unsigned height)
91{
92   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
93   struct pipe_resource *src_ptex = xstfb->textures[src_statt];
94   struct pipe_resource *dst_ptex = xstfb->textures[dst_statt];
95   struct pipe_box src_box;
96   struct pipe_context *pipe;
97
98   if (!src_ptex || !dst_ptex)
99      return;
100
101   pipe = xmesa_get_context(stfbi);
102
103   u_box_2d(x, y, width, height, &src_box);
104
105   if (src_ptex && dst_ptex)
106      pipe->resource_copy_region(pipe, dst_ptex, 0, x, y, 0,
107                                 src_ptex, 0, &src_box);
108}
109
110
111/**
112 * Remove outdated textures and create the requested ones.
113 * This is a helper used during framebuffer validation.
114 */
115boolean
116xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
117                                       unsigned width, unsigned height,
118                                       unsigned mask)
119{
120   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
121   struct pipe_resource templ;
122   enum st_attachment_type i;
123
124   /* remove outdated textures */
125   if (xstfb->texture_width != width || xstfb->texture_height != height) {
126      for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
127         pipe_resource_reference(&xstfb->textures[i], NULL);
128   }
129
130   memset(&templ, 0, sizeof(templ));
131   templ.target = xstfb->target;
132   templ.width0 = width;
133   templ.height0 = height;
134   templ.depth0 = 1;
135   templ.array_size = 1;
136   templ.last_level = 0;
137
138   for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
139      enum pipe_format format;
140      unsigned bind;
141
142      /* the texture already exists or not requested */
143      if (xstfb->textures[i] || !(mask & (1 << i))) {
144         /* remember the texture */
145         if (xstfb->textures[i])
146            mask |= (1 << i);
147         continue;
148      }
149
150      switch (i) {
151      case ST_ATTACHMENT_FRONT_LEFT:
152      case ST_ATTACHMENT_BACK_LEFT:
153      case ST_ATTACHMENT_FRONT_RIGHT:
154      case ST_ATTACHMENT_BACK_RIGHT:
155         format = xstfb->stvis.color_format;
156         bind = PIPE_BIND_DISPLAY_TARGET |
157                     PIPE_BIND_RENDER_TARGET;
158         break;
159      case ST_ATTACHMENT_DEPTH_STENCIL:
160         format = xstfb->stvis.depth_stencil_format;
161         bind = PIPE_BIND_DEPTH_STENCIL;
162         break;
163      default:
164         format = PIPE_FORMAT_NONE;
165         break;
166      }
167
168      if (format != PIPE_FORMAT_NONE) {
169         templ.format = format;
170         templ.bind = bind;
171
172         xstfb->textures[i] =
173            xstfb->screen->resource_create(xstfb->screen, &templ);
174         if (!xstfb->textures[i])
175            return FALSE;
176      }
177   }
178
179   xstfb->texture_width = width;
180   xstfb->texture_height = height;
181   xstfb->texture_mask = mask;
182
183   return TRUE;
184}
185
186
187/**
188 * Check that a framebuffer's attachments match the window's size.
189 *
190 * Called via st_framebuffer_iface::validate()
191 *
192 * \param statts  array of framebuffer attachments
193 * \param count  number of framebuffer attachments in statts[]
194 * \param out  returns resources for each of the attachments
195 */
196static boolean
197xmesa_st_framebuffer_validate(struct st_context_iface *stctx,
198                              struct st_framebuffer_iface *stfbi,
199                              const enum st_attachment_type *statts,
200                              unsigned count,
201                              struct pipe_resource **out)
202{
203   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
204   unsigned statt_mask, new_mask, i;
205   boolean resized;
206   boolean ret;
207
208   /* build mask of ST_ATTACHMENT bits */
209   statt_mask = 0x0;
210   for (i = 0; i < count; i++)
211      statt_mask |= 1 << statts[i];
212
213   /* record newly allocated textures */
214   new_mask = statt_mask & ~xstfb->texture_mask;
215
216   /* If xmesa_strict_invalidate is not set, we will not yet have
217    * called XGetGeometry().  Do so here:
218    */
219   if (!xmesa_strict_invalidate)
220      xmesa_check_buffer_size(xstfb->buffer);
221
222   resized = (xstfb->buffer->width != xstfb->texture_width ||
223              xstfb->buffer->height != xstfb->texture_height);
224
225   /* revalidate textures */
226   if (resized || new_mask) {
227      ret = xmesa_st_framebuffer_validate_textures(stfbi,
228                  xstfb->buffer->width, xstfb->buffer->height, statt_mask);
229      if (!ret)
230         return ret;
231
232      if (!resized) {
233         enum st_attachment_type back, front;
234
235         back = ST_ATTACHMENT_BACK_LEFT;
236         front = ST_ATTACHMENT_FRONT_LEFT;
237         /* copy the contents if front is newly allocated and back is not */
238         if ((statt_mask & (1 << back)) &&
239             (new_mask & (1 << front)) &&
240             !(new_mask & (1 << back))) {
241            xmesa_st_framebuffer_copy_textures(stfbi, back, front,
242                  0, 0, xstfb->texture_width, xstfb->texture_height);
243         }
244      }
245   }
246
247   for (i = 0; i < count; i++) {
248      out[i] = NULL;
249      pipe_resource_reference(&out[i], xstfb->textures[statts[i]]);
250   }
251
252   return TRUE;
253}
254
255
256/**
257 * Called via st_framebuffer_iface::flush_front()
258 */
259static boolean
260xmesa_st_framebuffer_flush_front(struct st_context_iface *stctx,
261                                 struct st_framebuffer_iface *stfbi,
262                                 enum st_attachment_type statt)
263{
264   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
265   boolean ret;
266
267   ret = xmesa_st_framebuffer_display(stfbi, statt);
268
269   if (ret && xmesa_strict_invalidate)
270      xmesa_check_buffer_size(xstfb->buffer);
271
272   return ret;
273}
274
275
276struct st_framebuffer_iface *
277xmesa_create_st_framebuffer(XMesaDisplay xmdpy, XMesaBuffer b)
278{
279   struct st_framebuffer_iface *stfbi;
280   struct xmesa_st_framebuffer *xstfb;
281
282   assert(xmdpy->display == b->xm_visual->display);
283
284   stfbi = CALLOC_STRUCT(st_framebuffer_iface);
285   xstfb = CALLOC_STRUCT(xmesa_st_framebuffer);
286   if (!stfbi || !xstfb) {
287      free(stfbi);
288      free(xstfb);
289      return NULL;
290   }
291
292   xstfb->display = xmdpy;
293   xstfb->buffer = b;
294   xstfb->screen = xmdpy->screen;
295   xstfb->stvis = b->xm_visual->stvis;
296   if (xstfb->screen->get_param(xstfb->screen, PIPE_CAP_NPOT_TEXTURES))
297      xstfb->target = PIPE_TEXTURE_2D;
298   else
299      xstfb->target = PIPE_TEXTURE_RECT;
300
301   stfbi->visual = &xstfb->stvis;
302   stfbi->flush_front = xmesa_st_framebuffer_flush_front;
303   stfbi->validate = xmesa_st_framebuffer_validate;
304   p_atomic_set(&stfbi->stamp, 1);
305   stfbi->st_manager_private = (void *) xstfb;
306
307   return stfbi;
308}
309
310
311void
312xmesa_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
313{
314   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
315   int i;
316
317   pipe_resource_reference(&xstfb->display_resource, NULL);
318
319   for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
320      pipe_resource_reference(&xstfb->textures[i], NULL);
321
322   free(xstfb);
323   free(stfbi);
324}
325
326
327/**
328 * Return the pipe_surface which corresponds to the given
329 * framebuffer attachment.
330 */
331struct pipe_resource *
332xmesa_get_framebuffer_resource(struct st_framebuffer_iface *stfbi,
333                               enum st_attachment_type att)
334{
335   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
336   return xstfb->textures[att];
337}
338
339
340void
341xmesa_swap_st_framebuffer(struct st_framebuffer_iface *stfbi)
342{
343   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
344   boolean ret;
345
346   ret = xmesa_st_framebuffer_display(stfbi, ST_ATTACHMENT_BACK_LEFT);
347   if (ret) {
348      struct pipe_resource **front, **back, *tmp;
349
350      front = &xstfb->textures[ST_ATTACHMENT_FRONT_LEFT];
351      back = &xstfb->textures[ST_ATTACHMENT_BACK_LEFT];
352      /* swap textures only if the front texture has been allocated */
353      if (*front) {
354         tmp = *front;
355         *front = *back;
356         *back = tmp;
357
358         /* the current context should validate the buffer after swapping */
359         if (!xmesa_strict_invalidate)
360            xmesa_notify_invalid_buffer(xstfb->buffer);
361      }
362
363      if (xmesa_strict_invalidate)
364	 xmesa_check_buffer_size(xstfb->buffer);
365   }
366}
367
368
369void
370xmesa_copy_st_framebuffer(struct st_framebuffer_iface *stfbi,
371                          enum st_attachment_type src,
372                          enum st_attachment_type dst,
373                          int x, int y, int w, int h)
374{
375   xmesa_st_framebuffer_copy_textures(stfbi, src, dst, x, y, w, h);
376   if (dst == ST_ATTACHMENT_FRONT_LEFT)
377      xmesa_st_framebuffer_display(stfbi, dst);
378}
379
380
381struct pipe_resource*
382xmesa_get_attachment(struct st_framebuffer_iface *stfbi,
383                     enum st_attachment_type st_attachment)
384{
385   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
386   struct pipe_resource *res;
387
388   res = xstfb->textures[st_attachment];
389   return res;
390}
391
392
393struct pipe_context*
394xmesa_get_context(struct st_framebuffer_iface *stfbi)
395{
396   struct pipe_context *pipe;
397   struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
398
399   pipe = xstfb->display->pipe;
400   if (!pipe) {
401      pipe = xstfb->screen->context_create(xstfb->screen, NULL, 0);
402      if (!pipe)
403         return NULL;
404      xstfb->display->pipe = pipe;
405   }
406   return pipe;
407}
408