vg_manager.c revision f80c2874eca86a12517fbe2f4c15287edfb4dc89 
1/*
2 * Mesa 3-D graphics library
3 * Version:  7.9
4 *
5 * Copyright 2009 VMware, Inc.  All Rights Reserved.
6 * Copyright (C) 2010 LunarG Inc.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 * DEALINGS IN THE SOFTWARE.
25 *
26 * Authors:
27 *    Chia-I Wu <olv@lunarg.com>
28 */
29
30#include "state_tracker/st_api.h"
31
32#include "pipe/p_context.h"
33#include "pipe/p_screen.h"
34#include "util/u_memory.h"
35#include "util/u_inlines.h"
36#include "util/u_box.h"
37#include "util/u_surface.h"
38
39#include "vg_api.h"
40#include "vg_manager.h"
41#include "vg_context.h"
42#include "api.h"
43#include "handle.h"
44
45static boolean
46vg_context_update_color_rb(struct vg_context *ctx, struct pipe_resource *pt)
47{
48   struct st_renderbuffer *strb = ctx->draw_buffer->strb;
49   struct pipe_context *pipe = ctx->pipe;
50   struct pipe_surface surf_tmpl;
51
52   if (strb->texture == pt) {
53      pipe_resource_reference(&pt, NULL);
54      return FALSE;
55   }
56
57   /* unreference existing ones */
58   pipe_surface_reference(&strb->surface, NULL);
59   pipe_resource_reference(&strb->texture, NULL);
60   strb->width = strb->height = 0;
61
62   strb->texture = pt;
63
64   memset(&surf_tmpl, 0, sizeof(surf_tmpl));
65   u_surface_default_template(&surf_tmpl, strb->texture,
66                              PIPE_BIND_RENDER_TARGET);
67   strb->surface = pipe->create_surface(pipe, strb->texture, &surf_tmpl);
68
69   if (!strb->surface) {
70      pipe_resource_reference(&strb->texture, NULL);
71      return TRUE;
72   }
73
74   strb->width = pt->width0;
75   strb->height = pt->height0;
76
77   return TRUE;
78}
79
80/**
81 * Flush the front buffer if the current context renders to the front buffer.
82 */
83void
84vg_manager_flush_frontbuffer(struct vg_context *ctx)
85{
86   struct st_framebuffer *stfb = ctx->draw_buffer;
87
88   if (!stfb)
89      return;
90
91   switch (stfb->strb_att) {
92   case ST_ATTACHMENT_FRONT_LEFT:
93   case ST_ATTACHMENT_FRONT_RIGHT:
94      stfb->iface->flush_front(stfb->iface, stfb->strb_att);
95      break;
96   default:
97      break;
98   }
99}
100
101/**
102 * Re-validate the framebuffer.
103 */
104void
105vg_manager_validate_framebuffer(struct vg_context *ctx)
106{
107   struct st_framebuffer *stfb = ctx->draw_buffer;
108   struct pipe_resource *pt;
109   int32_t new_stamp;
110
111   /* no binding surface */
112   if (!stfb)
113      return;
114
115   new_stamp = p_atomic_read(&stfb->iface->stamp);
116   if (stfb->iface_stamp != new_stamp) {
117      do {
118	 /* validate the fb */
119	 if (!stfb->iface->validate(stfb->iface, &stfb->strb_att,
120				    1, &pt) || !pt)
121	    return;
122
123	 stfb->iface_stamp = new_stamp;
124	 new_stamp = p_atomic_read(&stfb->iface->stamp);
125
126      } while (stfb->iface_stamp != new_stamp);
127
128      if (vg_context_update_color_rb(ctx, pt) ||
129          stfb->width != pt->width0 ||
130          stfb->height != pt->height0)
131         ++stfb->stamp;
132
133      stfb->width = pt->width0;
134      stfb->height = pt->height0;
135   }
136
137   if (ctx->draw_stamp != stfb->stamp) {
138      ctx->state.dirty |= FRAMEBUFFER_DIRTY;
139      ctx->draw_stamp = stfb->stamp;
140   }
141}
142
143static void
144vg_context_flush(struct st_context_iface *stctxi, unsigned flags,
145                 struct pipe_fence_handle **fence)
146{
147   struct vg_context *ctx = (struct vg_context *) stctxi;
148   ctx->pipe->flush(ctx->pipe, fence);
149   if (flags & ST_FLUSH_FRONT)
150      vg_manager_flush_frontbuffer(ctx);
151}
152
153static void
154vg_context_destroy(struct st_context_iface *stctxi)
155{
156   struct vg_context *ctx = (struct vg_context *) stctxi;
157   struct pipe_context *pipe = ctx->pipe;
158
159   vg_destroy_context(ctx);
160   pipe->destroy(pipe);
161}
162
163static struct st_context_iface *
164vg_api_create_context(struct st_api *stapi, struct st_manager *smapi,
165                      const struct st_context_attribs *attribs,
166                      enum st_context_error *error,
167                      struct st_context_iface *shared_stctxi)
168{
169   struct vg_context *shared_ctx = (struct vg_context *) shared_stctxi;
170   struct vg_context *ctx;
171   struct pipe_context *pipe;
172
173   if (!(stapi->profile_mask & (1 << attribs->profile))) {
174      *error = ST_CONTEXT_ERROR_BAD_API;
175      return NULL;
176   }
177
178   /* only 1.0 is supported */
179   if (attribs->major > 1 || (attribs->major == 1 && attribs->minor > 0)) {
180      *error = ST_CONTEXT_ERROR_BAD_VERSION;
181      return NULL;
182   }
183
184   /* for VGHandle / pointer lookups */
185   init_handles();
186
187   pipe = smapi->screen->context_create(smapi->screen, NULL);
188   if (!pipe) {
189      *error = ST_CONTEXT_ERROR_NO_MEMORY;
190      return NULL;
191   }
192   ctx = vg_create_context(pipe, NULL, shared_ctx);
193   if (!ctx) {
194      pipe->destroy(pipe);
195      *error = ST_CONTEXT_ERROR_NO_MEMORY;
196      return NULL;
197   }
198
199   ctx->iface.destroy = vg_context_destroy;
200
201   ctx->iface.flush = vg_context_flush;
202
203   ctx->iface.teximage = NULL;
204   ctx->iface.copy = NULL;
205
206   ctx->iface.st_context_private = (void *) smapi;
207
208   return &ctx->iface;
209}
210
211static struct st_renderbuffer *
212create_renderbuffer(enum pipe_format format)
213{
214   struct st_renderbuffer *strb;
215
216   strb = CALLOC_STRUCT(st_renderbuffer);
217   if (strb)
218      strb->format = format;
219
220   return strb;
221}
222
223static void
224destroy_renderbuffer(struct st_renderbuffer *strb)
225{
226   pipe_surface_reference(&strb->surface, NULL);
227   pipe_resource_reference(&strb->texture, NULL);
228   FREE(strb);
229}
230
231/**
232 * Decide the buffer to render to.
233 */
234static enum st_attachment_type
235choose_attachment(struct st_framebuffer_iface *stfbi)
236{
237   enum st_attachment_type statt;
238
239   statt = stfbi->visual->render_buffer;
240   if (statt != ST_ATTACHMENT_INVALID) {
241      /* use the buffer given by the visual, unless it is unavailable */
242      if (!st_visual_have_buffers(stfbi->visual, 1 << statt)) {
243         switch (statt) {
244         case ST_ATTACHMENT_BACK_LEFT:
245            statt = ST_ATTACHMENT_FRONT_LEFT;
246            break;
247         case ST_ATTACHMENT_BACK_RIGHT:
248            statt = ST_ATTACHMENT_FRONT_RIGHT;
249            break;
250         default:
251            break;
252         }
253
254         if (!st_visual_have_buffers(stfbi->visual, 1 << statt))
255            statt = ST_ATTACHMENT_INVALID;
256      }
257   }
258
259   return statt;
260}
261
262/**
263 * Bind the context to the given framebuffers.
264 */
265static boolean
266vg_context_bind_framebuffers(struct st_context_iface *stctxi,
267                             struct st_framebuffer_iface *stdrawi,
268                             struct st_framebuffer_iface *streadi)
269{
270   struct vg_context *ctx = (struct vg_context *) stctxi;
271   struct st_framebuffer *stfb;
272   enum st_attachment_type strb_att;
273
274   /* the draw and read framebuffers must be the same */
275   if (stdrawi != streadi)
276      return FALSE;
277
278   strb_att = (stdrawi) ? choose_attachment(stdrawi) : ST_ATTACHMENT_INVALID;
279
280   if (ctx->draw_buffer) {
281      stfb = ctx->draw_buffer;
282
283      /* free the existing fb */
284      if (!stdrawi ||
285          stfb->strb_att != strb_att ||
286          stfb->strb->format != stdrawi->visual->color_format) {
287         destroy_renderbuffer(stfb->strb);
288         destroy_renderbuffer(stfb->dsrb);
289         FREE(stfb);
290
291         ctx->draw_buffer = NULL;
292      }
293   }
294
295   if (!stdrawi)
296      return TRUE;
297
298   if (strb_att == ST_ATTACHMENT_INVALID)
299      return FALSE;
300
301   /* create a new fb */
302   if (!ctx->draw_buffer) {
303      stfb = CALLOC_STRUCT(st_framebuffer);
304      if (!stfb)
305         return FALSE;
306
307      stfb->strb = create_renderbuffer(stdrawi->visual->color_format);
308      if (!stfb->strb) {
309         FREE(stfb);
310         return FALSE;
311      }
312
313      stfb->dsrb = create_renderbuffer(ctx->ds_format);
314      if (!stfb->dsrb) {
315         FREE(stfb->strb);
316         FREE(stfb);
317         return FALSE;
318      }
319
320      stfb->width = 0;
321      stfb->height = 0;
322      stfb->strb_att = strb_att;
323      stfb->stamp = 1;
324      stfb->iface_stamp = p_atomic_read(&stdrawi->stamp) - 1;
325
326      ctx->draw_buffer = stfb;
327   }
328
329   ctx->draw_buffer->iface = stdrawi;
330   ctx->draw_stamp = ctx->draw_buffer->stamp - 1;
331
332   return TRUE;
333}
334
335static boolean
336vg_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
337                    struct st_framebuffer_iface *stdrawi,
338                    struct st_framebuffer_iface *streadi)
339{
340   struct vg_context *ctx = (struct vg_context *) stctxi;
341
342   if (stctxi)
343      vg_context_bind_framebuffers(stctxi, stdrawi, streadi);
344   vg_set_current_context(ctx);
345
346   return TRUE;
347}
348
349static struct st_context_iface *
350vg_api_get_current(struct st_api *stapi)
351{
352   struct vg_context *ctx = vg_current_context();
353
354   return (ctx) ? &ctx->iface : NULL;
355}
356
357static st_proc_t
358vg_api_get_proc_address(struct st_api *stapi, const char *procname)
359{
360   return api_get_proc_address(procname);
361}
362
363static void
364vg_api_destroy(struct st_api *stapi)
365{
366}
367
368static const struct st_api vg_api = {
369   "Vega " VEGA_VERSION_STRING,
370   ST_API_OPENVG,
371   ST_PROFILE_DEFAULT_MASK,
372   0,
373   vg_api_destroy,
374   vg_api_get_proc_address,
375   vg_api_create_context,
376   vg_api_make_current,
377   vg_api_get_current,
378};
379
380const struct st_api *
381vg_api_get(void)
382{
383   return &vg_api;
384}
385