native_helper.c revision 7c4e9dcdceec1112c91206619fe8b0885be99a79 
1/*
2 * Mesa 3-D graphics library
3 * Version:  7.9
4 *
5 * Copyright (C) 2010 LunarG Inc.
6 * Copyright (C) 2011 VMware Inc. All rights reserved.
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 *    Thomas Hellstrom <thellstrom@vmware.com>
29 */
30
31#include "util/u_inlines.h"
32#include "util/u_memory.h"
33#include "pipe/p_screen.h"
34#include "pipe/p_context.h"
35#include "pipe/p_state.h"
36
37#include "native_helper.h"
38
39/**
40 * Number of swap fences and mask
41 */
42
43#define EGL_SWAP_FENCES_MAX 4
44#define EGL_SWAP_FENCES_MASK 3
45#define EGL_SWAP_FENCES_DEFAULT 1
46
47struct resource_surface {
48   struct pipe_screen *screen;
49   enum pipe_format format;
50   uint bind;
51
52   struct pipe_resource *resources[NUM_NATIVE_ATTACHMENTS];
53   uint resource_mask;
54   uint width, height;
55
56   /**
57    * Swap fences.
58    */
59   struct pipe_fence_handle *swap_fences[EGL_SWAP_FENCES_MAX];
60   unsigned int cur_fences;
61   unsigned int head;
62   unsigned int tail;
63   unsigned int desired_fences;
64};
65
66struct resource_surface *
67resource_surface_create(struct pipe_screen *screen,
68                        enum pipe_format format, uint bind)
69{
70   struct resource_surface *rsurf = CALLOC_STRUCT(resource_surface);
71   char *swap_fences = getenv("EGL_THROTTLE_FENCES");
72
73   if (rsurf) {
74      rsurf->screen = screen;
75      rsurf->format = format;
76      rsurf->bind = bind;
77      rsurf->desired_fences = (swap_fences) ? atoi(swap_fences) :
78	 EGL_SWAP_FENCES_DEFAULT;
79      if (rsurf->desired_fences > EGL_SWAP_FENCES_MAX)
80	 rsurf->desired_fences = EGL_SWAP_FENCES_MAX;
81   }
82
83   return rsurf;
84}
85
86static void
87resource_surface_free_resources(struct resource_surface *rsurf)
88{
89   if (rsurf->resource_mask) {
90      int i;
91
92      for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
93         if (rsurf->resources[i])
94            pipe_resource_reference(&rsurf->resources[i], NULL);
95      }
96      rsurf->resource_mask = 0x0;
97   }
98}
99
100void
101resource_surface_destroy(struct resource_surface *rsurf)
102{
103   resource_surface_free_resources(rsurf);
104   FREE(rsurf);
105}
106
107boolean
108resource_surface_set_size(struct resource_surface *rsurf,
109                          uint width, uint height)
110{
111   boolean changed = FALSE;
112
113   if (rsurf->width != width || rsurf->height != height) {
114      resource_surface_free_resources(rsurf);
115      rsurf->width = width;
116      rsurf->height = height;
117      changed = TRUE;
118   }
119
120   return changed;
121}
122
123void
124resource_surface_get_size(struct resource_surface *rsurf,
125                          uint *width, uint *height)
126{
127   if (width)
128      *width = rsurf->width;
129   if (height)
130      *height = rsurf->height;
131}
132
133boolean
134resource_surface_add_resources(struct resource_surface *rsurf,
135                               uint resource_mask)
136{
137   struct pipe_resource templ;
138   int i;
139
140   resource_mask &= ~rsurf->resource_mask;
141   if (!resource_mask)
142      return TRUE;
143
144   if (!rsurf->width || !rsurf->height)
145      return FALSE;
146
147   memset(&templ, 0, sizeof(templ));
148   templ.target = PIPE_TEXTURE_2D;
149   templ.format = rsurf->format;
150   templ.bind = rsurf->bind;
151   templ.width0 = rsurf->width;
152   templ.height0 = rsurf->height;
153   templ.depth0 = 1;
154   templ.array_size = 1;
155
156   for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
157      if (resource_mask & (1 <<i)) {
158         assert(!rsurf->resources[i]);
159
160         rsurf->resources[i] =
161            rsurf->screen->resource_create(rsurf->screen, &templ);
162         if (rsurf->resources[i])
163            rsurf->resource_mask |= 1 << i;
164      }
165   }
166
167   return ((rsurf->resource_mask & resource_mask) == resource_mask);
168}
169
170void
171resource_surface_import_resource(struct resource_surface *rsurf,
172                                 enum native_attachment which,
173                                 struct pipe_resource *pres)
174{
175	pipe_resource_reference(&rsurf->resources[which], pres);
176	rsurf->resource_mask |= 1 << which;
177}
178
179void
180resource_surface_get_resources(struct resource_surface *rsurf,
181                               struct pipe_resource **resources,
182                               uint resource_mask)
183{
184   int i;
185
186   for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
187      if (resource_mask & (1 << i)) {
188         resources[i] = NULL;
189         pipe_resource_reference(&resources[i], rsurf->resources[i]);
190      }
191   }
192}
193
194struct pipe_resource *
195resource_surface_get_single_resource(struct resource_surface *rsurf,
196                                     enum native_attachment which)
197{
198   struct pipe_resource *pres = NULL;
199   pipe_resource_reference(&pres, rsurf->resources[which]);
200   return pres;
201}
202
203static INLINE void
204pointer_swap(const void **p1, const void **p2)
205{
206   const void *tmp = *p1;
207   *p1 = *p2;
208   *p2 = tmp;
209}
210
211void
212resource_surface_swap_buffers(struct resource_surface *rsurf,
213                              enum native_attachment buf1,
214                              enum native_attachment buf2,
215                              boolean only_if_exist)
216{
217   const uint buf1_bit = 1 << buf1;
218   const uint buf2_bit = 1 << buf2;
219   uint mask;
220
221   if (only_if_exist && !(rsurf->resources[buf1] && rsurf->resources[buf2]))
222      return;
223
224   pointer_swap((const void **) &rsurf->resources[buf1],
225                (const void **) &rsurf->resources[buf2]);
226
227   /* swap mask bits */
228   mask = rsurf->resource_mask & ~(buf1_bit | buf2_bit);
229   if (rsurf->resource_mask & buf1_bit)
230      mask |= buf2_bit;
231   if (rsurf->resource_mask & buf2_bit)
232      mask |= buf1_bit;
233
234   rsurf->resource_mask = mask;
235}
236
237boolean
238resource_surface_present(struct resource_surface *rsurf,
239                         enum native_attachment which,
240                         void *winsys_drawable_handle)
241{
242   struct pipe_resource *pres = rsurf->resources[which];
243
244   if (!pres)
245      return TRUE;
246
247   rsurf->screen->flush_frontbuffer(rsurf->screen,
248         pres, 0, 0, winsys_drawable_handle);
249
250   return TRUE;
251}
252
253/**
254 * Schedule a copy swap from the back to the front buffer using the
255 * native display's copy context.
256 */
257boolean
258resource_surface_copy_swap(struct resource_surface *rsurf,
259			   struct native_display *ndpy)
260{
261   struct pipe_resource *ftex;
262   struct pipe_resource *btex;
263   struct pipe_context *pipe;
264   struct pipe_box src_box;
265   boolean ret = FALSE;
266
267   pipe = ndpy_get_copy_context(ndpy);
268   if (!pipe)
269      return FALSE;
270
271   ftex = resource_surface_get_single_resource(rsurf,
272					       NATIVE_ATTACHMENT_FRONT_LEFT);
273   if (!ftex)
274      goto out_no_ftex;
275   btex = resource_surface_get_single_resource(rsurf,
276					       NATIVE_ATTACHMENT_BACK_LEFT);
277   if (!btex)
278      goto out_no_btex;
279
280   u_box_origin_2d(ftex->width0, ftex->height0, &src_box);
281   pipe->resource_copy_region(pipe, ftex, 0, 0, 0, 0,
282			      btex, 0, &src_box);
283   ret = TRUE;
284
285 out_no_ftex:
286   pipe_resource_reference(&btex, NULL);
287 out_no_btex:
288   pipe_resource_reference(&ftex, NULL);
289
290   return ret;
291}
292
293static struct pipe_fence_handle *
294swap_fences_pop_front(struct resource_surface *rsurf)
295{
296   struct pipe_screen *screen = rsurf->screen;
297   struct pipe_fence_handle *fence = NULL;
298
299   if (rsurf->desired_fences == 0)
300      return NULL;
301
302   if (rsurf->cur_fences >= rsurf->desired_fences) {
303      screen->fence_reference(screen, &fence, rsurf->swap_fences[rsurf->tail]);
304      screen->fence_reference(screen, &rsurf->swap_fences[rsurf->tail++], NULL);
305      rsurf->tail &= EGL_SWAP_FENCES_MASK;
306      --rsurf->cur_fences;
307   }
308   return fence;
309}
310
311static void
312swap_fences_push_back(struct resource_surface *rsurf,
313		      struct pipe_fence_handle *fence)
314{
315   struct pipe_screen *screen = rsurf->screen;
316
317   if (!fence || rsurf->desired_fences == 0)
318      return;
319
320   while(rsurf->cur_fences == rsurf->desired_fences)
321      swap_fences_pop_front(rsurf);
322
323   rsurf->cur_fences++;
324   screen->fence_reference(screen, &rsurf->swap_fences[rsurf->head++],
325			   fence);
326   rsurf->head &= EGL_SWAP_FENCES_MASK;
327}
328
329boolean
330resource_surface_throttle(struct resource_surface *rsurf)
331{
332   struct pipe_screen *screen = rsurf->screen;
333   struct pipe_fence_handle *fence = swap_fences_pop_front(rsurf);
334
335   if (fence) {
336      (void) screen->fence_finish(screen, fence, PIPE_TIMEOUT_INFINITE);
337      screen->fence_reference(screen, &fence, NULL);
338      return TRUE;
339   }
340
341   return FALSE;
342}
343
344boolean
345resource_surface_flush(struct resource_surface *rsurf,
346		       struct native_display *ndpy)
347{
348   struct pipe_fence_handle *fence = NULL;
349   struct pipe_screen *screen = rsurf->screen;
350   struct pipe_context *pipe= ndpy_get_copy_context(ndpy);
351
352   if (!pipe)
353      return FALSE;
354
355   pipe->flush(pipe, &fence);
356   if (fence == NULL)
357      return FALSE;
358
359   swap_fences_push_back(rsurf, fence);
360   screen->fence_reference(screen, &fence, NULL);
361
362   return TRUE;
363}
364
365void
366resource_surface_wait(struct resource_surface *rsurf)
367{
368   while (resource_surface_throttle(rsurf));
369}
370
371boolean
372native_display_copy_to_pixmap(struct native_display *ndpy,
373                              EGLNativePixmapType pix,
374                              struct pipe_resource *src)
375{
376   struct pipe_context *pipe;
377   struct native_surface *nsurf;
378   struct pipe_resource *dst;
379   struct pipe_resource *tmp[NUM_NATIVE_ATTACHMENTS];
380   const enum native_attachment natt = NATIVE_ATTACHMENT_FRONT_LEFT;
381
382   pipe = ndpy_get_copy_context(ndpy);
383   if (!pipe)
384      return FALSE;
385
386   nsurf = ndpy->create_pixmap_surface(ndpy, pix, NULL);
387   if (!nsurf)
388      return FALSE;
389
390   /* get the texutre */
391   tmp[natt] = NULL;
392   nsurf->validate(nsurf, 1 << natt, NULL, tmp, NULL, NULL);
393   dst = tmp[natt];
394
395   if (dst && dst->format == src->format) {
396      struct pipe_box src_box;
397
398      u_box_origin_2d(src->width0, src->height0, &src_box);
399      pipe->resource_copy_region(pipe, dst, 0, 0, 0, 0, src, 0, &src_box);
400      pipe->flush(pipe, NULL);
401      nsurf->present(nsurf, natt, FALSE, 0);
402   }
403
404   if (dst)
405      pipe_resource_reference(&dst, NULL);
406
407   nsurf->destroy(nsurf);
408
409   return TRUE;
410}
411
412#include "state_tracker/drm_driver.h"
413struct pipe_resource *
414drm_display_import_native_buffer(struct native_display *ndpy,
415                                 struct native_buffer *nbuf)
416{
417   struct pipe_screen *screen = ndpy->screen;
418   struct pipe_resource *res = NULL;
419
420   switch (nbuf->type) {
421   case NATIVE_BUFFER_DRM:
422      {
423         struct winsys_handle wsh;
424
425         memset(&wsh, 0, sizeof(wsh));
426         wsh.handle = nbuf->u.drm.name;
427         wsh.stride = nbuf->u.drm.stride;
428
429         res = screen->resource_from_handle(screen, &nbuf->u.drm.templ, &wsh);
430      }
431      break;
432   default:
433      break;
434   }
435
436   return res;
437}
438
439boolean
440drm_display_export_native_buffer(struct native_display *ndpy,
441                                 struct pipe_resource *res,
442                                 struct native_buffer *nbuf)
443{
444   struct pipe_screen *screen = ndpy->screen;
445   boolean ret = FALSE;
446
447   switch (nbuf->type) {
448   case NATIVE_BUFFER_DRM:
449      {
450         struct winsys_handle wsh;
451
452         if ((nbuf->u.drm.templ.bind & res->bind) != nbuf->u.drm.templ.bind)
453            break;
454
455         memset(&wsh, 0, sizeof(wsh));
456         wsh.type = DRM_API_HANDLE_TYPE_KMS;
457         if (!screen->resource_get_handle(screen, res, &wsh))
458            break;
459
460         nbuf->u.drm.handle = wsh.handle;
461         nbuf->u.drm.stride = wsh.stride;
462
463         /* get the name of the GEM object */
464         if (nbuf->u.drm.templ.bind & PIPE_BIND_SHARED) {
465            memset(&wsh, 0, sizeof(wsh));
466            wsh.type = DRM_API_HANDLE_TYPE_SHARED;
467            if (!screen->resource_get_handle(screen, res, &wsh))
468               break;
469
470            nbuf->u.drm.name = wsh.handle;
471         }
472
473         nbuf->u.drm.templ = *res;
474         ret = TRUE;
475      }
476      break;
477   default:
478      break;
479   }
480
481   return ret;
482}
483