1f9fe27ab85a7541e6c8ae263de3fbdfcd6112f6
[mesa.git] / src / egl / drivers / dri2 / platform_android.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 2010-2011 Chia-I Wu <olvaffe@gmail.com>
5 * Copyright (C) 2010-2011 LunarG Inc.
6 *
7 * Based on platform_x11, which has
8 *
9 * Copyright © 2011 Intel Corporation
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 * DEALINGS IN THE SOFTWARE.
28 */
29
30 #include <cutils/properties.h>
31 #include <errno.h>
32 #include <dirent.h>
33 #include <dlfcn.h>
34 #include <fcntl.h>
35 #include <xf86drm.h>
36 #include <stdbool.h>
37 #include <stdio.h>
38 #include <sync/sync.h>
39 #include <sys/types.h>
40
41 #include "loader.h"
42 #include "egl_dri2.h"
43 #include "egl_dri2_fallbacks.h"
44
45 #ifdef HAVE_DRM_GRALLOC
46 #include <gralloc_drm_handle.h>
47 #include "gralloc_drm.h"
48 #endif /* HAVE_DRM_GRALLOC */
49
50 #define ALIGN(val, align) (((val) + (align) - 1) & ~((align) - 1))
51
52 struct droid_yuv_format {
53 /* Lookup keys */
54 int native; /* HAL_PIXEL_FORMAT_ */
55 int is_ycrcb; /* 0 if chroma order is {Cb, Cr}, 1 if {Cr, Cb} */
56 int chroma_step; /* Distance in bytes between subsequent chroma pixels. */
57
58 /* Result */
59 int fourcc; /* __DRI_IMAGE_FOURCC_ */
60 };
61
62 /* The following table is used to look up a DRI image FourCC based
63 * on native format and information contained in android_ycbcr struct. */
64 static const struct droid_yuv_format droid_yuv_formats[] = {
65 /* Native format, YCrCb, Chroma step, DRI image FourCC */
66 { HAL_PIXEL_FORMAT_YCbCr_420_888, 0, 2, __DRI_IMAGE_FOURCC_NV12 },
67 { HAL_PIXEL_FORMAT_YCbCr_420_888, 0, 1, __DRI_IMAGE_FOURCC_YUV420 },
68 { HAL_PIXEL_FORMAT_YCbCr_420_888, 1, 1, __DRI_IMAGE_FOURCC_YVU420 },
69 { HAL_PIXEL_FORMAT_YV12, 1, 1, __DRI_IMAGE_FOURCC_YVU420 },
70 /* HACK: See droid_create_image_from_prime_fd() and
71 * https://issuetracker.google.com/32077885. */
72 { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 0, 2, __DRI_IMAGE_FOURCC_NV12 },
73 { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 0, 1, __DRI_IMAGE_FOURCC_YUV420 },
74 { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 1, 1, __DRI_IMAGE_FOURCC_YVU420 },
75 };
76
77 static int
78 get_fourcc_yuv(int native, int is_ycrcb, int chroma_step)
79 {
80 for (int i = 0; i < ARRAY_SIZE(droid_yuv_formats); ++i)
81 if (droid_yuv_formats[i].native == native &&
82 droid_yuv_formats[i].is_ycrcb == is_ycrcb &&
83 droid_yuv_formats[i].chroma_step == chroma_step)
84 return droid_yuv_formats[i].fourcc;
85
86 return -1;
87 }
88
89 static bool
90 is_yuv(int native)
91 {
92 for (int i = 0; i < ARRAY_SIZE(droid_yuv_formats); ++i)
93 if (droid_yuv_formats[i].native == native)
94 return true;
95
96 return false;
97 }
98
99 static int
100 get_format_bpp(int native)
101 {
102 int bpp;
103
104 switch (native) {
105 case HAL_PIXEL_FORMAT_RGBA_8888:
106 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
107 /*
108 * HACK: Hardcode this to RGBX_8888 as per cros_gralloc hack.
109 * TODO: Remove this once https://issuetracker.google.com/32077885 is fixed.
110 */
111 case HAL_PIXEL_FORMAT_RGBX_8888:
112 case HAL_PIXEL_FORMAT_BGRA_8888:
113 bpp = 4;
114 break;
115 case HAL_PIXEL_FORMAT_RGB_565:
116 bpp = 2;
117 break;
118 default:
119 bpp = 0;
120 break;
121 }
122
123 return bpp;
124 }
125
126 /* createImageFromFds requires fourcc format */
127 static int get_fourcc(int native)
128 {
129 switch (native) {
130 case HAL_PIXEL_FORMAT_RGB_565: return __DRI_IMAGE_FOURCC_RGB565;
131 case HAL_PIXEL_FORMAT_BGRA_8888: return __DRI_IMAGE_FOURCC_ARGB8888;
132 case HAL_PIXEL_FORMAT_RGBA_8888: return __DRI_IMAGE_FOURCC_ABGR8888;
133 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
134 /*
135 * HACK: Hardcode this to RGBX_8888 as per cros_gralloc hack.
136 * TODO: Remove this once https://issuetracker.google.com/32077885 is fixed.
137 */
138 case HAL_PIXEL_FORMAT_RGBX_8888: return __DRI_IMAGE_FOURCC_XBGR8888;
139 default:
140 _eglLog(_EGL_WARNING, "unsupported native buffer format 0x%x", native);
141 }
142 return -1;
143 }
144
145 static int get_format(int format)
146 {
147 switch (format) {
148 case HAL_PIXEL_FORMAT_BGRA_8888: return __DRI_IMAGE_FORMAT_ARGB8888;
149 case HAL_PIXEL_FORMAT_RGB_565: return __DRI_IMAGE_FORMAT_RGB565;
150 case HAL_PIXEL_FORMAT_RGBA_8888: return __DRI_IMAGE_FORMAT_ABGR8888;
151 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
152 /*
153 * HACK: Hardcode this to RGBX_8888 as per cros_gralloc hack.
154 * TODO: Revert this once https://issuetracker.google.com/32077885 is fixed.
155 */
156 case HAL_PIXEL_FORMAT_RGBX_8888: return __DRI_IMAGE_FORMAT_XBGR8888;
157 default:
158 _eglLog(_EGL_WARNING, "unsupported native buffer format 0x%x", format);
159 }
160 return -1;
161 }
162
163 static int
164 get_native_buffer_fd(struct ANativeWindowBuffer *buf)
165 {
166 native_handle_t *handle = (native_handle_t *)buf->handle;
167 /*
168 * Various gralloc implementations exist, but the dma-buf fd tends
169 * to be first. Access it directly to avoid a dependency on specific
170 * gralloc versions.
171 */
172 return (handle && handle->numFds) ? handle->data[0] : -1;
173 }
174
175 #ifdef HAVE_DRM_GRALLOC
176 static int
177 get_native_buffer_name(struct ANativeWindowBuffer *buf)
178 {
179 return gralloc_drm_get_gem_handle(buf->handle);
180 }
181 #endif /* HAVE_DRM_GRALLOC */
182
183 static EGLBoolean
184 droid_window_dequeue_buffer(struct dri2_egl_surface *dri2_surf)
185 {
186 int fence_fd;
187
188 if (dri2_surf->window->dequeueBuffer(dri2_surf->window, &dri2_surf->buffer,
189 &fence_fd))
190 return EGL_FALSE;
191
192 /* If access to the buffer is controlled by a sync fence, then block on the
193 * fence.
194 *
195 * It may be more performant to postpone blocking until there is an
196 * immediate need to write to the buffer. But doing so would require adding
197 * hooks to the DRI2 loader.
198 *
199 * From the ANativeWindow::dequeueBuffer documentation:
200 *
201 * The libsync fence file descriptor returned in the int pointed to by
202 * the fenceFd argument will refer to the fence that must signal
203 * before the dequeued buffer may be written to. A value of -1
204 * indicates that the caller may access the buffer immediately without
205 * waiting on a fence. If a valid file descriptor is returned (i.e.
206 * any value except -1) then the caller is responsible for closing the
207 * file descriptor.
208 */
209 if (fence_fd >= 0) {
210 /* From the SYNC_IOC_WAIT documentation in <linux/sync.h>:
211 *
212 * Waits indefinitely if timeout < 0.
213 */
214 int timeout = -1;
215 sync_wait(fence_fd, timeout);
216 close(fence_fd);
217 }
218
219 dri2_surf->buffer->common.incRef(&dri2_surf->buffer->common);
220
221 /* Record all the buffers created by ANativeWindow and update back buffer
222 * for updating buffer's age in swap_buffers.
223 */
224 EGLBoolean updated = EGL_FALSE;
225 for (int i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
226 if (!dri2_surf->color_buffers[i].buffer) {
227 dri2_surf->color_buffers[i].buffer = dri2_surf->buffer;
228 }
229 if (dri2_surf->color_buffers[i].buffer == dri2_surf->buffer) {
230 dri2_surf->back = &dri2_surf->color_buffers[i];
231 updated = EGL_TRUE;
232 break;
233 }
234 }
235
236 if (!updated) {
237 /* In case of all the buffers were recreated by ANativeWindow, reset
238 * the color_buffers
239 */
240 for (int i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
241 dri2_surf->color_buffers[i].buffer = NULL;
242 dri2_surf->color_buffers[i].age = 0;
243 }
244 dri2_surf->color_buffers[0].buffer = dri2_surf->buffer;
245 dri2_surf->back = &dri2_surf->color_buffers[0];
246 }
247
248 return EGL_TRUE;
249 }
250
251 static EGLBoolean
252 droid_window_enqueue_buffer(_EGLDisplay *disp, struct dri2_egl_surface *dri2_surf)
253 {
254 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
255
256 /* To avoid blocking other EGL calls, release the display mutex before
257 * we enter droid_window_enqueue_buffer() and re-acquire the mutex upon
258 * return.
259 */
260 mtx_unlock(&disp->Mutex);
261
262 /* Queue the buffer with stored out fence fd. The ANativeWindow or buffer
263 * consumer may choose to wait for the fence to signal before accessing
264 * it. If fence fd value is -1, buffer can be accessed by consumer
265 * immediately. Consumer or application shouldn't rely on timestamp
266 * associated with fence if the fence fd is -1.
267 *
268 * Ownership of fd is transferred to consumer after queueBuffer and the
269 * consumer is responsible for closing it. Caller must not use the fd
270 * after passing it to queueBuffer.
271 */
272 int fence_fd = dri2_surf->out_fence_fd;
273 dri2_surf->out_fence_fd = -1;
274 dri2_surf->window->queueBuffer(dri2_surf->window, dri2_surf->buffer,
275 fence_fd);
276
277 dri2_surf->buffer->common.decRef(&dri2_surf->buffer->common);
278 dri2_surf->buffer = NULL;
279 dri2_surf->back = NULL;
280
281 mtx_lock(&disp->Mutex);
282
283 if (dri2_surf->dri_image_back) {
284 dri2_dpy->image->destroyImage(dri2_surf->dri_image_back);
285 dri2_surf->dri_image_back = NULL;
286 }
287
288 return EGL_TRUE;
289 }
290
291 static void
292 droid_window_cancel_buffer(struct dri2_egl_surface *dri2_surf)
293 {
294 int ret;
295 int fence_fd = dri2_surf->out_fence_fd;
296
297 dri2_surf->out_fence_fd = -1;
298 ret = dri2_surf->window->cancelBuffer(dri2_surf->window,
299 dri2_surf->buffer, fence_fd);
300 if (ret < 0) {
301 _eglLog(_EGL_WARNING, "ANativeWindow::cancelBuffer failed");
302 dri2_surf->base.Lost = EGL_TRUE;
303 }
304 }
305
306 static bool
307 droid_set_shared_buffer_mode(_EGLDisplay *disp, _EGLSurface *surf, bool mode)
308 {
309 #if ANDROID_API_LEVEL >= 24
310 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
311 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
312 struct ANativeWindow *window = dri2_surf->window;
313
314 assert(surf->Type == EGL_WINDOW_BIT);
315 assert(_eglSurfaceHasMutableRenderBuffer(&dri2_surf->base));
316
317 _eglLog(_EGL_DEBUG, "%s: mode=%d", __func__, mode);
318
319 if (native_window_set_shared_buffer_mode(window, mode)) {
320 _eglLog(_EGL_WARNING, "failed native_window_set_shared_buffer_mode"
321 "(window=%p, mode=%d)", window, mode);
322 return false;
323 }
324
325 return true;
326 #else
327 _eglLog(_EGL_FATAL, "%s:%d: internal error: unreachable", __FILE__, __LINE__);
328 return false;
329 #endif
330 }
331
332 static _EGLSurface *
333 droid_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
334 _EGLConfig *conf, void *native_window,
335 const EGLint *attrib_list)
336 {
337 __DRIcreateNewDrawableFunc createNewDrawable;
338 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
339 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
340 struct dri2_egl_surface *dri2_surf;
341 struct ANativeWindow *window = native_window;
342 const __DRIconfig *config;
343
344 dri2_surf = calloc(1, sizeof *dri2_surf);
345 if (!dri2_surf) {
346 _eglError(EGL_BAD_ALLOC, "droid_create_surface");
347 return NULL;
348 }
349
350 if (!dri2_init_surface(&dri2_surf->base, disp, type, conf, attrib_list, true))
351 goto cleanup_surface;
352
353 if (type == EGL_WINDOW_BIT) {
354 int format;
355
356 if (window->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) {
357 _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
358 goto cleanup_surface;
359 }
360 if (window->query(window, NATIVE_WINDOW_FORMAT, &format)) {
361 _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
362 goto cleanup_surface;
363 }
364
365 if (format != dri2_conf->base.NativeVisualID) {
366 _eglLog(_EGL_WARNING, "Native format mismatch: 0x%x != 0x%x",
367 format, dri2_conf->base.NativeVisualID);
368 }
369
370 window->query(window, NATIVE_WINDOW_WIDTH, &dri2_surf->base.Width);
371 window->query(window, NATIVE_WINDOW_HEIGHT, &dri2_surf->base.Height);
372 }
373
374 config = dri2_get_dri_config(dri2_conf, type,
375 dri2_surf->base.GLColorspace);
376 if (!config) {
377 _eglError(EGL_BAD_MATCH, "Unsupported surfacetype/colorspace configuration");
378 goto cleanup_surface;
379 }
380
381 if (dri2_dpy->image_driver)
382 createNewDrawable = dri2_dpy->image_driver->createNewDrawable;
383 else
384 createNewDrawable = dri2_dpy->dri2->createNewDrawable;
385
386 dri2_surf->dri_drawable = (*createNewDrawable)(dri2_dpy->dri_screen, config,
387 dri2_surf);
388 if (dri2_surf->dri_drawable == NULL) {
389 _eglError(EGL_BAD_ALLOC, "createNewDrawable");
390 goto cleanup_surface;
391 }
392
393 if (window) {
394 window->common.incRef(&window->common);
395 dri2_surf->window = window;
396 }
397
398 return &dri2_surf->base;
399
400 cleanup_surface:
401 free(dri2_surf);
402
403 return NULL;
404 }
405
406 static _EGLSurface *
407 droid_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
408 _EGLConfig *conf, void *native_window,
409 const EGLint *attrib_list)
410 {
411 return droid_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
412 native_window, attrib_list);
413 }
414
415 static _EGLSurface *
416 droid_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
417 _EGLConfig *conf, const EGLint *attrib_list)
418 {
419 return droid_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
420 NULL, attrib_list);
421 }
422
423 static EGLBoolean
424 droid_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
425 {
426 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
427 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
428
429 dri2_egl_surface_free_local_buffers(dri2_surf);
430
431 if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
432 if (dri2_surf->buffer)
433 droid_window_cancel_buffer(dri2_surf);
434
435 dri2_surf->window->common.decRef(&dri2_surf->window->common);
436 }
437
438 if (dri2_surf->dri_image_back) {
439 _eglLog(_EGL_DEBUG, "%s : %d : destroy dri_image_back", __func__, __LINE__);
440 dri2_dpy->image->destroyImage(dri2_surf->dri_image_back);
441 dri2_surf->dri_image_back = NULL;
442 }
443
444 if (dri2_surf->dri_image_front) {
445 _eglLog(_EGL_DEBUG, "%s : %d : destroy dri_image_front", __func__, __LINE__);
446 dri2_dpy->image->destroyImage(dri2_surf->dri_image_front);
447 dri2_surf->dri_image_front = NULL;
448 }
449
450 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
451
452 dri2_fini_surface(surf);
453 free(dri2_surf);
454
455 return EGL_TRUE;
456 }
457
458 static EGLBoolean
459 droid_swap_interval(_EGLDriver *drv, _EGLDisplay *dpy,
460 _EGLSurface *surf, EGLint interval)
461 {
462 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
463 struct ANativeWindow *window = dri2_surf->window;
464
465 if (window->setSwapInterval(window, interval))
466 return EGL_FALSE;
467
468 surf->SwapInterval = interval;
469 return EGL_TRUE;
470 }
471
472 static int
473 update_buffers(struct dri2_egl_surface *dri2_surf)
474 {
475 if (dri2_surf->base.Lost)
476 return -1;
477
478 if (dri2_surf->base.Type != EGL_WINDOW_BIT)
479 return 0;
480
481 /* try to dequeue the next back buffer */
482 if (!dri2_surf->buffer && !droid_window_dequeue_buffer(dri2_surf)) {
483 _eglLog(_EGL_WARNING, "Could not dequeue buffer from native window");
484 dri2_surf->base.Lost = EGL_TRUE;
485 return -1;
486 }
487
488 /* free outdated buffers and update the surface size */
489 if (dri2_surf->base.Width != dri2_surf->buffer->width ||
490 dri2_surf->base.Height != dri2_surf->buffer->height) {
491 dri2_egl_surface_free_local_buffers(dri2_surf);
492 dri2_surf->base.Width = dri2_surf->buffer->width;
493 dri2_surf->base.Height = dri2_surf->buffer->height;
494 }
495
496 return 0;
497 }
498
499 static int
500 get_front_bo(struct dri2_egl_surface *dri2_surf, unsigned int format)
501 {
502 struct dri2_egl_display *dri2_dpy =
503 dri2_egl_display(dri2_surf->base.Resource.Display);
504
505 if (dri2_surf->dri_image_front)
506 return 0;
507
508 if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
509 /* According current EGL spec, front buffer rendering
510 * for window surface is not supported now.
511 * and mesa doesn't have the implementation of this case.
512 * Add warning message, but not treat it as error.
513 */
514 _eglLog(_EGL_DEBUG, "DRI driver requested unsupported front buffer for window surface");
515 } else if (dri2_surf->base.Type == EGL_PBUFFER_BIT) {
516 dri2_surf->dri_image_front =
517 dri2_dpy->image->createImage(dri2_dpy->dri_screen,
518 dri2_surf->base.Width,
519 dri2_surf->base.Height,
520 format,
521 0,
522 dri2_surf);
523 if (!dri2_surf->dri_image_front) {
524 _eglLog(_EGL_WARNING, "dri2_image_front allocation failed");
525 return -1;
526 }
527 }
528
529 return 0;
530 }
531
532 static int
533 get_back_bo(struct dri2_egl_surface *dri2_surf)
534 {
535 struct dri2_egl_display *dri2_dpy =
536 dri2_egl_display(dri2_surf->base.Resource.Display);
537 int fourcc, pitch;
538 int offset = 0, fd;
539
540 if (dri2_surf->dri_image_back)
541 return 0;
542
543 if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
544 if (!dri2_surf->buffer) {
545 _eglLog(_EGL_WARNING, "Could not get native buffer");
546 return -1;
547 }
548
549 fd = get_native_buffer_fd(dri2_surf->buffer);
550 if (fd < 0) {
551 _eglLog(_EGL_WARNING, "Could not get native buffer FD");
552 return -1;
553 }
554
555 fourcc = get_fourcc(dri2_surf->buffer->format);
556
557 pitch = dri2_surf->buffer->stride *
558 get_format_bpp(dri2_surf->buffer->format);
559
560 if (fourcc == -1 || pitch == 0) {
561 _eglLog(_EGL_WARNING, "Invalid buffer fourcc(%x) or pitch(%d)",
562 fourcc, pitch);
563 return -1;
564 }
565
566 dri2_surf->dri_image_back =
567 dri2_dpy->image->createImageFromFds(dri2_dpy->dri_screen,
568 dri2_surf->base.Width,
569 dri2_surf->base.Height,
570 fourcc,
571 &fd,
572 1,
573 &pitch,
574 &offset,
575 dri2_surf);
576 if (!dri2_surf->dri_image_back) {
577 _eglLog(_EGL_WARNING, "failed to create DRI image from FD");
578 return -1;
579 }
580 } else if (dri2_surf->base.Type == EGL_PBUFFER_BIT) {
581 /* The EGL 1.5 spec states that pbuffers are single-buffered. Specifically,
582 * the spec states that they have a back buffer but no front buffer, in
583 * contrast to pixmaps, which have a front buffer but no back buffer.
584 *
585 * Single-buffered surfaces with no front buffer confuse Mesa; so we deviate
586 * from the spec, following the precedent of Mesa's EGL X11 platform. The
587 * X11 platform correctly assigns pbuffers to single-buffered configs, but
588 * assigns the pbuffer a front buffer instead of a back buffer.
589 *
590 * Pbuffers in the X11 platform mostly work today, so let's just copy its
591 * behavior instead of trying to fix (and hence potentially breaking) the
592 * world.
593 */
594 _eglLog(_EGL_DEBUG, "DRI driver requested unsupported back buffer for pbuffer surface");
595 }
596
597 return 0;
598 }
599
600 /* Some drivers will pass multiple bits in buffer_mask.
601 * For such case, will go through all the bits, and
602 * will not return error when unsupported buffer is requested, only
603 * return error when the allocation for supported buffer failed.
604 */
605 static int
606 droid_image_get_buffers(__DRIdrawable *driDrawable,
607 unsigned int format,
608 uint32_t *stamp,
609 void *loaderPrivate,
610 uint32_t buffer_mask,
611 struct __DRIimageList *images)
612 {
613 struct dri2_egl_surface *dri2_surf = loaderPrivate;
614
615 images->image_mask = 0;
616 images->front = NULL;
617 images->back = NULL;
618
619 if (update_buffers(dri2_surf) < 0)
620 return 0;
621
622 if (_eglSurfaceInSharedBufferMode(&dri2_surf->base)) {
623 if (get_back_bo(dri2_surf) < 0)
624 return 0;
625
626 /* We have dri_image_back because this is a window surface and
627 * get_back_bo() succeeded.
628 */
629 assert(dri2_surf->dri_image_back);
630 images->back = dri2_surf->dri_image_back;
631 images->image_mask |= __DRI_IMAGE_BUFFER_SHARED;
632
633 /* There exists no accompanying back nor front buffer. */
634 return 1;
635 }
636
637 if (buffer_mask & __DRI_IMAGE_BUFFER_FRONT) {
638 if (get_front_bo(dri2_surf, format) < 0)
639 return 0;
640
641 if (dri2_surf->dri_image_front) {
642 images->front = dri2_surf->dri_image_front;
643 images->image_mask |= __DRI_IMAGE_BUFFER_FRONT;
644 }
645 }
646
647 if (buffer_mask & __DRI_IMAGE_BUFFER_BACK) {
648 if (get_back_bo(dri2_surf) < 0)
649 return 0;
650
651 if (dri2_surf->dri_image_back) {
652 images->back = dri2_surf->dri_image_back;
653 images->image_mask |= __DRI_IMAGE_BUFFER_BACK;
654 }
655 }
656
657 return 1;
658 }
659
660 static EGLint
661 droid_query_buffer_age(_EGLDriver *drv,
662 _EGLDisplay *disp, _EGLSurface *surface)
663 {
664 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
665
666 if (update_buffers(dri2_surf) < 0) {
667 _eglError(EGL_BAD_ALLOC, "droid_query_buffer_age");
668 return -1;
669 }
670
671 return dri2_surf->back ? dri2_surf->back->age : 0;
672 }
673
674 static EGLBoolean
675 droid_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
676 {
677 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
678 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
679
680 if (dri2_surf->base.Type != EGL_WINDOW_BIT)
681 return EGL_TRUE;
682
683 const bool has_mutable_rb = _eglSurfaceHasMutableRenderBuffer(draw);
684
685 /* From the EGL_KHR_mutable_render_buffer spec (v12):
686 *
687 * If surface is a single-buffered window, pixmap, or pbuffer surface
688 * for which there is no pending change to the EGL_RENDER_BUFFER
689 * attribute, eglSwapBuffers has no effect.
690 */
691 if (has_mutable_rb &&
692 draw->RequestedRenderBuffer == EGL_SINGLE_BUFFER &&
693 draw->ActiveRenderBuffer == EGL_SINGLE_BUFFER) {
694 _eglLog(_EGL_DEBUG, "%s: remain in shared buffer mode", __func__);
695 return EGL_TRUE;
696 }
697
698 for (int i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
699 if (dri2_surf->color_buffers[i].age > 0)
700 dri2_surf->color_buffers[i].age++;
701 }
702
703 /* "XXX: we don't use get_back_bo() since it causes regressions in
704 * several dEQP tests.
705 */
706 if (dri2_surf->back)
707 dri2_surf->back->age = 1;
708
709 dri2_flush_drawable_for_swapbuffers(disp, draw);
710
711 /* dri2_surf->buffer can be null even when no error has occured. For
712 * example, if the user has called no GL rendering commands since the
713 * previous eglSwapBuffers, then the driver may have not triggered
714 * a callback to ANativeWindow::dequeueBuffer, in which case
715 * dri2_surf->buffer remains null.
716 */
717 if (dri2_surf->buffer)
718 droid_window_enqueue_buffer(disp, dri2_surf);
719
720 dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
721
722 /* Update the shared buffer mode */
723 if (has_mutable_rb &&
724 draw->ActiveRenderBuffer != draw->RequestedRenderBuffer) {
725 bool mode = (draw->RequestedRenderBuffer == EGL_SINGLE_BUFFER);
726 _eglLog(_EGL_DEBUG, "%s: change to shared buffer mode %d",
727 __func__, mode);
728
729 if (!droid_set_shared_buffer_mode(disp, draw, mode))
730 return EGL_FALSE;
731 draw->ActiveRenderBuffer = draw->RequestedRenderBuffer;
732 }
733
734 return EGL_TRUE;
735 }
736
737 #if ANDROID_API_LEVEL >= 23
738 static EGLBoolean
739 droid_set_damage_region(_EGLDriver *drv,
740 _EGLDisplay *disp,
741 _EGLSurface *draw, const EGLint* rects, EGLint n_rects)
742 {
743 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
744 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
745 android_native_rect_t* droid_rects = NULL;
746 int ret;
747
748 if (n_rects == 0)
749 return EGL_TRUE;
750
751 droid_rects = malloc(n_rects * sizeof(android_native_rect_t));
752 if (droid_rects == NULL)
753 return _eglError(EGL_BAD_ALLOC, "eglSetDamageRegionKHR");
754
755 for (EGLint num_drects = 0; num_drects < n_rects; num_drects++) {
756 EGLint i = num_drects * 4;
757 droid_rects[num_drects].left = rects[i];
758 droid_rects[num_drects].bottom = rects[i + 1];
759 droid_rects[num_drects].right = rects[i] + rects[i + 2];
760 droid_rects[num_drects].top = rects[i + 1] + rects[i + 3];
761 }
762
763 /*
764 * XXX/TODO: Need to check for other return values
765 */
766
767 ret = native_window_set_surface_damage(dri2_surf->window, droid_rects, n_rects);
768 free(droid_rects);
769
770 return ret == 0 ? EGL_TRUE : EGL_FALSE;
771 }
772 #endif
773
774 static _EGLImage *
775 droid_create_image_from_prime_fd_yuv(_EGLDisplay *disp, _EGLContext *ctx,
776 struct ANativeWindowBuffer *buf, int fd)
777 {
778 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
779 struct android_ycbcr ycbcr;
780 size_t offsets[3];
781 size_t pitches[3];
782 int is_ycrcb;
783 int fourcc;
784 int ret;
785
786 if (!dri2_dpy->gralloc->lock_ycbcr) {
787 _eglLog(_EGL_WARNING, "Gralloc does not support lock_ycbcr");
788 return NULL;
789 }
790
791 memset(&ycbcr, 0, sizeof(ycbcr));
792 ret = dri2_dpy->gralloc->lock_ycbcr(dri2_dpy->gralloc, buf->handle,
793 0, 0, 0, 0, 0, &ycbcr);
794 if (ret) {
795 /* HACK: See droid_create_image_from_prime_fd() and
796 * https://issuetracker.google.com/32077885.*/
797 if (buf->format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED)
798 return NULL;
799
800 _eglLog(_EGL_WARNING, "gralloc->lock_ycbcr failed: %d", ret);
801 return NULL;
802 }
803 dri2_dpy->gralloc->unlock(dri2_dpy->gralloc, buf->handle);
804
805 /* When lock_ycbcr's usage argument contains no SW_READ/WRITE flags
806 * it will return the .y/.cb/.cr pointers based on a NULL pointer,
807 * so they can be interpreted as offsets. */
808 offsets[0] = (size_t)ycbcr.y;
809 /* We assume here that all the planes are located in one DMA-buf. */
810 is_ycrcb = (size_t)ycbcr.cr < (size_t)ycbcr.cb;
811 if (is_ycrcb) {
812 offsets[1] = (size_t)ycbcr.cr;
813 offsets[2] = (size_t)ycbcr.cb;
814 } else {
815 offsets[1] = (size_t)ycbcr.cb;
816 offsets[2] = (size_t)ycbcr.cr;
817 }
818
819 /* .ystride is the line length (in bytes) of the Y plane,
820 * .cstride is the line length (in bytes) of any of the remaining
821 * Cb/Cr/CbCr planes, assumed to be the same for Cb and Cr for fully
822 * planar formats. */
823 pitches[0] = ycbcr.ystride;
824 pitches[1] = pitches[2] = ycbcr.cstride;
825
826 /* .chroma_step is the byte distance between the same chroma channel
827 * values of subsequent pixels, assumed to be the same for Cb and Cr. */
828 fourcc = get_fourcc_yuv(buf->format, is_ycrcb, ycbcr.chroma_step);
829 if (fourcc == -1) {
830 _eglLog(_EGL_WARNING, "unsupported YUV format, native = %x, is_ycrcb = %d, chroma_step = %d",
831 buf->format, is_ycrcb, ycbcr.chroma_step);
832 return NULL;
833 }
834
835 if (ycbcr.chroma_step == 2) {
836 /* Semi-planar Y + CbCr or Y + CrCb format. */
837 const EGLint attr_list_2plane[] = {
838 EGL_WIDTH, buf->width,
839 EGL_HEIGHT, buf->height,
840 EGL_LINUX_DRM_FOURCC_EXT, fourcc,
841 EGL_DMA_BUF_PLANE0_FD_EXT, fd,
842 EGL_DMA_BUF_PLANE0_PITCH_EXT, pitches[0],
843 EGL_DMA_BUF_PLANE0_OFFSET_EXT, offsets[0],
844 EGL_DMA_BUF_PLANE1_FD_EXT, fd,
845 EGL_DMA_BUF_PLANE1_PITCH_EXT, pitches[1],
846 EGL_DMA_BUF_PLANE1_OFFSET_EXT, offsets[1],
847 EGL_NONE, 0
848 };
849
850 return dri2_create_image_dma_buf(disp, ctx, NULL, attr_list_2plane);
851 } else {
852 /* Fully planar Y + Cb + Cr or Y + Cr + Cb format. */
853 const EGLint attr_list_3plane[] = {
854 EGL_WIDTH, buf->width,
855 EGL_HEIGHT, buf->height,
856 EGL_LINUX_DRM_FOURCC_EXT, fourcc,
857 EGL_DMA_BUF_PLANE0_FD_EXT, fd,
858 EGL_DMA_BUF_PLANE0_PITCH_EXT, pitches[0],
859 EGL_DMA_BUF_PLANE0_OFFSET_EXT, offsets[0],
860 EGL_DMA_BUF_PLANE1_FD_EXT, fd,
861 EGL_DMA_BUF_PLANE1_PITCH_EXT, pitches[1],
862 EGL_DMA_BUF_PLANE1_OFFSET_EXT, offsets[1],
863 EGL_DMA_BUF_PLANE2_FD_EXT, fd,
864 EGL_DMA_BUF_PLANE2_PITCH_EXT, pitches[2],
865 EGL_DMA_BUF_PLANE2_OFFSET_EXT, offsets[2],
866 EGL_NONE, 0
867 };
868
869 return dri2_create_image_dma_buf(disp, ctx, NULL, attr_list_3plane);
870 }
871 }
872
873 static _EGLImage *
874 droid_create_image_from_prime_fd(_EGLDisplay *disp, _EGLContext *ctx,
875 struct ANativeWindowBuffer *buf, int fd)
876 {
877 unsigned int pitch;
878
879 if (is_yuv(buf->format)) {
880 _EGLImage *image;
881
882 image = droid_create_image_from_prime_fd_yuv(disp, ctx, buf, fd);
883 /*
884 * HACK: https://issuetracker.google.com/32077885
885 * There is no API available to properly query the IMPLEMENTATION_DEFINED
886 * format. As a workaround we rely here on gralloc allocating either
887 * an arbitrary YCbCr 4:2:0 or RGBX_8888, with the latter being recognized
888 * by lock_ycbcr failing.
889 */
890 if (image || buf->format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED)
891 return image;
892 }
893
894 const int fourcc = get_fourcc(buf->format);
895 if (fourcc == -1) {
896 _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
897 return NULL;
898 }
899
900 pitch = buf->stride * get_format_bpp(buf->format);
901 if (pitch == 0) {
902 _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
903 return NULL;
904 }
905
906 const EGLint attr_list[] = {
907 EGL_WIDTH, buf->width,
908 EGL_HEIGHT, buf->height,
909 EGL_LINUX_DRM_FOURCC_EXT, fourcc,
910 EGL_DMA_BUF_PLANE0_FD_EXT, fd,
911 EGL_DMA_BUF_PLANE0_PITCH_EXT, pitch,
912 EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
913 EGL_NONE, 0
914 };
915
916 return dri2_create_image_dma_buf(disp, ctx, NULL, attr_list);
917 }
918
919 #ifdef HAVE_DRM_GRALLOC
920 static _EGLImage *
921 droid_create_image_from_name(_EGLDisplay *disp, _EGLContext *ctx,
922 struct ANativeWindowBuffer *buf)
923 {
924 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
925 struct dri2_egl_image *dri2_img;
926 int name;
927 int format;
928
929 name = get_native_buffer_name(buf);
930 if (!name) {
931 _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
932 return NULL;
933 }
934
935 format = get_format(buf->format);
936 if (format == -1)
937 return NULL;
938
939 dri2_img = calloc(1, sizeof(*dri2_img));
940 if (!dri2_img) {
941 _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
942 return NULL;
943 }
944
945 _eglInitImage(&dri2_img->base, disp);
946
947 dri2_img->dri_image =
948 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
949 buf->width,
950 buf->height,
951 format,
952 name,
953 buf->stride,
954 dri2_img);
955 if (!dri2_img->dri_image) {
956 free(dri2_img);
957 _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
958 return NULL;
959 }
960
961 return &dri2_img->base;
962 }
963 #endif /* HAVE_DRM_GRALLOC */
964
965 static EGLBoolean
966 droid_query_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
967 EGLint attribute, EGLint *value)
968 {
969 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
970 switch (attribute) {
971 case EGL_WIDTH:
972 if (dri2_surf->base.Type == EGL_WINDOW_BIT && dri2_surf->window) {
973 dri2_surf->window->query(dri2_surf->window,
974 NATIVE_WINDOW_DEFAULT_WIDTH, value);
975 return EGL_TRUE;
976 }
977 break;
978 case EGL_HEIGHT:
979 if (dri2_surf->base.Type == EGL_WINDOW_BIT && dri2_surf->window) {
980 dri2_surf->window->query(dri2_surf->window,
981 NATIVE_WINDOW_DEFAULT_HEIGHT, value);
982 return EGL_TRUE;
983 }
984 break;
985 default:
986 break;
987 }
988 return _eglQuerySurface(drv, dpy, surf, attribute, value);
989 }
990
991 static _EGLImage *
992 dri2_create_image_android_native_buffer(_EGLDisplay *disp,
993 _EGLContext *ctx,
994 struct ANativeWindowBuffer *buf)
995 {
996 int fd;
997
998 if (ctx != NULL) {
999 /* From the EGL_ANDROID_image_native_buffer spec:
1000 *
1001 * * If <target> is EGL_NATIVE_BUFFER_ANDROID and <ctx> is not
1002 * EGL_NO_CONTEXT, the error EGL_BAD_CONTEXT is generated.
1003 */
1004 _eglError(EGL_BAD_CONTEXT, "eglCreateEGLImageKHR: for "
1005 "EGL_NATIVE_BUFFER_ANDROID, the context must be "
1006 "EGL_NO_CONTEXT");
1007 return NULL;
1008 }
1009
1010 if (!buf || buf->common.magic != ANDROID_NATIVE_BUFFER_MAGIC ||
1011 buf->common.version != sizeof(*buf)) {
1012 _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
1013 return NULL;
1014 }
1015
1016 fd = get_native_buffer_fd(buf);
1017 if (fd >= 0)
1018 return droid_create_image_from_prime_fd(disp, ctx, buf, fd);
1019
1020 #ifdef HAVE_DRM_GRALLOC
1021 return droid_create_image_from_name(disp, ctx, buf);
1022 #else
1023 return NULL;
1024 #endif
1025 }
1026
1027 static _EGLImage *
1028 droid_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
1029 _EGLContext *ctx, EGLenum target,
1030 EGLClientBuffer buffer, const EGLint *attr_list)
1031 {
1032 switch (target) {
1033 case EGL_NATIVE_BUFFER_ANDROID:
1034 return dri2_create_image_android_native_buffer(disp, ctx,
1035 (struct ANativeWindowBuffer *) buffer);
1036 default:
1037 return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
1038 }
1039 }
1040
1041 static void
1042 droid_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
1043 {
1044 }
1045
1046 #ifdef HAVE_DRM_GRALLOC
1047 static int
1048 droid_get_buffers_parse_attachments(struct dri2_egl_surface *dri2_surf,
1049 unsigned int *attachments, int count)
1050 {
1051 int num_buffers = 0;
1052
1053 /* fill dri2_surf->buffers */
1054 for (int i = 0; i < count * 2; i += 2) {
1055 __DRIbuffer *buf, *local;
1056
1057 assert(num_buffers < ARRAY_SIZE(dri2_surf->buffers));
1058 buf = &dri2_surf->buffers[num_buffers];
1059
1060 switch (attachments[i]) {
1061 case __DRI_BUFFER_BACK_LEFT:
1062 if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
1063 buf->attachment = attachments[i];
1064 buf->name = get_native_buffer_name(dri2_surf->buffer);
1065 buf->cpp = get_format_bpp(dri2_surf->buffer->format);
1066 buf->pitch = dri2_surf->buffer->stride * buf->cpp;
1067 buf->flags = 0;
1068
1069 if (buf->name)
1070 num_buffers++;
1071
1072 break;
1073 }
1074 /* fall through for pbuffers */
1075 case __DRI_BUFFER_DEPTH:
1076 case __DRI_BUFFER_STENCIL:
1077 case __DRI_BUFFER_ACCUM:
1078 case __DRI_BUFFER_DEPTH_STENCIL:
1079 case __DRI_BUFFER_HIZ:
1080 local = dri2_egl_surface_alloc_local_buffer(dri2_surf,
1081 attachments[i], attachments[i + 1]);
1082
1083 if (local) {
1084 *buf = *local;
1085 num_buffers++;
1086 }
1087 break;
1088 case __DRI_BUFFER_FRONT_LEFT:
1089 case __DRI_BUFFER_FRONT_RIGHT:
1090 case __DRI_BUFFER_FAKE_FRONT_LEFT:
1091 case __DRI_BUFFER_FAKE_FRONT_RIGHT:
1092 case __DRI_BUFFER_BACK_RIGHT:
1093 default:
1094 /* no front or right buffers */
1095 break;
1096 }
1097 }
1098
1099 return num_buffers;
1100 }
1101
1102 static __DRIbuffer *
1103 droid_get_buffers_with_format(__DRIdrawable * driDrawable,
1104 int *width, int *height,
1105 unsigned int *attachments, int count,
1106 int *out_count, void *loaderPrivate)
1107 {
1108 struct dri2_egl_surface *dri2_surf = loaderPrivate;
1109
1110 if (update_buffers(dri2_surf) < 0)
1111 return NULL;
1112
1113 *out_count = droid_get_buffers_parse_attachments(dri2_surf, attachments, count);
1114
1115 if (width)
1116 *width = dri2_surf->base.Width;
1117 if (height)
1118 *height = dri2_surf->base.Height;
1119
1120 return dri2_surf->buffers;
1121 }
1122 #endif /* HAVE_DRM_GRALLOC */
1123
1124 static unsigned
1125 droid_get_capability(void *loaderPrivate, enum dri_loader_cap cap)
1126 {
1127 /* Note: loaderPrivate is _EGLDisplay* */
1128 switch (cap) {
1129 case DRI_LOADER_CAP_RGBA_ORDERING:
1130 return 1;
1131 default:
1132 return 0;
1133 }
1134 }
1135
1136 static EGLBoolean
1137 droid_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *dpy)
1138 {
1139 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
1140 static const struct {
1141 int format;
1142 unsigned int rgba_masks[4];
1143 } visuals[] = {
1144 { HAL_PIXEL_FORMAT_RGBA_8888, { 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 } },
1145 { HAL_PIXEL_FORMAT_RGBX_8888, { 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000 } },
1146 { HAL_PIXEL_FORMAT_RGB_565, { 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000 } },
1147 { HAL_PIXEL_FORMAT_BGRA_8888, { 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 } },
1148 };
1149
1150 unsigned int format_count[ARRAY_SIZE(visuals)] = { 0 };
1151 int config_count = 0;
1152
1153 /* The nesting of loops is significant here. Also significant is the order
1154 * of the HAL pixel formats. Many Android apps (such as Google's official
1155 * NDK GLES2 example app), and even portions the core framework code (such
1156 * as SystemServiceManager in Nougat), incorrectly choose their EGLConfig.
1157 * They neglect to match the EGLConfig's EGL_NATIVE_VISUAL_ID against the
1158 * window's native format, and instead choose the first EGLConfig whose
1159 * channel sizes match those of the native window format while ignoring the
1160 * channel *ordering*.
1161 *
1162 * We can detect such buggy clients in logcat when they call
1163 * eglCreateSurface, by detecting the mismatch between the EGLConfig's
1164 * format and the window's format.
1165 *
1166 * As a workaround, we generate EGLConfigs such that all EGLConfigs for HAL
1167 * pixel format i precede those for HAL pixel format i+1. In my
1168 * (chadversary) testing on Android Nougat, this was good enough to pacify
1169 * the buggy clients.
1170 */
1171 for (int i = 0; i < ARRAY_SIZE(visuals); i++) {
1172 for (int j = 0; dri2_dpy->driver_configs[j]; j++) {
1173 const EGLint surface_type = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
1174
1175 const EGLint config_attrs[] = {
1176 EGL_NATIVE_VISUAL_ID, visuals[i].format,
1177 EGL_NATIVE_VISUAL_TYPE, visuals[i].format,
1178 EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
1179 EGL_RECORDABLE_ANDROID, EGL_TRUE,
1180 EGL_NONE
1181 };
1182
1183 struct dri2_egl_config *dri2_conf =
1184 dri2_add_config(dpy, dri2_dpy->driver_configs[j],
1185 config_count + 1, surface_type, config_attrs,
1186 visuals[i].rgba_masks);
1187 if (dri2_conf) {
1188 if (dri2_conf->base.ConfigID == config_count + 1)
1189 config_count++;
1190 format_count[i]++;
1191 }
1192 }
1193 }
1194
1195 for (int i = 0; i < ARRAY_SIZE(format_count); i++) {
1196 if (!format_count[i]) {
1197 _eglLog(_EGL_DEBUG, "No DRI config supports native format 0x%x",
1198 visuals[i].format);
1199 }
1200 }
1201
1202 return (config_count != 0);
1203 }
1204
1205 #ifdef HAVE_DRM_GRALLOC
1206 static int
1207 droid_open_device_drm_gralloc(struct dri2_egl_display *dri2_dpy)
1208 {
1209 int fd = -1, err = -EINVAL;
1210
1211 if (dri2_dpy->gralloc->perform)
1212 err = dri2_dpy->gralloc->perform(dri2_dpy->gralloc,
1213 GRALLOC_MODULE_PERFORM_GET_DRM_FD,
1214 &fd);
1215 if (err || fd < 0) {
1216 _eglLog(_EGL_WARNING, "fail to get drm fd");
1217 fd = -1;
1218 }
1219
1220 return (fd >= 0) ? fcntl(fd, F_DUPFD_CLOEXEC, 3) : -1;
1221 }
1222 #endif /* HAVE_DRM_GRALLOC */
1223
1224 static const struct dri2_egl_display_vtbl droid_display_vtbl = {
1225 .authenticate = NULL,
1226 .create_window_surface = droid_create_window_surface,
1227 .create_pixmap_surface = dri2_fallback_create_pixmap_surface,
1228 .create_pbuffer_surface = droid_create_pbuffer_surface,
1229 .destroy_surface = droid_destroy_surface,
1230 .create_image = droid_create_image_khr,
1231 .swap_buffers = droid_swap_buffers,
1232 .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage, /* Android implements the function */
1233 .swap_buffers_region = dri2_fallback_swap_buffers_region,
1234 .swap_interval = droid_swap_interval,
1235 #if ANDROID_API_LEVEL >= 23
1236 .set_damage_region = droid_set_damage_region,
1237 #else
1238 .set_damage_region = dri2_fallback_set_damage_region,
1239 #endif
1240 .post_sub_buffer = dri2_fallback_post_sub_buffer,
1241 .copy_buffers = dri2_fallback_copy_buffers,
1242 .query_buffer_age = droid_query_buffer_age,
1243 .query_surface = droid_query_surface,
1244 .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1245 .get_sync_values = dri2_fallback_get_sync_values,
1246 .get_dri_drawable = dri2_surface_get_dri_drawable,
1247 .set_shared_buffer_mode = droid_set_shared_buffer_mode,
1248 };
1249
1250 #ifdef HAVE_DRM_GRALLOC
1251 static const __DRIdri2LoaderExtension droid_dri2_loader_extension = {
1252 .base = { __DRI_DRI2_LOADER, 4 },
1253
1254 .getBuffers = NULL,
1255 .flushFrontBuffer = droid_flush_front_buffer,
1256 .getBuffersWithFormat = droid_get_buffers_with_format,
1257 .getCapability = droid_get_capability,
1258 };
1259 #endif /* HAVE_DRM_GRALLOC */
1260
1261 static const __DRIimageLoaderExtension droid_image_loader_extension = {
1262 .base = { __DRI_IMAGE_LOADER, 2 },
1263
1264 .getBuffers = droid_image_get_buffers,
1265 .flushFrontBuffer = droid_flush_front_buffer,
1266 .getCapability = droid_get_capability,
1267 };
1268
1269 #ifdef HAVE_DRM_GRALLOC
1270 static const __DRIextension *droid_dri2_loader_extensions[] = {
1271 &droid_dri2_loader_extension.base,
1272 &image_lookup_extension.base,
1273 &use_invalidate.base,
1274 /* No __DRI_MUTABLE_RENDER_BUFFER_LOADER because it requires
1275 * __DRI_IMAGE_LOADER.
1276 */
1277 NULL,
1278 };
1279 #endif /* HAVE_DRM_GRALLOC */
1280
1281 static void
1282 droid_display_shared_buffer(__DRIdrawable *driDrawable, int fence_fd,
1283 void *loaderPrivate)
1284 {
1285 struct dri2_egl_surface *dri2_surf = loaderPrivate;
1286 struct ANativeWindowBuffer *old_buffer UNUSED = dri2_surf->buffer;
1287
1288 if (!_eglSurfaceInSharedBufferMode(&dri2_surf->base)) {
1289 _eglLog(_EGL_WARNING, "%s: internal error: buffer is not shared",
1290 __func__);
1291 return;
1292 }
1293
1294 if (fence_fd >= 0) {
1295 /* The driver's fence is more recent than the surface's out fence, if it
1296 * exists at all. So use the driver's fence.
1297 */
1298 if (dri2_surf->out_fence_fd >= 0) {
1299 close(dri2_surf->out_fence_fd);
1300 dri2_surf->out_fence_fd = -1;
1301 }
1302 } else if (dri2_surf->out_fence_fd >= 0) {
1303 fence_fd = dri2_surf->out_fence_fd;
1304 dri2_surf->out_fence_fd = -1;
1305 }
1306
1307 if (dri2_surf->window->queueBuffer(dri2_surf->window, dri2_surf->buffer,
1308 fence_fd)) {
1309 _eglLog(_EGL_WARNING, "%s: ANativeWindow::queueBuffer failed", __func__);
1310 close(fence_fd);
1311 return;
1312 }
1313
1314 fence_fd = -1;
1315
1316 if (dri2_surf->window->dequeueBuffer(dri2_surf->window, &dri2_surf->buffer,
1317 &fence_fd)) {
1318 /* Tear down the surface because it no longer has a back buffer. */
1319 struct dri2_egl_display *dri2_dpy =
1320 dri2_egl_display(dri2_surf->base.Resource.Display);
1321
1322 _eglLog(_EGL_WARNING, "%s: ANativeWindow::dequeueBuffer failed", __func__);
1323
1324 dri2_surf->base.Lost = true;
1325 dri2_surf->buffer = NULL;
1326 dri2_surf->back = NULL;
1327
1328 if (dri2_surf->dri_image_back) {
1329 dri2_dpy->image->destroyImage(dri2_surf->dri_image_back);
1330 dri2_surf->dri_image_back = NULL;
1331 }
1332
1333 dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
1334 return;
1335 }
1336
1337 if (fence_fd < 0)
1338 return;
1339
1340 /* Access to the buffer is controlled by a sync fence. Block on it.
1341 *
1342 * Ideally, we would submit the fence to the driver, and the driver would
1343 * postpone command execution until it signalled. But DRI lacks API for
1344 * that (as of 2018-04-11).
1345 *
1346 * SYNC_IOC_WAIT waits forever if timeout < 0
1347 */
1348 sync_wait(fence_fd, -1);
1349 close(fence_fd);
1350 }
1351
1352 static const __DRImutableRenderBufferLoaderExtension droid_mutable_render_buffer_extension = {
1353 .base = { __DRI_MUTABLE_RENDER_BUFFER_LOADER, 1 },
1354 .displaySharedBuffer = droid_display_shared_buffer,
1355 };
1356
1357 static const __DRIextension *droid_image_loader_extensions[] = {
1358 &droid_image_loader_extension.base,
1359 &image_lookup_extension.base,
1360 &use_invalidate.base,
1361 &droid_mutable_render_buffer_extension.base,
1362 NULL,
1363 };
1364
1365 EGLBoolean
1366 droid_load_driver(_EGLDisplay *disp)
1367 {
1368 struct dri2_egl_display *dri2_dpy = disp->DriverData;
1369 const char *err;
1370
1371 dri2_dpy->driver_name = loader_get_driver_for_fd(dri2_dpy->fd);
1372 if (dri2_dpy->driver_name == NULL)
1373 return false;
1374
1375 dri2_dpy->is_render_node = drmGetNodeTypeFromFd(dri2_dpy->fd) == DRM_NODE_RENDER;
1376
1377 if (!dri2_dpy->is_render_node) {
1378 #ifdef HAVE_DRM_GRALLOC
1379 /* Handle control nodes using __DRI_DRI2_LOADER extension and GEM names
1380 * for backwards compatibility with drm_gralloc. (Do not use on new
1381 * systems.) */
1382 dri2_dpy->loader_extensions = droid_dri2_loader_extensions;
1383 if (!dri2_load_driver(disp)) {
1384 err = "DRI2: failed to load driver";
1385 goto error;
1386 }
1387 #else
1388 err = "DRI2: handle is not for a render node";
1389 goto error;
1390 #endif
1391 } else {
1392 dri2_dpy->loader_extensions = droid_image_loader_extensions;
1393 if (!dri2_load_driver_dri3(disp)) {
1394 err = "DRI3: failed to load driver";
1395 goto error;
1396 }
1397 }
1398
1399 return true;
1400
1401 error:
1402 free(dri2_dpy->driver_name);
1403 dri2_dpy->driver_name = NULL;
1404 return false;
1405 }
1406
1407 static int
1408 droid_filter_device(_EGLDisplay *disp, int fd, const char *vendor)
1409 {
1410 drmVersionPtr ver = drmGetVersion(fd);
1411 if (!ver)
1412 return -1;
1413
1414 if (strcmp(vendor, ver->name) != 0) {
1415 drmFreeVersion(ver);
1416 return -1;
1417 }
1418
1419 drmFreeVersion(ver);
1420 return 0;
1421 }
1422
1423 static int
1424 droid_open_device(_EGLDisplay *disp)
1425 {
1426 #define MAX_DRM_DEVICES 32
1427 drmDevicePtr device, devices[MAX_DRM_DEVICES] = { NULL };
1428 int prop_set, num_devices;
1429 int fd = -1, fallback_fd = -1;
1430
1431 char *vendor_name = NULL;
1432 char vendor_buf[PROPERTY_VALUE_MAX];
1433
1434 if (property_get("drm.gpu.vendor_name", vendor_buf, NULL) > 0)
1435 vendor_name = vendor_buf;
1436
1437 num_devices = drmGetDevices2(0, devices, ARRAY_SIZE(devices));
1438 if (num_devices < 0)
1439 return num_devices;
1440
1441 for (int i = 0; i < num_devices; i++) {
1442 device = devices[i];
1443
1444 if (!(device->available_nodes & (1 << DRM_NODE_RENDER)))
1445 continue;
1446
1447 fd = loader_open_device(device->nodes[DRM_NODE_RENDER]);
1448 if (fd < 0) {
1449 _eglLog(_EGL_WARNING, "%s() Failed to open DRM device %s",
1450 __func__, device->nodes[DRM_NODE_RENDER]);
1451 continue;
1452 }
1453
1454 if (vendor_name && droid_filter_device(disp, fd, vendor_name)) {
1455 /* Match requested, but not found - set as fallback */
1456 if (fallback_fd == -1) {
1457 fallback_fd = fd;
1458 } else {
1459 close(fd);
1460 fd = -1;
1461 }
1462
1463 continue;
1464 }
1465 /* Found a device */
1466 break;
1467 }
1468 drmFreeDevices(devices, num_devices);
1469
1470 if (fallback_fd < 0 && fd < 0) {
1471 _eglLog(_EGL_WARNING, "Failed to open any DRM device");
1472 return -1;
1473 }
1474
1475 if (fd < 0) {
1476 _eglLog(_EGL_WARNING, "Failed to open desired DRM device, using fallback");
1477 return fallback_fd;
1478 }
1479
1480 close(fallback_fd);
1481 return fd;
1482 #undef MAX_DRM_DEVICES
1483 }
1484
1485 EGLBoolean
1486 dri2_initialize_android(_EGLDriver *drv, _EGLDisplay *disp)
1487 {
1488 struct dri2_egl_display *dri2_dpy;
1489 const char *err;
1490 int ret;
1491
1492 /* Not supported yet */
1493 if (disp->Options.ForceSoftware)
1494 return EGL_FALSE;
1495
1496 loader_set_logger(_eglLog);
1497
1498 dri2_dpy = calloc(1, sizeof(*dri2_dpy));
1499 if (!dri2_dpy)
1500 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1501
1502 dri2_dpy->fd = -1;
1503 ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
1504 (const hw_module_t **)&dri2_dpy->gralloc);
1505 if (ret) {
1506 err = "DRI2: failed to get gralloc module";
1507 goto cleanup;
1508 }
1509
1510 disp->DriverData = (void *) dri2_dpy;
1511
1512 #ifdef HAVE_DRM_GRALLOC
1513 dri2_dpy->fd = droid_open_device_drm_gralloc(dri2_dpy);
1514 #else
1515 dri2_dpy->fd = droid_open_device(disp);
1516 #endif
1517 if (dri2_dpy->fd < 0) {
1518 err = "DRI2: failed to open device";
1519 goto cleanup;
1520 }
1521
1522 if (!droid_load_driver(disp)) {
1523 err = "DRI2: failed to load driver";
1524 goto cleanup;
1525 }
1526
1527 if (!dri2_create_screen(disp)) {
1528 err = "DRI2: failed to create screen";
1529 goto cleanup;
1530 }
1531
1532 if (!dri2_setup_extensions(disp)) {
1533 err = "DRI2: failed to setup extensions";
1534 goto cleanup;
1535 }
1536
1537 dri2_setup_screen(disp);
1538
1539 /* We set the maximum swap interval as 1 for Android platform, since it is
1540 * the maximum value supported by Android according to the value of
1541 * ANativeWindow::maxSwapInterval.
1542 */
1543 dri2_setup_swap_interval(disp, 1);
1544
1545 disp->Extensions.ANDROID_framebuffer_target = EGL_TRUE;
1546 disp->Extensions.ANDROID_image_native_buffer = EGL_TRUE;
1547 disp->Extensions.ANDROID_recordable = EGL_TRUE;
1548 disp->Extensions.EXT_buffer_age = EGL_TRUE;
1549 #if ANDROID_API_LEVEL >= 23
1550 disp->Extensions.KHR_partial_update = EGL_TRUE;
1551 #endif
1552 disp->Extensions.KHR_image = EGL_TRUE;
1553 #if ANDROID_API_LEVEL >= 24
1554 if (dri2_dpy->mutable_render_buffer &&
1555 dri2_dpy->loader_extensions == droid_image_loader_extensions) {
1556 disp->Extensions.KHR_mutable_render_buffer = EGL_TRUE;
1557 }
1558 #endif
1559
1560 /* Create configs *after* enabling extensions because presence of DRI
1561 * driver extensions can affect the capabilities of EGLConfigs.
1562 */
1563 if (!droid_add_configs_for_visuals(drv, disp)) {
1564 err = "DRI2: failed to add configs";
1565 goto cleanup;
1566 }
1567
1568 /* Fill vtbl last to prevent accidentally calling virtual function during
1569 * initialization.
1570 */
1571 dri2_dpy->vtbl = &droid_display_vtbl;
1572
1573 return EGL_TRUE;
1574
1575 cleanup:
1576 dri2_display_destroy(disp);
1577 return _eglError(EGL_NOT_INITIALIZED, err);
1578 }