summarylogtreecommitdiffstats
path: root/0008-gl-renderer-Add-support-for-EGLDevice-composited-fra.patch
blob: 032d2b12b75a02a6320e27f6dd2d863dcd8ba1a8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
From 34433e17e968229bce5eca51946fb85fcbc69f3d Mon Sep 17 00:00:00 2001
From: "Miguel A. Vico" <mvicomoya@nvidia.com>
Date: Mon, 2 May 2016 16:34:01 +0200
Subject: [PATCH 08/12] gl-renderer: Add support for EGLDevice composited frame
 presentation
X-NVConfidentiality: public

EGLDevice provides means to enumerate native devices, and then create
an EGL display connection from them.

Similarly, EGLOutput will provide means to access different
portions of display control hardware associated with an EGLDevice.

For instance, EGLOutputLayer represents a portion of display
control hardware that accepts an image as input and processes it
for presentation on a display device.

EGLStream implements a mechanism to communicate frame producers and
frame consumers. By attaching an EGLOutputLayer consumer to a stream,
a producer will be able to present frames on a display device.

Thus, a compositor could produce frames and feed them to an
EGLOutputLayer through an EGLStream for presentation on a display
device.

This change adds required logic to support presentation approach
described above.

Note that some unpublished EGL extensions were needed:

 - EGL_NV_stream_attrib:
   https://github.com/aritger/eglstreams-kms-example/blob/master/proposed-extensions/EGL_NV_stream_attrib.txt

 - EGL_EXT_stream_acquire_mode:
   https://github.com/aritger/eglstreams-kms-example/blob/master/proposed-extensions/EGL_EXT_stream_acquire_mode.txt

 - EGL_NV_output_drm_flip_event:
   https://github.com/aritger/eglstreams-kms-example/blob/master/proposed-extensions/EGL_NV_output_drm_flip_event.txt

Signed-off-by: Miguel A Vico Moya <mvicomoya@nvidia.com>
Reviewed-by: Andy Ritger <aritger@nvidia.com>
Reviewed-by: Adam Cheney <acheney@nvidia.com>
Reviewed-by: James Jones <jajones@nvidia.com>
---
 libweston/gl-renderer.c    | 262 ++++++++++++++++++++++++++++++++++++++++++++-
 libweston/gl-renderer.h    |  16 +++
 libweston/weston-egl-ext.h |  38 +++++++
 3 files changed, 313 insertions(+), 3 deletions(-)

diff --git a/libweston/gl-renderer.c b/libweston/gl-renderer.c
index 9ef115ae092f..a0efea2ed648 100644
--- a/libweston/gl-renderer.c
+++ b/libweston/gl-renderer.c
@@ -86,6 +86,8 @@ struct gl_output_state {
 	struct gl_border_image borders[4];
 	enum gl_border_status border_status;
 
+	EGLStreamKHR egl_stream;
+
 	struct weston_matrix output_matrix;
 };
 
@@ -204,6 +206,28 @@ struct gl_renderer {
 
 	int has_surfaceless_context;
 
+	PFNEGLGETOUTPUTLAYERSEXTPROC get_output_layers;
+	PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC query_output_layer_attrib;
+	int has_egl_output_base;
+	int has_egl_output_drm;
+	int has_egl_output_drm_flip_event;
+
+	PFNEGLCREATESTREAMKHRPROC create_stream;
+	PFNEGLDESTROYSTREAMKHRPROC destroy_stream;
+	int has_egl_stream;
+
+	PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC create_stream_producer_surface;
+	int has_egl_stream_producer_eglsurface;
+
+	PFNEGLSTREAMCONSUMEROUTPUTEXTPROC stream_consumer_output;
+	int has_egl_stream_consumer_egloutput;
+
+#ifdef EGL_NV_stream_attrib
+	PFNEGLSTREAMCONSUMERACQUIREATTRIBNVPROC stream_consumer_acquire_attrib;
+#endif
+	int has_egl_stream_attrib;
+	int has_egl_stream_acquire_mode;
+
 	int has_dmabuf_import;
 	struct wl_list dmabuf_images;
 
@@ -1189,6 +1213,38 @@ gl_renderer_repaint_output(struct weston_output *output,
 }
 
 static int
+gl_renderer_output_stream_flip(struct weston_output *output,
+			       void *flip_data)
+{
+#if defined(EGL_NV_stream_attrib) && defined(EGL_EXT_stream_acquire_mode)
+	struct gl_output_state *go = get_output_state(output);
+	struct weston_compositor *compositor = output->compositor;
+	struct gl_renderer *gr = get_renderer(compositor);
+
+	EGLAttrib acquire_attribs[3] = { EGL_NONE };
+
+#ifdef EGL_NV_output_drm_flip_event
+	if (gr->has_egl_output_drm_flip_event) {
+		acquire_attribs[0] = EGL_DRM_FLIP_EVENT_DATA_NV;
+		acquire_attribs[1] = (EGLAttrib)flip_data;
+		acquire_attribs[2] = EGL_NONE;
+	}
+#endif
+
+	if (go->egl_stream != EGL_NO_STREAM_KHR)
+		if (gr->stream_consumer_acquire_attrib(
+						gr->egl_display,
+						go->egl_stream,
+						acquire_attribs) != EGL_TRUE)
+			return -1;
+
+	return 0;
+#else
+	return -1;
+#endif
+}
+
+static int
 gl_renderer_read_pixels(struct weston_output *output,
 			       pixman_format_code_t format, void *pixels,
 			       uint32_t x, uint32_t y,
@@ -2584,9 +2640,93 @@ gl_renderer_create_window_surface(struct gl_renderer *gr,
 	return egl_surface;
 }
 
+static EGLSurface
+gl_renderer_create_stream_surface(struct gl_renderer *gr,
+				  uint32_t plane_id,
+				  uint32_t crtc_id,
+				  EGLint width, EGLint height,
+				  EGLStreamKHR *egl_stream)
+{
+	EGLint stream_attribs[] = {
+		EGL_STREAM_FIFO_LENGTH_KHR, 1,
+#ifdef EGL_EXT_stream_acquire_mode
+		EGL_CONSUMER_AUTO_ACQUIRE_EXT, EGL_FALSE,
+#endif
+		EGL_NONE
+	};
+	EGLAttrib output_attribs[3];
+	EGLint stream_producer_attribs[] = {
+		EGL_WIDTH, width,
+		EGL_HEIGHT, height,
+		EGL_NONE
+	};
+
+	EGLint num_layers;
+	EGLOutputLayerEXT output_layer;
+	EGLSurface egl_surface = EGL_NO_SURFACE;
+
+	*egl_stream = gr->create_stream(gr->egl_display, stream_attribs);
+
+	if (*egl_stream == EGL_NO_STREAM_KHR) {
+		weston_log("Failed to create EGL stream.\n");
+		goto err_egl_create_surf_base;
+	}
+
+	if (plane_id != ~0u) {
+		output_attribs[0] = EGL_DRM_PLANE_EXT;
+		output_attribs[1] = plane_id;
+	} else {
+		assert(crtc_id != ~0u);
+		output_attribs[0] = EGL_DRM_CRTC_EXT;
+		output_attribs[1] = crtc_id;
+	}
+	output_attribs[2] = EGL_NONE;
+
+	if (gr->get_output_layers(gr->egl_display,
+				  output_attribs,
+				  &output_layer,
+				  1, &num_layers) != EGL_TRUE) {
+		weston_log("Failed to get output layer.\n");
+		goto err_egl_create_surf_stream;
+	}
+
+	if (num_layers < 1) {
+		weston_log("Unable to find output layers.\n");
+		goto err_egl_create_surf_stream;
+	}
+
+	if (gr->stream_consumer_output(gr->egl_display, *egl_stream,
+				       output_layer) != EGL_TRUE) {
+		weston_log("Failed to set EGL stream consumer.\n");
+		goto err_egl_create_surf_stream;
+	}
+
+	egl_surface = gr->create_stream_producer_surface(
+						gr->egl_display,
+						gr->egl_config,
+						*egl_stream,
+						stream_producer_attribs);
+
+	if (egl_surface == EGL_NO_SURFACE) {
+		weston_log("Failed to create EGL producer surface.\n");
+		goto err_egl_create_surf_stream;
+	}
+
+	return egl_surface;
+
+err_egl_create_surf_stream:
+	gr->destroy_stream(gr->egl_display, *egl_stream);
+	*egl_stream = EGL_NO_STREAM_KHR;
+
+err_egl_create_surf_base:
+	gl_renderer_print_egl_error_state();
+	return EGL_NO_SURFACE;
+}
+
 static int
 gl_renderer_output_create(struct weston_output *output,
-			  EGLSurface surface)
+			  EGLSurface surface,
+			  EGLStreamKHR stream)
 {
 	struct gl_output_state *go;
 	int i;
@@ -2596,6 +2736,7 @@ gl_renderer_output_create(struct weston_output *output,
 		return -1;
 
 	go->egl_surface = surface;
+	go->egl_stream = stream;
 
 	for (i = 0; i < BUFFER_DAMAGE_COUNT; i++)
 		pixman_region32_init(&go->buffer_damage[i]);
@@ -2628,13 +2769,41 @@ gl_renderer_output_window_create(struct weston_output *output,
 		return -1;
 	}
 
-	ret = gl_renderer_output_create(output, egl_surface);
+	ret = gl_renderer_output_create(output, egl_surface, EGL_NO_STREAM_KHR);
 	if (ret < 0)
 		eglDestroySurface(gr->egl_display, egl_surface);
 
 	return ret;
 }
 
+static int
+gl_renderer_output_stream_create(struct weston_output *output,
+				 uint32_t plane_id, uint32_t crtc_id)
+{
+	struct weston_compositor *ec = output->compositor;
+	struct gl_renderer *gr = get_renderer(ec);
+	EGLSurface egl_surface = EGL_NO_SURFACE;
+	EGLStreamKHR egl_stream = EGL_NO_STREAM_KHR;
+	int ret;
+
+	egl_surface =
+		gl_renderer_create_stream_surface(gr,
+						  plane_id, crtc_id,
+						  output->current_mode->width,
+						  output->current_mode->height,
+						  &egl_stream);
+	if (egl_surface == EGL_NO_SURFACE)
+		return -1;
+
+	ret = gl_renderer_output_create(output, egl_surface, egl_stream);
+	if (ret < 0) {
+		eglDestroySurface(gr->egl_display, egl_surface);
+		gr->destroy_stream(gr->egl_display, egl_stream);
+	}
+
+	return ret;
+}
+
 static void
 gl_renderer_output_destroy(struct weston_output *output)
 {
@@ -2647,6 +2816,9 @@ gl_renderer_output_destroy(struct weston_output *output)
 
 	eglDestroySurface(gr->egl_display, go->egl_surface);
 
+	if (go->egl_stream != EGL_NO_STREAM_KHR)
+		gr->destroy_stream(gr->egl_display, go->egl_stream);
+
 	free(go);
 }
 
@@ -2728,6 +2900,19 @@ gl_renderer_setup_egl_extensions(struct weston_compositor *ec)
 		(void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
 	gr->query_buffer =
 		(void *) eglGetProcAddress("eglQueryWaylandBufferWL");
+	gr->get_output_layers = (void *) eglGetProcAddress("eglGetOutputLayersEXT");
+	gr->query_output_layer_attrib =
+		(void *) eglGetProcAddress("eglQueryOutputLayerAttribEXT");
+	gr->create_stream = (void *) eglGetProcAddress("eglCreateStreamKHR");
+	gr->destroy_stream = (void *) eglGetProcAddress("eglDestroyStreamKHR");
+	gr->create_stream_producer_surface =
+		(void *) eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
+	gr->stream_consumer_output =
+		(void *) eglGetProcAddress("eglStreamConsumerOutputEXT");
+#ifdef EGL_NV_stream_attrib
+	gr->stream_consumer_acquire_attrib =
+		(void *) eglGetProcAddress("eglStreamConsumerAcquireAttribNV");
+#endif
 
 	extensions =
 		(const char *) eglQueryString(gr->egl_display, EGL_EXTENSIONS);
@@ -2766,6 +2951,30 @@ gl_renderer_setup_egl_extensions(struct weston_compositor *ec)
 	if (weston_check_egl_extension(extensions, "EGL_EXT_image_dma_buf_import"))
 		gr->has_dmabuf_import = 1;
 
+	if (weston_check_egl_extension(extensions, "EGL_EXT_output_base"))
+		gr->has_egl_output_base = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_EXT_output_drm"))
+		gr->has_egl_output_drm = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_NV_output_drm_flip_event"))
+		gr->has_egl_output_drm_flip_event = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_KHR_stream"))
+		gr->has_egl_stream = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_KHR_stream_producer_eglsurface"))
+		gr->has_egl_stream_producer_eglsurface = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_EXT_stream_consumer_egloutput"))
+		gr->has_egl_stream_consumer_egloutput = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_NV_stream_attrib"))
+		gr->has_egl_stream_attrib = 1;
+
+	if (weston_check_egl_extension(extensions, "EGL_EXT_stream_acquire_mode"))
+		gr->has_egl_stream_acquire_mode = 1;
+
 	renderer_setup_egl_client_extensions(gr);
 
 	return 0;
@@ -2791,6 +3000,15 @@ static const EGLint gl_renderer_alpha_attribs[] = {
 	EGL_NONE
 };
 
+static const EGLint gl_renderer_opaque_stream_attribs[] = {
+	EGL_SURFACE_TYPE, EGL_STREAM_BIT_KHR,
+	EGL_RED_SIZE, 1,
+	EGL_GREEN_SIZE, 1,
+	EGL_BLUE_SIZE, 1,
+	EGL_ALPHA_SIZE, 0,
+	EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+	EGL_NONE
+};
 
 /** Checks whether a platform EGL client extension is supported
  *
@@ -2864,6 +3082,8 @@ platform_to_extension(EGLenum platform)
 		return "wayland";
 	case EGL_PLATFORM_X11_KHR:
 		return "x11";
+	case EGL_PLATFORM_DEVICE_EXT:
+		return "device";
 	default:
 		assert(0 && "bad EGL platform enum");
 	}
@@ -3000,6 +3220,38 @@ gl_renderer_display_create(struct weston_compositor *ec, EGLenum platform,
 	if (gl_renderer_setup_egl_extensions(ec) < 0)
 		goto fail_with_error;
 
+	if (platform == EGL_PLATFORM_DEVICE_EXT) {
+		if (!gr->has_egl_output_base ||
+		    !gr->has_egl_output_drm ||
+		    !gr->has_egl_stream ||
+		    !gr->has_egl_stream_producer_eglsurface ||
+		    !gr->has_egl_stream_consumer_egloutput ||
+		    !gr->has_egl_stream_attrib ||
+		    !gr->has_egl_stream_acquire_mode) {
+			weston_log("following required extensions not "
+				"supported:\n%s%s%s%s%s%s%s",
+				(gr->has_egl_output_base                ? "" :
+					"    EGL_EXT_output_base\n"),
+				(gr->has_egl_output_drm                 ? "" :
+					"    EGL_EXT_output_drm\n"),
+				(gr->has_egl_stream                     ? "" :
+					"    EGL_KHR_stream\n"),
+				(gr->has_egl_stream_producer_eglsurface ? "" :
+					"    EGL_KHR_stream_producer_eglsurface\n"),
+				(gr->has_egl_stream_consumer_egloutput  ? "" :
+					"    EGL_EXT_stream_consumer_egloutput\n"),
+				(gr->has_egl_stream_attrib              ? "" :
+					"    EGL_NV_stream_attrib\n"),
+				(gr->has_egl_stream_acquire_mode        ? "" :
+					"    EGL_EXT_stream_acquire_mode\n"));
+			goto fail_terminate;
+		}
+
+		if (!gr->has_egl_output_drm_flip_event)
+			weston_log("warning: EGL page flip event notification "
+				   "not supported\n");
+	}
+
 	wl_list_init(&gr->dmabuf_images);
 	if (gr->has_dmabuf_import)
 		gr->base.import_dmabuf = gl_renderer_import_dmabuf;
@@ -3295,15 +3547,19 @@ gl_renderer_get_drm_device_file(EGLDeviceEXT device,
 WL_EXPORT struct gl_renderer_interface gl_renderer_interface = {
 	.opaque_attribs = gl_renderer_opaque_attribs,
 	.alpha_attribs = gl_renderer_alpha_attribs,
+	.opaque_stream_attribs = gl_renderer_opaque_stream_attribs,
 
 	.display_create = gl_renderer_display_create,
 	.display = gl_renderer_display,
 	.output_window_create = gl_renderer_output_window_create,
+	.output_stream_create = gl_renderer_output_stream_create,
 	.output_destroy = gl_renderer_output_destroy,
 	.output_surface = gl_renderer_output_surface,
 	.output_set_border = gl_renderer_output_set_border,
 	.print_egl_error_state = gl_renderer_print_egl_error_state,
 
 	.get_devices = gl_renderer_get_devices,
-	.get_drm_device_file = gl_renderer_get_drm_device_file
+	.get_drm_device_file = gl_renderer_get_drm_device_file,
+
+	.output_stream_flip = gl_renderer_output_stream_flip
 };
diff --git a/libweston/gl-renderer.h b/libweston/gl-renderer.h
index 2840ee5bea28..6e2fd34f4257 100644
--- a/libweston/gl-renderer.h
+++ b/libweston/gl-renderer.h
@@ -59,6 +59,7 @@ enum gl_renderer_border_side {
 struct gl_renderer_interface {
 	const EGLint *opaque_attribs;
 	const EGLint *alpha_attribs;
+	const EGLint *opaque_stream_attribs;
 
 	int (*display_create)(struct weston_compositor *ec,
 			      EGLenum platform,
@@ -77,6 +78,9 @@ struct gl_renderer_interface {
 				    const EGLint *visual_id,
 				    const int n_ids);
 
+	int (*output_stream_create)(struct weston_output *output,
+				    uint32_t plane_id, uint32_t crtc_id);
+
 	void (*output_destroy)(struct weston_output *output);
 
 	EGLSurface (*output_surface)(struct weston_output *output);
@@ -121,5 +125,17 @@ struct gl_renderer_interface {
 
 	int (*get_drm_device_file)(EGLDeviceEXT device,
 				   const char **drm_device_file);
+
+	/*
+	 * output_stream_flip() makes the EGLOutput consumer attached to the
+	 * corresponding <output> stream acquire the new available frame
+	 * (repaint_output() has been called previously) and queue a page flip.
+	 * Whenever DRM is the underlying API and EGL_NV_output_drm_flip_event
+	 * is supported, page flip notification can be requested by passing a
+	 * non-NULL <flip_data> pointer. Otherwise, compositors should rely on a
+	 * different mechanism in order to re-schedule output repaints.
+	 */
+	int (*output_stream_flip)(struct weston_output *output,
+				  void *flip_data);
 };
 
diff --git a/libweston/weston-egl-ext.h b/libweston/weston-egl-ext.h
index 6e3699602b5b..709c80959b66 100644
--- a/libweston/weston-egl-ext.h
+++ b/libweston/weston-egl-ext.h
@@ -152,5 +152,43 @@ typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC) (EGLD
 #define EGL_PLATFORM_X11_KHR 0x31D5
 #endif
 
+#ifndef EGL_PLATFORM_DEVICE_EXT
+#define EGL_PLATFORM_DEVICE_EXT 0x313F
+#endif
+
+/*
+ * FIXME: Remove both EGL_EXT_stream_acquire_mode and
+ *        EGL_NV_output_drm_flip_event definitions below once both extensions
+ *        get published by Khronos and incorportated into Khronos' header files
+ */
+#ifndef EGL_NV_stream_attrib
+#define EGL_NV_stream_attrib 1
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamAttribNV(EGLDisplay dpy, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglSetStreamAttribNV(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamAttribNV(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib *value);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireAttribNV(EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseAttribNV(EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#endif
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMATTRIBNVPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSTREAMATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEATTRIBNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#endif /* EGL_NV_stream_attrib */
+
+#ifndef EGL_EXT_stream_acquire_mode
+#define EGL_EXT_stream_acquire_mode 1
+#define EGL_CONSUMER_AUTO_ACQUIRE_EXT         0x332B
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREATTRIBEXTPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireAttribEXT (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#endif
+#endif /* EGL_EXT_stream_acquire_mode */
+
+#ifndef EGL_NV_output_drm_flip_event
+#define EGL_NV_output_drm_flip_event 1
+#define EGL_DRM_FLIP_EVENT_DATA_NV            0x333E
+#endif /* EGL_NV_output_drm_flip_event */
 
 #endif
-- 
2.10.2