2 * Mesa 3-D graphics library
4 * Copyright 2009, VMware, Inc.
6 * Copyright (C) 2010 LunarG Inc.
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:
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR 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
22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
27 * Keith Whitwell <keithw@vmware.com> Jakob Bornecrantz
28 * <wallbraker@gmail.com> Chia-I Wu <olv@lunarg.com>
32 #include "GL/mesa_glinterop.h"
33 #include "util/disk_cache.h"
34 #include "util/u_memory.h"
35 #include "util/u_inlines.h"
36 #include "util/format/u_format.h"
37 #include "util/u_debug.h"
38 #include "frontend/drm_driver.h"
39 #include "state_tracker/st_cb_bufferobjects.h"
40 #include "state_tracker/st_cb_fbo.h"
41 #include "state_tracker/st_cb_texture.h"
42 #include "state_tracker/st_texture.h"
43 #include "state_tracker/st_context.h"
44 #include "pipe-loader/pipe_loader.h"
45 #include "main/bufferobj.h"
46 #include "main/texobj.h"
50 #include "dri_helpers.h"
51 #include "dri_drawable.h"
52 #include "dri_query_renderer.h"
54 #include "drm-uapi/drm_fourcc.h"
59 struct pipe_resource
*resource
;
62 static inline struct dri2_buffer
*
63 dri2_buffer(__DRIbuffer
* driBufferPriv
)
65 return (struct dri2_buffer
*) driBufferPriv
;
69 * DRI2 flush extension.
72 dri2_flush_drawable(__DRIdrawable
*dPriv
)
74 dri_flush(dPriv
->driContextPriv
, dPriv
, __DRI2_FLUSH_DRAWABLE
, -1);
78 dri2_invalidate_drawable(__DRIdrawable
*dPriv
)
80 struct dri_drawable
*drawable
= dri_drawable(dPriv
);
82 dri2InvalidateDrawable(dPriv
);
83 drawable
->dPriv
->lastStamp
= drawable
->dPriv
->dri2
.stamp
;
84 drawable
->texture_mask
= 0;
86 p_atomic_inc(&drawable
->base
.stamp
);
89 static const __DRI2flushExtension dri2FlushExtension
= {
90 .base
= { __DRI2_FLUSH
, 4 },
92 .flush
= dri2_flush_drawable
,
93 .invalidate
= dri2_invalidate_drawable
,
94 .flush_with_flags
= dri_flush
,
98 * Retrieve __DRIbuffer from the DRI loader.
101 dri2_drawable_get_buffers(struct dri_drawable
*drawable
,
102 const enum st_attachment_type
*atts
,
105 __DRIdrawable
*dri_drawable
= drawable
->dPriv
;
106 const __DRIdri2LoaderExtension
*loader
= drawable
->sPriv
->dri2
.loader
;
108 __DRIbuffer
*buffers
;
110 unsigned attachments
[10];
111 unsigned num_attachments
, i
;
114 with_format
= dri_with_format(drawable
->sPriv
);
118 /* for Xserver 1.6.0 (DRI2 version 1) we always need to ask for the front */
120 attachments
[num_attachments
++] = __DRI_BUFFER_FRONT_LEFT
;
122 for (i
= 0; i
< *count
; i
++) {
123 enum pipe_format format
;
127 dri_drawable_get_format(drawable
, atts
[i
], &format
, &bind
);
128 if (format
== PIPE_FORMAT_NONE
)
132 case ST_ATTACHMENT_FRONT_LEFT
:
136 att
= __DRI_BUFFER_FRONT_LEFT
;
138 case ST_ATTACHMENT_BACK_LEFT
:
139 att
= __DRI_BUFFER_BACK_LEFT
;
141 case ST_ATTACHMENT_FRONT_RIGHT
:
142 att
= __DRI_BUFFER_FRONT_RIGHT
;
144 case ST_ATTACHMENT_BACK_RIGHT
:
145 att
= __DRI_BUFFER_BACK_RIGHT
;
152 * In this switch statement we must support all formats that
153 * may occur as the stvis->color_format.
156 case PIPE_FORMAT_R16G16B16A16_FLOAT
:
159 case PIPE_FORMAT_R16G16B16X16_FLOAT
:
162 case PIPE_FORMAT_B10G10R10A2_UNORM
:
163 case PIPE_FORMAT_R10G10B10A2_UNORM
:
164 case PIPE_FORMAT_BGRA8888_UNORM
:
165 case PIPE_FORMAT_RGBA8888_UNORM
:
168 case PIPE_FORMAT_R10G10B10X2_UNORM
:
169 case PIPE_FORMAT_B10G10R10X2_UNORM
:
172 case PIPE_FORMAT_BGRX8888_UNORM
:
173 case PIPE_FORMAT_RGBX8888_UNORM
:
176 case PIPE_FORMAT_B5G6R5_UNORM
:
180 depth
= util_format_get_blocksizebits(format
);
181 assert(!"Unexpected format in dri2_drawable_get_buffers()");
184 attachments
[num_attachments
++] = att
;
186 attachments
[num_attachments
++] = depth
;
191 num_attachments
/= 2;
192 buffers
= loader
->getBuffersWithFormat(dri_drawable
,
193 &dri_drawable
->w
, &dri_drawable
->h
,
194 attachments
, num_attachments
,
195 &num_buffers
, dri_drawable
->loaderPrivate
);
198 buffers
= loader
->getBuffers(dri_drawable
,
199 &dri_drawable
->w
, &dri_drawable
->h
,
200 attachments
, num_attachments
,
201 &num_buffers
, dri_drawable
->loaderPrivate
);
205 *count
= num_buffers
;
211 dri_image_drawable_get_buffers(struct dri_drawable
*drawable
,
212 struct __DRIimageList
*images
,
213 const enum st_attachment_type
*statts
,
214 unsigned statts_count
)
216 __DRIdrawable
*dPriv
= drawable
->dPriv
;
217 __DRIscreen
*sPriv
= drawable
->sPriv
;
218 unsigned int image_format
= __DRI_IMAGE_FORMAT_NONE
;
220 uint32_t buffer_mask
= 0;
223 for (i
= 0; i
< statts_count
; i
++) {
224 dri_drawable_get_format(drawable
, statts
[i
], &pf
, &bind
);
225 if (pf
== PIPE_FORMAT_NONE
)
229 case ST_ATTACHMENT_FRONT_LEFT
:
230 buffer_mask
|= __DRI_IMAGE_BUFFER_FRONT
;
232 case ST_ATTACHMENT_BACK_LEFT
:
233 buffer_mask
|= __DRI_IMAGE_BUFFER_BACK
;
240 case PIPE_FORMAT_R16G16B16A16_FLOAT
:
241 image_format
= __DRI_IMAGE_FORMAT_ABGR16161616F
;
243 case PIPE_FORMAT_R16G16B16X16_FLOAT
:
244 image_format
= __DRI_IMAGE_FORMAT_XBGR16161616F
;
246 case PIPE_FORMAT_B5G5R5A1_UNORM
:
247 image_format
= __DRI_IMAGE_FORMAT_ARGB1555
;
249 case PIPE_FORMAT_B5G6R5_UNORM
:
250 image_format
= __DRI_IMAGE_FORMAT_RGB565
;
252 case PIPE_FORMAT_BGRX8888_UNORM
:
253 image_format
= __DRI_IMAGE_FORMAT_XRGB8888
;
255 case PIPE_FORMAT_BGRA8888_UNORM
:
256 image_format
= __DRI_IMAGE_FORMAT_ARGB8888
;
258 case PIPE_FORMAT_RGBX8888_UNORM
:
259 image_format
= __DRI_IMAGE_FORMAT_XBGR8888
;
261 case PIPE_FORMAT_RGBA8888_UNORM
:
262 image_format
= __DRI_IMAGE_FORMAT_ABGR8888
;
264 case PIPE_FORMAT_B10G10R10X2_UNORM
:
265 image_format
= __DRI_IMAGE_FORMAT_XRGB2101010
;
267 case PIPE_FORMAT_B10G10R10A2_UNORM
:
268 image_format
= __DRI_IMAGE_FORMAT_ARGB2101010
;
270 case PIPE_FORMAT_R10G10B10X2_UNORM
:
271 image_format
= __DRI_IMAGE_FORMAT_XBGR2101010
;
273 case PIPE_FORMAT_R10G10B10A2_UNORM
:
274 image_format
= __DRI_IMAGE_FORMAT_ABGR2101010
;
277 image_format
= __DRI_IMAGE_FORMAT_NONE
;
282 return (*sPriv
->image
.loader
->getBuffers
) (dPriv
, image_format
,
283 (uint32_t *) &drawable
->base
.stamp
,
284 dPriv
->loaderPrivate
, buffer_mask
,
289 dri2_allocate_buffer(__DRIscreen
*sPriv
,
290 unsigned attachment
, unsigned format
,
291 int width
, int height
)
293 struct dri_screen
*screen
= dri_screen(sPriv
);
294 struct dri2_buffer
*buffer
;
295 struct pipe_resource templ
;
298 struct winsys_handle whandle
;
300 switch (attachment
) {
301 case __DRI_BUFFER_FRONT_LEFT
:
302 case __DRI_BUFFER_FAKE_FRONT_LEFT
:
303 bind
= PIPE_BIND_RENDER_TARGET
| PIPE_BIND_SAMPLER_VIEW
;
305 case __DRI_BUFFER_BACK_LEFT
:
306 bind
= PIPE_BIND_RENDER_TARGET
| PIPE_BIND_SAMPLER_VIEW
;
308 case __DRI_BUFFER_DEPTH
:
309 case __DRI_BUFFER_DEPTH_STENCIL
:
310 case __DRI_BUFFER_STENCIL
:
311 bind
= PIPE_BIND_DEPTH_STENCIL
; /* XXX sampler? */
315 /* because we get the handle and stride */
316 bind
|= PIPE_BIND_SHARED
;
320 pf
= PIPE_FORMAT_R16G16B16A16_FLOAT
;
323 pf
= PIPE_FORMAT_R16G16B16X16_FLOAT
;
326 pf
= PIPE_FORMAT_BGRA8888_UNORM
;
329 pf
= PIPE_FORMAT_B10G10R10X2_UNORM
;
332 pf
= PIPE_FORMAT_BGRX8888_UNORM
;
335 pf
= PIPE_FORMAT_Z16_UNORM
;
341 buffer
= CALLOC_STRUCT(dri2_buffer
);
345 memset(&templ
, 0, sizeof(templ
));
348 templ
.target
= PIPE_TEXTURE_2D
;
349 templ
.last_level
= 0;
350 templ
.width0
= width
;
351 templ
.height0
= height
;
353 templ
.array_size
= 1;
356 screen
->base
.screen
->resource_create(screen
->base
.screen
, &templ
);
357 if (!buffer
->resource
) {
362 memset(&whandle
, 0, sizeof(whandle
));
363 if (screen
->can_share_buffer
)
364 whandle
.type
= WINSYS_HANDLE_TYPE_SHARED
;
366 whandle
.type
= WINSYS_HANDLE_TYPE_KMS
;
368 screen
->base
.screen
->resource_get_handle(screen
->base
.screen
, NULL
,
369 buffer
->resource
, &whandle
,
370 PIPE_HANDLE_USAGE_EXPLICIT_FLUSH
);
372 buffer
->base
.attachment
= attachment
;
373 buffer
->base
.name
= whandle
.handle
;
374 buffer
->base
.cpp
= util_format_get_blocksize(pf
);
375 buffer
->base
.pitch
= whandle
.stride
;
377 return &buffer
->base
;
381 dri2_release_buffer(__DRIscreen
*sPriv
, __DRIbuffer
*bPriv
)
383 struct dri2_buffer
*buffer
= dri2_buffer(bPriv
);
385 pipe_resource_reference(&buffer
->resource
, NULL
);
390 * Backend functions for st_framebuffer interface.
394 dri2_allocate_textures(struct dri_context
*ctx
,
395 struct dri_drawable
*drawable
,
396 const enum st_attachment_type
*statts
,
397 unsigned statts_count
)
399 __DRIscreen
*sPriv
= drawable
->sPriv
;
400 __DRIdrawable
*dri_drawable
= drawable
->dPriv
;
401 struct dri_screen
*screen
= dri_screen(sPriv
);
402 struct pipe_resource templ
;
403 boolean alloc_depthstencil
= FALSE
;
405 const __DRIimageLoaderExtension
*image
= sPriv
->image
.loader
;
406 /* Image specific variables */
407 struct __DRIimageList images
;
408 /* Dri2 specific variables */
409 __DRIbuffer
*buffers
= NULL
;
410 struct winsys_handle whandle
;
411 unsigned num_buffers
= statts_count
;
413 /* First get the buffers from the loader */
415 if (!dri_image_drawable_get_buffers(drawable
, &images
,
416 statts
, statts_count
))
420 buffers
= dri2_drawable_get_buffers(drawable
, statts
, &num_buffers
);
421 if (!buffers
|| (drawable
->old_num
== num_buffers
&&
422 drawable
->old_w
== dri_drawable
->w
&&
423 drawable
->old_h
== dri_drawable
->h
&&
424 memcmp(drawable
->old
, buffers
,
425 sizeof(__DRIbuffer
) * num_buffers
) == 0))
429 /* Second clean useless resources*/
431 /* See if we need a depth-stencil buffer. */
432 for (i
= 0; i
< statts_count
; i
++) {
433 if (statts
[i
] == ST_ATTACHMENT_DEPTH_STENCIL
) {
434 alloc_depthstencil
= TRUE
;
439 /* Delete the resources we won't need. */
440 for (i
= 0; i
< ST_ATTACHMENT_COUNT
; i
++) {
441 /* Don't delete the depth-stencil buffer, we can reuse it. */
442 if (i
== ST_ATTACHMENT_DEPTH_STENCIL
&& alloc_depthstencil
)
445 /* Flush the texture before unreferencing, so that other clients can
446 * see what the driver has rendered.
448 if (i
!= ST_ATTACHMENT_DEPTH_STENCIL
&& drawable
->textures
[i
]) {
449 struct pipe_context
*pipe
= ctx
->st
->pipe
;
450 pipe
->flush_resource(pipe
, drawable
->textures
[i
]);
453 pipe_resource_reference(&drawable
->textures
[i
], NULL
);
456 if (drawable
->stvis
.samples
> 1) {
457 for (i
= 0; i
< ST_ATTACHMENT_COUNT
; i
++) {
460 /* Don't delete MSAA resources for the attachments which are enabled,
461 * we can reuse them. */
462 for (j
= 0; j
< statts_count
; j
++) {
463 if (i
== statts
[j
]) {
470 pipe_resource_reference(&drawable
->msaa_textures
[i
], NULL
);
475 /* Third use the buffers retrieved to fill the drawable info */
477 memset(&templ
, 0, sizeof(templ
));
478 templ
.target
= screen
->target
;
479 templ
.last_level
= 0;
481 templ
.array_size
= 1;
484 if (images
.image_mask
& __DRI_IMAGE_BUFFER_FRONT
) {
485 struct pipe_resource
**buf
=
486 &drawable
->textures
[ST_ATTACHMENT_FRONT_LEFT
];
487 struct pipe_resource
*texture
= images
.front
->texture
;
489 dri_drawable
->w
= texture
->width0
;
490 dri_drawable
->h
= texture
->height0
;
492 pipe_resource_reference(buf
, texture
);
495 if (images
.image_mask
& __DRI_IMAGE_BUFFER_BACK
) {
496 struct pipe_resource
**buf
=
497 &drawable
->textures
[ST_ATTACHMENT_BACK_LEFT
];
498 struct pipe_resource
*texture
= images
.back
->texture
;
500 dri_drawable
->w
= texture
->width0
;
501 dri_drawable
->h
= texture
->height0
;
503 pipe_resource_reference(buf
, texture
);
506 /* Note: if there is both a back and a front buffer,
507 * then they have the same size.
509 templ
.width0
= dri_drawable
->w
;
510 templ
.height0
= dri_drawable
->h
;
513 memset(&whandle
, 0, sizeof(whandle
));
515 /* Process DRI-provided buffers and get pipe_resources. */
516 for (i
= 0; i
< num_buffers
; i
++) {
517 __DRIbuffer
*buf
= &buffers
[i
];
518 enum st_attachment_type statt
;
519 enum pipe_format format
;
521 switch (buf
->attachment
) {
522 case __DRI_BUFFER_FRONT_LEFT
:
523 if (!screen
->auto_fake_front
) {
524 continue; /* invalid attachment */
527 case __DRI_BUFFER_FAKE_FRONT_LEFT
:
528 statt
= ST_ATTACHMENT_FRONT_LEFT
;
530 case __DRI_BUFFER_BACK_LEFT
:
531 statt
= ST_ATTACHMENT_BACK_LEFT
;
534 continue; /* invalid attachment */
537 dri_drawable_get_format(drawable
, statt
, &format
, &bind
);
538 if (format
== PIPE_FORMAT_NONE
)
541 /* dri2_drawable_get_buffers has already filled dri_drawable->w
542 * and dri_drawable->h */
543 templ
.width0
= dri_drawable
->w
;
544 templ
.height0
= dri_drawable
->h
;
545 templ
.format
= format
;
547 whandle
.handle
= buf
->name
;
548 whandle
.stride
= buf
->pitch
;
550 whandle
.format
= format
;
551 whandle
.modifier
= DRM_FORMAT_MOD_INVALID
;
552 if (screen
->can_share_buffer
)
553 whandle
.type
= WINSYS_HANDLE_TYPE_SHARED
;
555 whandle
.type
= WINSYS_HANDLE_TYPE_KMS
;
556 drawable
->textures
[statt
] =
557 screen
->base
.screen
->resource_from_handle(screen
->base
.screen
,
559 PIPE_HANDLE_USAGE_EXPLICIT_FLUSH
);
560 assert(drawable
->textures
[statt
]);
564 /* Allocate private MSAA colorbuffers. */
565 if (drawable
->stvis
.samples
> 1) {
566 for (i
= 0; i
< statts_count
; i
++) {
567 enum st_attachment_type statt
= statts
[i
];
569 if (statt
== ST_ATTACHMENT_DEPTH_STENCIL
)
572 if (drawable
->textures
[statt
]) {
573 templ
.format
= drawable
->textures
[statt
]->format
;
574 templ
.bind
= drawable
->textures
[statt
]->bind
&
575 ~(PIPE_BIND_SCANOUT
| PIPE_BIND_SHARED
);
576 templ
.nr_samples
= drawable
->stvis
.samples
;
577 templ
.nr_storage_samples
= drawable
->stvis
.samples
;
579 /* Try to reuse the resource.
580 * (the other resource parameters should be constant)
582 if (!drawable
->msaa_textures
[statt
] ||
583 drawable
->msaa_textures
[statt
]->width0
!= templ
.width0
||
584 drawable
->msaa_textures
[statt
]->height0
!= templ
.height0
) {
585 /* Allocate a new one. */
586 pipe_resource_reference(&drawable
->msaa_textures
[statt
], NULL
);
588 drawable
->msaa_textures
[statt
] =
589 screen
->base
.screen
->resource_create(screen
->base
.screen
,
591 assert(drawable
->msaa_textures
[statt
]);
593 /* If there are any MSAA resources, we should initialize them
594 * such that they contain the same data as the single-sample
595 * resources we just got from the X server.
597 * The reason for this is that the gallium frontend (and
598 * therefore the app) can access the MSAA resources only.
599 * The single-sample resources are not exposed
600 * to the gallium frontend.
603 dri_pipe_blit(ctx
->st
->pipe
,
604 drawable
->msaa_textures
[statt
],
605 drawable
->textures
[statt
]);
609 pipe_resource_reference(&drawable
->msaa_textures
[statt
], NULL
);
614 /* Allocate a private depth-stencil buffer. */
615 if (alloc_depthstencil
) {
616 enum st_attachment_type statt
= ST_ATTACHMENT_DEPTH_STENCIL
;
617 struct pipe_resource
**zsbuf
;
618 enum pipe_format format
;
621 dri_drawable_get_format(drawable
, statt
, &format
, &bind
);
624 templ
.format
= format
;
625 templ
.bind
= bind
& ~PIPE_BIND_SHARED
;
627 if (drawable
->stvis
.samples
> 1) {
628 templ
.nr_samples
= drawable
->stvis
.samples
;
629 templ
.nr_storage_samples
= drawable
->stvis
.samples
;
630 zsbuf
= &drawable
->msaa_textures
[statt
];
633 templ
.nr_samples
= 0;
634 templ
.nr_storage_samples
= 0;
635 zsbuf
= &drawable
->textures
[statt
];
638 /* Try to reuse the resource.
639 * (the other resource parameters should be constant)
642 (*zsbuf
)->width0
!= templ
.width0
||
643 (*zsbuf
)->height0
!= templ
.height0
) {
644 /* Allocate a new one. */
645 pipe_resource_reference(zsbuf
, NULL
);
646 *zsbuf
= screen
->base
.screen
->resource_create(screen
->base
.screen
,
652 pipe_resource_reference(&drawable
->msaa_textures
[statt
], NULL
);
653 pipe_resource_reference(&drawable
->textures
[statt
], NULL
);
657 /* For DRI2, we may get the same buffers again from the server.
658 * To prevent useless imports of gem names, drawable->old* is used
659 * to bypass the import if we get the same buffers. This doesn't apply
660 * to DRI3/Wayland, users of image.loader, since the buffer is managed
661 * by the client (no import), and the back buffer is going to change
665 drawable
->old_num
= num_buffers
;
666 drawable
->old_w
= dri_drawable
->w
;
667 drawable
->old_h
= dri_drawable
->h
;
668 memcpy(drawable
->old
, buffers
, sizeof(__DRIbuffer
) * num_buffers
);
673 dri2_flush_frontbuffer(struct dri_context
*ctx
,
674 struct dri_drawable
*drawable
,
675 enum st_attachment_type statt
)
677 __DRIdrawable
*dri_drawable
= drawable
->dPriv
;
678 const __DRIimageLoaderExtension
*image
= drawable
->sPriv
->image
.loader
;
679 const __DRIdri2LoaderExtension
*loader
= drawable
->sPriv
->dri2
.loader
;
680 struct pipe_context
*pipe
= ctx
->st
->pipe
;
682 if (statt
!= ST_ATTACHMENT_FRONT_LEFT
)
685 if (drawable
->stvis
.samples
> 1) {
686 /* Resolve the front buffer. */
687 dri_pipe_blit(ctx
->st
->pipe
,
688 drawable
->textures
[ST_ATTACHMENT_FRONT_LEFT
],
689 drawable
->msaa_textures
[ST_ATTACHMENT_FRONT_LEFT
]);
692 if (drawable
->textures
[ST_ATTACHMENT_FRONT_LEFT
]) {
693 pipe
->flush_resource(pipe
, drawable
->textures
[ST_ATTACHMENT_FRONT_LEFT
]);
696 pipe
->flush(pipe
, NULL
, 0);
699 image
->flushFrontBuffer(dri_drawable
, dri_drawable
->loaderPrivate
);
701 else if (loader
->flushFrontBuffer
) {
702 loader
->flushFrontBuffer(dri_drawable
, dri_drawable
->loaderPrivate
);
707 * The struct dri_drawable flush_swapbuffers callback
710 dri2_flush_swapbuffers(struct dri_context
*ctx
,
711 struct dri_drawable
*drawable
)
713 __DRIdrawable
*dri_drawable
= drawable
->dPriv
;
714 const __DRIimageLoaderExtension
*image
= drawable
->sPriv
->image
.loader
;
716 if (image
&& image
->base
.version
>= 3 && image
->flushSwapBuffers
) {
717 image
->flushSwapBuffers(dri_drawable
, dri_drawable
->loaderPrivate
);
722 dri2_update_tex_buffer(struct dri_drawable
*drawable
,
723 struct dri_context
*ctx
,
724 struct pipe_resource
*res
)
730 dri2_create_image_from_winsys(__DRIscreen
*_screen
,
731 int width
, int height
, const struct dri2_format_mapping
*map
,
732 int num_handles
, struct winsys_handle
*whandle
,
735 struct dri_screen
*screen
= dri_screen(_screen
);
736 struct pipe_screen
*pscreen
= screen
->base
.screen
;
738 struct pipe_resource templ
;
739 unsigned tex_usage
= 0;
741 bool use_lowered
= false;
743 if (pscreen
->is_format_supported(pscreen
, map
->pipe_format
, screen
->target
, 0, 0,
744 PIPE_BIND_RENDER_TARGET
))
745 tex_usage
|= PIPE_BIND_RENDER_TARGET
;
746 if (pscreen
->is_format_supported(pscreen
, map
->pipe_format
, screen
->target
, 0, 0,
747 PIPE_BIND_SAMPLER_VIEW
))
748 tex_usage
|= PIPE_BIND_SAMPLER_VIEW
;
750 if (!tex_usage
&& util_format_is_yuv(map
->pipe_format
)) {
751 /* YUV format sampling can be emulated by the GL gallium frontend by
752 * using multiple samplers of varying formats.
753 * If no tex_usage is set and we detect a YUV format,
754 * test for support of all planes' sampler formats and
755 * add sampler view usage.
758 if (dri2_yuv_dma_buf_supported(screen
, map
))
759 tex_usage
|= PIPE_BIND_SAMPLER_VIEW
;
765 img
= CALLOC_STRUCT(__DRIimageRec
);
769 memset(&templ
, 0, sizeof(templ
));
770 templ
.bind
= tex_usage
;
771 templ
.target
= screen
->target
;
772 templ
.last_level
= 0;
774 templ
.array_size
= 1;
776 for (i
= (use_lowered
? map
->nplanes
: num_handles
) - 1; i
>= 0; i
--) {
777 struct pipe_resource
*tex
;
779 templ
.next
= img
->texture
;
780 templ
.width0
= width
>> map
->planes
[i
].width_shift
;
781 templ
.height0
= height
>> map
->planes
[i
].height_shift
;
783 templ
.format
= dri2_get_pipe_format_for_dri_format(map
->planes
[i
].dri_format
);
785 templ
.format
= map
->pipe_format
;
786 assert(templ
.format
!= PIPE_FORMAT_NONE
);
788 tex
= pscreen
->resource_from_handle(pscreen
,
789 &templ
, &whandle
[use_lowered
? map
->planes
[i
].buffer_index
: i
],
790 PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE
);
792 pipe_resource_reference(&img
->texture
, NULL
);
803 img
->loader_private
= loaderPrivate
;
809 dri2_create_image_from_name(__DRIscreen
*_screen
,
810 int width
, int height
, int format
,
811 int name
, int pitch
, void *loaderPrivate
)
813 const struct dri2_format_mapping
*map
= dri2_get_mapping_by_format(format
);
814 struct winsys_handle whandle
;
820 memset(&whandle
, 0, sizeof(whandle
));
821 whandle
.type
= WINSYS_HANDLE_TYPE_SHARED
;
822 whandle
.handle
= name
;
823 whandle
.format
= map
->pipe_format
;
824 whandle
.modifier
= DRM_FORMAT_MOD_INVALID
;
826 whandle
.stride
= pitch
* util_format_get_blocksize(map
->pipe_format
);
828 img
= dri2_create_image_from_winsys(_screen
, width
, height
, map
,
829 1, &whandle
, loaderPrivate
);
834 img
->dri_components
= map
->dri_components
;
835 img
->dri_fourcc
= map
->dri_fourcc
;
836 img
->dri_format
= map
->dri_format
;
842 dri2_get_modifier_num_planes(uint64_t modifier
, int fourcc
)
844 const struct dri2_format_mapping
*map
= dri2_get_mapping_by_fourcc(fourcc
);
850 case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS
:
851 case I915_FORMAT_MOD_Y_TILED_CCS
:
853 case DRM_FORMAT_MOD_ARM_16X16_BLOCK_U_INTERLEAVED
:
854 case DRM_FORMAT_MOD_ARM_AFBC(
855 AFBC_FORMAT_MOD_BLOCK_SIZE_16x16
|
856 AFBC_FORMAT_MOD_SPARSE
|
857 AFBC_FORMAT_MOD_YTR
):
858 case DRM_FORMAT_MOD_ARM_AFBC(
859 AFBC_FORMAT_MOD_BLOCK_SIZE_16x16
|
860 AFBC_FORMAT_MOD_SPARSE
):
861 case DRM_FORMAT_MOD_BROADCOM_UIF
:
862 case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED
:
863 case DRM_FORMAT_MOD_LINEAR
:
864 /* DRM_FORMAT_MOD_NONE is the same as LINEAR */
865 case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_EIGHT_GOB
:
866 case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_FOUR_GOB
:
867 case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_ONE_GOB
:
868 case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_SIXTEEN_GOB
:
869 case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_THIRTYTWO_GOB
:
870 case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_TWO_GOB
:
871 case DRM_FORMAT_MOD_QCOM_COMPRESSED
:
872 case DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED
:
873 case DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED
:
874 case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED
:
875 case DRM_FORMAT_MOD_VIVANTE_TILED
:
876 /* FD_FORMAT_MOD_QCOM_TILED is not in drm_fourcc.h */
877 case I915_FORMAT_MOD_X_TILED
:
878 case I915_FORMAT_MOD_Y_TILED
:
879 case DRM_FORMAT_MOD_INVALID
:
880 return util_format_get_num_planes(map
->pipe_format
);
887 dri2_create_image_from_fd(__DRIscreen
*_screen
,
888 int width
, int height
, int fourcc
,
889 uint64_t modifier
, int *fds
, int num_fds
,
890 int *strides
, int *offsets
, unsigned *error
,
893 struct winsys_handle whandles
[3];
894 const struct dri2_format_mapping
*map
= dri2_get_mapping_by_fourcc(fourcc
);
895 __DRIimage
*img
= NULL
;
896 unsigned err
= __DRI_IMAGE_ERROR_SUCCESS
;
898 const int expected_num_fds
= dri2_get_modifier_num_planes(modifier
, fourcc
);
900 if (!map
|| expected_num_fds
== 0) {
901 err
= __DRI_IMAGE_ERROR_BAD_MATCH
;
905 if (num_fds
!= expected_num_fds
) {
906 err
= __DRI_IMAGE_ERROR_BAD_MATCH
;
910 memset(whandles
, 0, sizeof(whandles
));
912 for (i
= 0; i
< num_fds
; i
++) {
914 err
= __DRI_IMAGE_ERROR_BAD_ALLOC
;
918 whandles
[i
].type
= WINSYS_HANDLE_TYPE_FD
;
919 whandles
[i
].handle
= (unsigned)fds
[i
];
920 whandles
[i
].stride
= (unsigned)strides
[i
];
921 whandles
[i
].offset
= (unsigned)offsets
[i
];
922 whandles
[i
].format
= map
->pipe_format
;
923 whandles
[i
].modifier
= modifier
;
924 whandles
[i
].plane
= i
;
927 img
= dri2_create_image_from_winsys(_screen
, width
, height
, map
,
928 num_fds
, whandles
, loaderPrivate
);
930 err
= __DRI_IMAGE_ERROR_BAD_ALLOC
;
934 img
->dri_components
= map
->dri_components
;
935 img
->dri_fourcc
= fourcc
;
936 img
->dri_format
= map
->dri_format
;
937 img
->imported_dmabuf
= TRUE
;
947 dri2_create_image_common(__DRIscreen
*_screen
,
948 int width
, int height
,
949 int format
, unsigned int use
,
950 const uint64_t *modifiers
,
951 const unsigned count
,
954 const struct dri2_format_mapping
*map
= dri2_get_mapping_by_format(format
);
955 struct dri_screen
*screen
= dri_screen(_screen
);
957 struct pipe_resource templ
;
963 tex_usage
= PIPE_BIND_RENDER_TARGET
| PIPE_BIND_SAMPLER_VIEW
;
965 if (use
& __DRI_IMAGE_USE_SCANOUT
)
966 tex_usage
|= PIPE_BIND_SCANOUT
;
967 if (use
& __DRI_IMAGE_USE_SHARE
)
968 tex_usage
|= PIPE_BIND_SHARED
;
969 if (use
& __DRI_IMAGE_USE_LINEAR
)
970 tex_usage
|= PIPE_BIND_LINEAR
;
971 if (use
& __DRI_IMAGE_USE_CURSOR
) {
972 if (width
!= 64 || height
!= 64)
974 tex_usage
|= PIPE_BIND_CURSOR
;
977 img
= CALLOC_STRUCT(__DRIimageRec
);
981 memset(&templ
, 0, sizeof(templ
));
982 templ
.bind
= tex_usage
;
983 templ
.format
= map
->pipe_format
;
984 templ
.target
= PIPE_TEXTURE_2D
;
985 templ
.last_level
= 0;
986 templ
.width0
= width
;
987 templ
.height0
= height
;
989 templ
.array_size
= 1;
994 ->resource_create_with_modifiers(screen
->base
.screen
,
1000 screen
->base
.screen
->resource_create(screen
->base
.screen
, &templ
);
1001 if (!img
->texture
) {
1008 img
->dri_format
= format
;
1009 img
->dri_fourcc
= map
->dri_fourcc
;
1010 img
->dri_components
= 0;
1013 img
->loader_private
= loaderPrivate
;
1018 dri2_create_image(__DRIscreen
*_screen
,
1019 int width
, int height
, int format
,
1020 unsigned int use
, void *loaderPrivate
)
1022 return dri2_create_image_common(_screen
, width
, height
, format
, use
,
1023 NULL
/* modifiers */, 0 /* count */,
1028 dri2_create_image_with_modifiers(__DRIscreen
*dri_screen
,
1029 int width
, int height
, int format
,
1030 const uint64_t *modifiers
,
1031 const unsigned count
,
1032 void *loaderPrivate
)
1034 return dri2_create_image_common(dri_screen
, width
, height
, format
,
1035 __DRI_IMAGE_USE_SHARE
, modifiers
, count
,
1040 dri2_query_image_common(__DRIimage
*image
, int attrib
, int *value
)
1043 case __DRI_IMAGE_ATTRIB_FORMAT
:
1044 *value
= image
->dri_format
;
1046 case __DRI_IMAGE_ATTRIB_WIDTH
:
1047 *value
= image
->texture
->width0
;
1049 case __DRI_IMAGE_ATTRIB_HEIGHT
:
1050 *value
= image
->texture
->height0
;
1052 case __DRI_IMAGE_ATTRIB_COMPONENTS
:
1053 if (image
->dri_components
== 0)
1055 *value
= image
->dri_components
;
1057 case __DRI_IMAGE_ATTRIB_FOURCC
:
1058 if (image
->dri_fourcc
) {
1059 *value
= image
->dri_fourcc
;
1061 const struct dri2_format_mapping
*map
;
1063 map
= dri2_get_mapping_by_format(image
->dri_format
);
1067 *value
= map
->dri_fourcc
;
1076 dri2_query_image_by_resource_handle(__DRIimage
*image
, int attrib
, int *value
)
1078 struct pipe_screen
*pscreen
= image
->texture
->screen
;
1079 struct winsys_handle whandle
;
1081 memset(&whandle
, 0, sizeof(whandle
));
1082 whandle
.plane
= image
->plane
;
1085 case __DRI_IMAGE_ATTRIB_STRIDE
:
1086 case __DRI_IMAGE_ATTRIB_OFFSET
:
1087 case __DRI_IMAGE_ATTRIB_HANDLE
:
1088 whandle
.type
= WINSYS_HANDLE_TYPE_KMS
;
1090 case __DRI_IMAGE_ATTRIB_NAME
:
1091 whandle
.type
= WINSYS_HANDLE_TYPE_SHARED
;
1093 case __DRI_IMAGE_ATTRIB_FD
:
1094 whandle
.type
= WINSYS_HANDLE_TYPE_FD
;
1096 case __DRI_IMAGE_ATTRIB_NUM_PLANES
:
1099 case __DRI_IMAGE_ATTRIB_MODIFIER_UPPER
:
1100 case __DRI_IMAGE_ATTRIB_MODIFIER_LOWER
:
1101 whandle
.type
= WINSYS_HANDLE_TYPE_KMS
;
1102 whandle
.modifier
= DRM_FORMAT_MOD_INVALID
;
1108 usage
= PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE
;
1110 if (image
->use
& __DRI_IMAGE_USE_BACKBUFFER
)
1111 usage
|= PIPE_HANDLE_USAGE_EXPLICIT_FLUSH
;
1113 if (!pscreen
->resource_get_handle(pscreen
, NULL
, image
->texture
,
1118 case __DRI_IMAGE_ATTRIB_STRIDE
:
1119 *value
= whandle
.stride
;
1121 case __DRI_IMAGE_ATTRIB_OFFSET
:
1122 *value
= whandle
.offset
;
1124 case __DRI_IMAGE_ATTRIB_HANDLE
:
1125 case __DRI_IMAGE_ATTRIB_NAME
:
1126 case __DRI_IMAGE_ATTRIB_FD
:
1127 *value
= whandle
.handle
;
1129 case __DRI_IMAGE_ATTRIB_MODIFIER_UPPER
:
1130 if (whandle
.modifier
== DRM_FORMAT_MOD_INVALID
)
1132 *value
= (whandle
.modifier
>> 32) & 0xffffffff;
1134 case __DRI_IMAGE_ATTRIB_MODIFIER_LOWER
:
1135 if (whandle
.modifier
== DRM_FORMAT_MOD_INVALID
)
1137 *value
= whandle
.modifier
& 0xffffffff;
1145 dri2_resource_get_param(__DRIimage
*image
, enum pipe_resource_param param
,
1146 unsigned handle_usage
, uint64_t *value
)
1148 struct pipe_screen
*pscreen
= image
->texture
->screen
;
1149 if (!pscreen
->resource_get_param
)
1152 return pscreen
->resource_get_param(pscreen
, NULL
, image
->texture
,
1153 image
->plane
, 0, param
, handle_usage
,
1158 dri2_query_image_by_resource_param(__DRIimage
*image
, int attrib
, int *value
)
1160 enum pipe_resource_param param
;
1162 unsigned handle_usage
;
1164 if (!image
->texture
->screen
->resource_get_param
)
1168 case __DRI_IMAGE_ATTRIB_STRIDE
:
1169 param
= PIPE_RESOURCE_PARAM_STRIDE
;
1171 case __DRI_IMAGE_ATTRIB_OFFSET
:
1172 param
= PIPE_RESOURCE_PARAM_OFFSET
;
1174 case __DRI_IMAGE_ATTRIB_NUM_PLANES
:
1175 param
= PIPE_RESOURCE_PARAM_NPLANES
;
1177 case __DRI_IMAGE_ATTRIB_MODIFIER_UPPER
:
1178 case __DRI_IMAGE_ATTRIB_MODIFIER_LOWER
:
1179 param
= PIPE_RESOURCE_PARAM_MODIFIER
;
1181 case __DRI_IMAGE_ATTRIB_HANDLE
:
1182 param
= PIPE_RESOURCE_PARAM_HANDLE_TYPE_KMS
;
1184 case __DRI_IMAGE_ATTRIB_NAME
:
1185 param
= PIPE_RESOURCE_PARAM_HANDLE_TYPE_SHARED
;
1187 case __DRI_IMAGE_ATTRIB_FD
:
1188 param
= PIPE_RESOURCE_PARAM_HANDLE_TYPE_FD
;
1194 handle_usage
= PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE
;
1196 if (image
->use
& __DRI_IMAGE_USE_BACKBUFFER
)
1197 handle_usage
|= PIPE_HANDLE_USAGE_EXPLICIT_FLUSH
;
1199 if (!dri2_resource_get_param(image
, param
, handle_usage
, &res_param
))
1203 case __DRI_IMAGE_ATTRIB_STRIDE
:
1204 case __DRI_IMAGE_ATTRIB_OFFSET
:
1205 case __DRI_IMAGE_ATTRIB_NUM_PLANES
:
1206 if (res_param
> INT_MAX
)
1208 *value
= (int)res_param
;
1210 case __DRI_IMAGE_ATTRIB_HANDLE
:
1211 case __DRI_IMAGE_ATTRIB_NAME
:
1212 case __DRI_IMAGE_ATTRIB_FD
:
1213 if (res_param
> UINT_MAX
)
1215 *value
= (int)res_param
;
1217 case __DRI_IMAGE_ATTRIB_MODIFIER_UPPER
:
1218 if (res_param
== DRM_FORMAT_MOD_INVALID
)
1220 *value
= (res_param
>> 32) & 0xffffffff;
1222 case __DRI_IMAGE_ATTRIB_MODIFIER_LOWER
:
1223 if (res_param
== DRM_FORMAT_MOD_INVALID
)
1225 *value
= res_param
& 0xffffffff;
1233 dri2_query_image(__DRIimage
*image
, int attrib
, int *value
)
1235 if (dri2_query_image_common(image
, attrib
, value
))
1237 else if (dri2_query_image_by_resource_param(image
, attrib
, value
))
1239 else if (dri2_query_image_by_resource_handle(image
, attrib
, value
))
1246 dri2_dup_image(__DRIimage
*image
, void *loaderPrivate
)
1250 img
= CALLOC_STRUCT(__DRIimageRec
);
1254 img
->texture
= NULL
;
1255 pipe_resource_reference(&img
->texture
, image
->texture
);
1256 img
->level
= image
->level
;
1257 img
->layer
= image
->layer
;
1258 img
->dri_format
= image
->dri_format
;
1259 /* This should be 0 for sub images, but dup is also used for base images. */
1260 img
->dri_components
= image
->dri_components
;
1261 img
->loader_private
= loaderPrivate
;
1267 dri2_validate_usage(__DRIimage
*image
, unsigned int use
)
1269 if (!image
|| !image
->texture
)
1272 struct pipe_screen
*screen
= image
->texture
->screen
;
1273 if (!screen
->check_resource_capability
)
1276 /* We don't want to check these:
1277 * __DRI_IMAGE_USE_SHARE (all images are shareable)
1278 * __DRI_IMAGE_USE_BACKBUFFER (all images support this)
1281 if (use
& __DRI_IMAGE_USE_SCANOUT
)
1282 bind
|= PIPE_BIND_SCANOUT
;
1283 if (use
& __DRI_IMAGE_USE_LINEAR
)
1284 bind
|= PIPE_BIND_LINEAR
;
1285 if (use
& __DRI_IMAGE_USE_CURSOR
)
1286 bind
|= PIPE_BIND_CURSOR
;
1291 return screen
->check_resource_capability(screen
, image
->texture
, bind
);
1295 dri2_from_names(__DRIscreen
*screen
, int width
, int height
, int format
,
1296 int *names
, int num_names
, int *strides
, int *offsets
,
1297 void *loaderPrivate
)
1299 const struct dri2_format_mapping
*map
= dri2_get_mapping_by_format(format
);
1301 struct winsys_handle whandle
;
1309 memset(&whandle
, 0, sizeof(whandle
));
1310 whandle
.type
= WINSYS_HANDLE_TYPE_SHARED
;
1311 whandle
.handle
= names
[0];
1312 whandle
.stride
= strides
[0];
1313 whandle
.offset
= offsets
[0];
1314 whandle
.format
= map
->pipe_format
;
1315 whandle
.modifier
= DRM_FORMAT_MOD_INVALID
;
1317 img
= dri2_create_image_from_winsys(screen
, width
, height
, map
,
1318 1, &whandle
, loaderPrivate
);
1322 img
->dri_components
= map
->dri_components
;
1323 img
->dri_fourcc
= map
->dri_fourcc
;
1324 img
->dri_format
= map
->pipe_format
;
1330 dri2_from_planar(__DRIimage
*image
, int plane
, void *loaderPrivate
)
1336 } else if (plane
> 0) {
1338 if (!dri2_resource_get_param(image
, PIPE_RESOURCE_PARAM_NPLANES
, 0,
1345 if (image
->dri_components
== 0) {
1347 if (!dri2_resource_get_param(image
, PIPE_RESOURCE_PARAM_MODIFIER
, 0,
1349 modifier
== DRM_FORMAT_MOD_INVALID
) {
1354 img
= dri2_dup_image(image
, loaderPrivate
);
1358 if (img
->texture
->screen
->resource_changed
)
1359 img
->texture
->screen
->resource_changed(img
->texture
->screen
,
1362 /* set this to 0 for sub images. */
1363 img
->dri_components
= 0;
1369 dri2_from_fds(__DRIscreen
*screen
, int width
, int height
, int fourcc
,
1370 int *fds
, int num_fds
, int *strides
, int *offsets
,
1371 void *loaderPrivate
)
1373 return dri2_create_image_from_fd(screen
, width
, height
, fourcc
,
1374 DRM_FORMAT_MOD_INVALID
, fds
, num_fds
,
1375 strides
, offsets
, NULL
, loaderPrivate
);
1379 dri2_query_dma_buf_modifiers(__DRIscreen
*_screen
, int fourcc
, int max
,
1380 uint64_t *modifiers
, unsigned int *external_only
,
1383 struct dri_screen
*screen
= dri_screen(_screen
);
1384 struct pipe_screen
*pscreen
= screen
->base
.screen
;
1385 const struct dri2_format_mapping
*map
= dri2_get_mapping_by_fourcc(fourcc
);
1386 enum pipe_format format
;
1391 format
= map
->pipe_format
;
1393 if (pscreen
->is_format_supported(pscreen
, format
, screen
->target
, 0, 0,
1394 PIPE_BIND_RENDER_TARGET
) ||
1395 pscreen
->is_format_supported(pscreen
, format
, screen
->target
, 0, 0,
1396 PIPE_BIND_SAMPLER_VIEW
) ||
1397 dri2_yuv_dma_buf_supported(screen
, map
)) {
1398 if (pscreen
->query_dmabuf_modifiers
!= NULL
)
1399 pscreen
->query_dmabuf_modifiers(pscreen
, format
, max
, modifiers
,
1400 external_only
, count
);
1409 dri2_query_dma_buf_format_modifier_attribs(__DRIscreen
*_screen
,
1410 uint32_t fourcc
, uint64_t modifier
,
1411 int attrib
, uint64_t *value
)
1413 struct dri_screen
*screen
= dri_screen(_screen
);
1414 struct pipe_screen
*pscreen
= screen
->base
.screen
;
1416 if (!pscreen
->query_dmabuf_modifiers
)
1420 case __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB_PLANE_COUNT
: {
1421 uint64_t mod_planes
= dri2_get_modifier_num_planes(modifier
, fourcc
);
1423 *value
= mod_planes
;
1424 return mod_planes
> 0;
1432 dri2_from_dma_bufs(__DRIscreen
*screen
,
1433 int width
, int height
, int fourcc
,
1434 int *fds
, int num_fds
,
1435 int *strides
, int *offsets
,
1436 enum __DRIYUVColorSpace yuv_color_space
,
1437 enum __DRISampleRange sample_range
,
1438 enum __DRIChromaSiting horizontal_siting
,
1439 enum __DRIChromaSiting vertical_siting
,
1441 void *loaderPrivate
)
1445 img
= dri2_create_image_from_fd(screen
, width
, height
, fourcc
,
1446 DRM_FORMAT_MOD_INVALID
, fds
, num_fds
,
1447 strides
, offsets
, error
, loaderPrivate
);
1451 img
->yuv_color_space
= yuv_color_space
;
1452 img
->sample_range
= sample_range
;
1453 img
->horizontal_siting
= horizontal_siting
;
1454 img
->vertical_siting
= vertical_siting
;
1456 *error
= __DRI_IMAGE_ERROR_SUCCESS
;
1461 dri2_from_dma_bufs2(__DRIscreen
*screen
,
1462 int width
, int height
, int fourcc
,
1463 uint64_t modifier
, int *fds
, int num_fds
,
1464 int *strides
, int *offsets
,
1465 enum __DRIYUVColorSpace yuv_color_space
,
1466 enum __DRISampleRange sample_range
,
1467 enum __DRIChromaSiting horizontal_siting
,
1468 enum __DRIChromaSiting vertical_siting
,
1470 void *loaderPrivate
)
1474 img
= dri2_create_image_from_fd(screen
, width
, height
, fourcc
,
1475 modifier
, fds
, num_fds
, strides
, offsets
,
1476 error
, loaderPrivate
);
1480 img
->yuv_color_space
= yuv_color_space
;
1481 img
->sample_range
= sample_range
;
1482 img
->horizontal_siting
= horizontal_siting
;
1483 img
->vertical_siting
= vertical_siting
;
1485 *error
= __DRI_IMAGE_ERROR_SUCCESS
;
1490 dri2_blit_image(__DRIcontext
*context
, __DRIimage
*dst
, __DRIimage
*src
,
1491 int dstx0
, int dsty0
, int dstwidth
, int dstheight
,
1492 int srcx0
, int srcy0
, int srcwidth
, int srcheight
,
1495 struct dri_context
*ctx
= dri_context(context
);
1496 struct pipe_context
*pipe
= ctx
->st
->pipe
;
1497 struct pipe_screen
*screen
;
1498 struct pipe_fence_handle
*fence
;
1499 struct pipe_blit_info blit
;
1504 memset(&blit
, 0, sizeof(blit
));
1505 blit
.dst
.resource
= dst
->texture
;
1506 blit
.dst
.box
.x
= dstx0
;
1507 blit
.dst
.box
.y
= dsty0
;
1508 blit
.dst
.box
.width
= dstwidth
;
1509 blit
.dst
.box
.height
= dstheight
;
1510 blit
.dst
.box
.depth
= 1;
1511 blit
.dst
.format
= dst
->texture
->format
;
1512 blit
.src
.resource
= src
->texture
;
1513 blit
.src
.box
.x
= srcx0
;
1514 blit
.src
.box
.y
= srcy0
;
1515 blit
.src
.box
.width
= srcwidth
;
1516 blit
.src
.box
.height
= srcheight
;
1517 blit
.src
.box
.depth
= 1;
1518 blit
.src
.format
= src
->texture
->format
;
1519 blit
.mask
= PIPE_MASK_RGBA
;
1520 blit
.filter
= PIPE_TEX_FILTER_NEAREST
;
1522 pipe
->blit(pipe
, &blit
);
1524 if (flush_flag
== __BLIT_FLAG_FLUSH
) {
1525 pipe
->flush_resource(pipe
, dst
->texture
);
1526 ctx
->st
->flush(ctx
->st
, 0, NULL
, NULL
, NULL
);
1527 } else if (flush_flag
== __BLIT_FLAG_FINISH
) {
1528 screen
= dri_screen(ctx
->sPriv
)->base
.screen
;
1529 pipe
->flush_resource(pipe
, dst
->texture
);
1530 ctx
->st
->flush(ctx
->st
, 0, &fence
, NULL
, NULL
);
1531 (void) screen
->fence_finish(screen
, NULL
, fence
, PIPE_TIMEOUT_INFINITE
);
1532 screen
->fence_reference(screen
, &fence
, NULL
);
1537 dri2_map_image(__DRIcontext
*context
, __DRIimage
*image
,
1538 int x0
, int y0
, int width
, int height
,
1539 unsigned int flags
, int *stride
, void **data
)
1541 struct dri_context
*ctx
= dri_context(context
);
1542 struct pipe_context
*pipe
= ctx
->st
->pipe
;
1543 enum pipe_transfer_usage pipe_access
= 0;
1544 struct pipe_resource
*resource
= image
->texture
;
1545 struct pipe_transfer
*trans
;
1548 if (!image
|| !data
|| *data
)
1551 unsigned plane
= image
->plane
;
1552 if (plane
>= dri2_get_mapping_by_format(image
->dri_format
)->nplanes
)
1556 resource
= resource
->next
;
1558 if (flags
& __DRI_IMAGE_TRANSFER_READ
)
1559 pipe_access
|= PIPE_TRANSFER_READ
;
1560 if (flags
& __DRI_IMAGE_TRANSFER_WRITE
)
1561 pipe_access
|= PIPE_TRANSFER_WRITE
;
1563 map
= pipe_transfer_map(pipe
, resource
, 0, 0, pipe_access
, x0
, y0
,
1564 width
, height
, &trans
);
1567 *stride
= trans
->stride
;
1574 dri2_unmap_image(__DRIcontext
*context
, __DRIimage
*image
, void *data
)
1576 struct dri_context
*ctx
= dri_context(context
);
1577 struct pipe_context
*pipe
= ctx
->st
->pipe
;
1579 pipe_transfer_unmap(pipe
, (struct pipe_transfer
*)data
);
1583 dri2_get_capabilities(__DRIscreen
*_screen
)
1585 struct dri_screen
*screen
= dri_screen(_screen
);
1587 return (screen
->can_share_buffer
? __DRI_IMAGE_CAP_GLOBAL_NAMES
: 0);
1590 /* The extension is modified during runtime if DRI_PRIME is detected */
1591 static __DRIimageExtension dri2ImageExtension
= {
1592 .base
= { __DRI_IMAGE
, 17 },
1594 .createImageFromName
= dri2_create_image_from_name
,
1595 .createImageFromRenderbuffer
= dri2_create_image_from_renderbuffer
,
1596 .destroyImage
= dri2_destroy_image
,
1597 .createImage
= dri2_create_image
,
1598 .queryImage
= dri2_query_image
,
1599 .dupImage
= dri2_dup_image
,
1600 .validateUsage
= dri2_validate_usage
,
1601 .createImageFromNames
= dri2_from_names
,
1602 .fromPlanar
= dri2_from_planar
,
1603 .createImageFromTexture
= dri2_create_from_texture
,
1604 .createImageFromFds
= NULL
,
1605 .createImageFromDmaBufs
= NULL
,
1606 .blitImage
= dri2_blit_image
,
1607 .getCapabilities
= dri2_get_capabilities
,
1608 .mapImage
= dri2_map_image
,
1609 .unmapImage
= dri2_unmap_image
,
1610 .createImageWithModifiers
= NULL
,
1611 .createImageFromDmaBufs2
= NULL
,
1612 .queryDmaBufFormats
= NULL
,
1613 .queryDmaBufModifiers
= NULL
,
1614 .queryDmaBufFormatModifierAttribs
= NULL
,
1615 .createImageFromRenderbuffer2
= dri2_create_image_from_renderbuffer2
,
1618 static const __DRIrobustnessExtension dri2Robustness
= {
1619 .base
= { __DRI2_ROBUSTNESS
, 1 }
1623 dri2_interop_query_device_info(__DRIcontext
*_ctx
,
1624 struct mesa_glinterop_device_info
*out
)
1626 struct pipe_screen
*screen
= dri_context(_ctx
)->st
->pipe
->screen
;
1628 /* There is no version 0, thus we do not support it */
1629 if (out
->version
== 0)
1630 return MESA_GLINTEROP_INVALID_VERSION
;
1632 out
->pci_segment_group
= screen
->get_param(screen
, PIPE_CAP_PCI_GROUP
);
1633 out
->pci_bus
= screen
->get_param(screen
, PIPE_CAP_PCI_BUS
);
1634 out
->pci_device
= screen
->get_param(screen
, PIPE_CAP_PCI_DEVICE
);
1635 out
->pci_function
= screen
->get_param(screen
, PIPE_CAP_PCI_FUNCTION
);
1637 out
->vendor_id
= screen
->get_param(screen
, PIPE_CAP_VENDOR_ID
);
1638 out
->device_id
= screen
->get_param(screen
, PIPE_CAP_DEVICE_ID
);
1640 /* Instruct the caller that we support up-to version one of the interface */
1643 return MESA_GLINTEROP_SUCCESS
;
1647 dri2_interop_export_object(__DRIcontext
*_ctx
,
1648 struct mesa_glinterop_export_in
*in
,
1649 struct mesa_glinterop_export_out
*out
)
1651 struct st_context_iface
*st
= dri_context(_ctx
)->st
;
1652 struct pipe_screen
*screen
= st
->pipe
->screen
;
1653 struct gl_context
*ctx
= ((struct st_context
*)st
)->ctx
;
1654 struct pipe_resource
*res
= NULL
;
1655 struct winsys_handle whandle
;
1656 unsigned target
, usage
;
1659 /* There is no version 0, thus we do not support it */
1660 if (in
->version
== 0 || out
->version
== 0)
1661 return MESA_GLINTEROP_INVALID_VERSION
;
1663 /* Validate the target. */
1664 switch (in
->target
) {
1665 case GL_TEXTURE_BUFFER
:
1669 case GL_TEXTURE_RECTANGLE
:
1670 case GL_TEXTURE_1D_ARRAY
:
1671 case GL_TEXTURE_2D_ARRAY
:
1672 case GL_TEXTURE_CUBE_MAP_ARRAY
:
1673 case GL_TEXTURE_CUBE_MAP
:
1674 case GL_TEXTURE_2D_MULTISAMPLE
:
1675 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
1676 case GL_TEXTURE_EXTERNAL_OES
:
1677 case GL_RENDERBUFFER
:
1678 case GL_ARRAY_BUFFER
:
1679 target
= in
->target
;
1681 case GL_TEXTURE_CUBE_MAP_POSITIVE_X
:
1682 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X
:
1683 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y
:
1684 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
:
1685 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z
:
1686 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
:
1687 target
= GL_TEXTURE_CUBE_MAP
;
1690 return MESA_GLINTEROP_INVALID_TARGET
;
1693 /* Validate the simple case of miplevel. */
1694 if ((target
== GL_RENDERBUFFER
|| target
== GL_ARRAY_BUFFER
) &&
1696 return MESA_GLINTEROP_INVALID_MIP_LEVEL
;
1698 /* Validate the OpenGL object and get pipe_resource. */
1699 simple_mtx_lock(&ctx
->Shared
->Mutex
);
1701 if (target
== GL_ARRAY_BUFFER
) {
1704 * The error checking is based on the documentation of
1705 * clCreateFromGLBuffer from OpenCL 2.0 SDK.
1707 struct gl_buffer_object
*buf
= _mesa_lookup_bufferobj(ctx
, in
->obj
);
1709 /* From OpenCL 2.0 SDK, clCreateFromGLBuffer:
1710 * "CL_INVALID_GL_OBJECT if bufobj is not a GL buffer object or is
1711 * a GL buffer object but does not have an existing data store or
1712 * the size of the buffer is 0."
1714 if (!buf
|| buf
->Size
== 0) {
1715 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1716 return MESA_GLINTEROP_INVALID_OBJECT
;
1719 res
= st_buffer_object(buf
)->buffer
;
1721 /* this shouldn't happen */
1722 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1723 return MESA_GLINTEROP_INVALID_OBJECT
;
1726 out
->buf_offset
= 0;
1727 out
->buf_size
= buf
->Size
;
1729 buf
->UsageHistory
|= USAGE_DISABLE_MINMAX_CACHE
;
1730 } else if (target
== GL_RENDERBUFFER
) {
1733 * The error checking is based on the documentation of
1734 * clCreateFromGLRenderbuffer from OpenCL 2.0 SDK.
1736 struct gl_renderbuffer
*rb
= _mesa_lookup_renderbuffer(ctx
, in
->obj
);
1738 /* From OpenCL 2.0 SDK, clCreateFromGLRenderbuffer:
1739 * "CL_INVALID_GL_OBJECT if renderbuffer is not a GL renderbuffer
1740 * object or if the width or height of renderbuffer is zero."
1742 if (!rb
|| rb
->Width
== 0 || rb
->Height
== 0) {
1743 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1744 return MESA_GLINTEROP_INVALID_OBJECT
;
1747 /* From OpenCL 2.0 SDK, clCreateFromGLRenderbuffer:
1748 * "CL_INVALID_OPERATION if renderbuffer is a multi-sample GL
1749 * renderbuffer object."
1751 if (rb
->NumSamples
> 1) {
1752 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1753 return MESA_GLINTEROP_INVALID_OPERATION
;
1756 /* From OpenCL 2.0 SDK, clCreateFromGLRenderbuffer:
1757 * "CL_OUT_OF_RESOURCES if there is a failure to allocate resources
1758 * required by the OpenCL implementation on the device."
1760 res
= st_renderbuffer(rb
)->texture
;
1762 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1763 return MESA_GLINTEROP_OUT_OF_RESOURCES
;
1766 out
->internal_format
= rb
->InternalFormat
;
1767 out
->view_minlevel
= 0;
1768 out
->view_numlevels
= 1;
1769 out
->view_minlayer
= 0;
1770 out
->view_numlayers
= 1;
1774 * The error checking is based on the documentation of
1775 * clCreateFromGLTexture from OpenCL 2.0 SDK.
1777 struct gl_texture_object
*obj
= _mesa_lookup_texture(ctx
, in
->obj
);
1780 _mesa_test_texobj_completeness(ctx
, obj
);
1782 /* From OpenCL 2.0 SDK, clCreateFromGLTexture:
1783 * "CL_INVALID_GL_OBJECT if texture is not a GL texture object whose
1784 * type matches texture_target, if the specified miplevel of texture
1785 * is not defined, or if the width or height of the specified
1786 * miplevel is zero or if the GL texture object is incomplete."
1789 obj
->Target
!= target
||
1790 !obj
->_BaseComplete
||
1791 (in
->miplevel
> 0 && !obj
->_MipmapComplete
)) {
1792 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1793 return MESA_GLINTEROP_INVALID_OBJECT
;
1796 if (target
== GL_TEXTURE_BUFFER
) {
1797 struct st_buffer_object
*stBuf
=
1798 st_buffer_object(obj
->BufferObject
);
1800 if (!stBuf
|| !stBuf
->buffer
) {
1801 /* this shouldn't happen */
1802 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1803 return MESA_GLINTEROP_INVALID_OBJECT
;
1805 res
= stBuf
->buffer
;
1807 out
->internal_format
= obj
->BufferObjectFormat
;
1808 out
->buf_offset
= obj
->BufferOffset
;
1809 out
->buf_size
= obj
->BufferSize
== -1 ? obj
->BufferObject
->Size
:
1812 obj
->BufferObject
->UsageHistory
|= USAGE_DISABLE_MINMAX_CACHE
;
1814 /* From OpenCL 2.0 SDK, clCreateFromGLTexture:
1815 * "CL_INVALID_MIP_LEVEL if miplevel is less than the value of
1816 * levelbase (for OpenGL implementations) or zero (for OpenGL ES
1817 * implementations); or greater than the value of q (for both OpenGL
1818 * and OpenGL ES). levelbase and q are defined for the texture in
1819 * section 3.8.10 (Texture Completeness) of the OpenGL 2.1
1820 * specification and section 3.7.10 of the OpenGL ES 2.0."
1822 if (in
->miplevel
< obj
->BaseLevel
|| in
->miplevel
> obj
->_MaxLevel
) {
1823 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1824 return MESA_GLINTEROP_INVALID_MIP_LEVEL
;
1827 if (!st_finalize_texture(ctx
, st
->pipe
, obj
, 0)) {
1828 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1829 return MESA_GLINTEROP_OUT_OF_RESOURCES
;
1832 res
= st_get_texobj_resource(obj
);
1834 /* Incomplete texture buffer object? This shouldn't really occur. */
1835 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1836 return MESA_GLINTEROP_INVALID_OBJECT
;
1839 out
->internal_format
= obj
->Image
[0][0]->InternalFormat
;
1840 out
->view_minlevel
= obj
->MinLevel
;
1841 out
->view_numlevels
= obj
->NumLevels
;
1842 out
->view_minlayer
= obj
->MinLayer
;
1843 out
->view_numlayers
= obj
->NumLayers
;
1847 /* Get the handle. */
1848 switch (in
->access
) {
1849 case MESA_GLINTEROP_ACCESS_READ_ONLY
:
1852 case MESA_GLINTEROP_ACCESS_READ_WRITE
:
1853 case MESA_GLINTEROP_ACCESS_WRITE_ONLY
:
1854 usage
= PIPE_HANDLE_USAGE_SHADER_WRITE
;
1860 memset(&whandle
, 0, sizeof(whandle
));
1861 whandle
.type
= WINSYS_HANDLE_TYPE_FD
;
1863 success
= screen
->resource_get_handle(screen
, st
->pipe
, res
, &whandle
,
1865 simple_mtx_unlock(&ctx
->Shared
->Mutex
);
1868 return MESA_GLINTEROP_OUT_OF_HOST_MEMORY
;
1870 out
->dmabuf_fd
= whandle
.handle
;
1871 out
->out_driver_data_written
= 0;
1873 if (res
->target
== PIPE_BUFFER
)
1874 out
->buf_offset
+= whandle
.offset
;
1876 /* Instruct the caller that we support up-to version one of the interface */
1880 return MESA_GLINTEROP_SUCCESS
;
1883 static const __DRI2interopExtension dri2InteropExtension
= {
1884 .base
= { __DRI2_INTEROP
, 1 },
1885 .query_device_info
= dri2_interop_query_device_info
,
1886 .export_object
= dri2_interop_export_object
1890 * \brief the DRI2bufferDamageExtension set_damage_region method
1893 dri2_set_damage_region(__DRIdrawable
*dPriv
, unsigned int nrects
, int *rects
)
1895 struct dri_drawable
*drawable
= dri_drawable(dPriv
);
1896 struct pipe_box
*boxes
= NULL
;
1899 boxes
= CALLOC(nrects
, sizeof(*boxes
));
1902 for (unsigned int i
= 0; i
< nrects
; i
++) {
1903 int *rect
= &rects
[i
* 4];
1905 u_box_2d(rect
[0], rect
[1], rect
[2], rect
[3], &boxes
[i
]);
1909 FREE(drawable
->damage_rects
);
1910 drawable
->damage_rects
= boxes
;
1911 drawable
->num_damage_rects
= nrects
;
1913 /* Only apply the damage region if the BACK_LEFT texture is up-to-date. */
1914 if (drawable
->texture_stamp
== drawable
->dPriv
->lastStamp
&&
1915 (drawable
->texture_mask
& (1 << ST_ATTACHMENT_BACK_LEFT
))) {
1916 struct pipe_screen
*screen
= drawable
->screen
->base
.screen
;
1917 struct pipe_resource
*resource
;
1919 if (drawable
->stvis
.samples
> 1)
1920 resource
= drawable
->msaa_textures
[ST_ATTACHMENT_BACK_LEFT
];
1922 resource
= drawable
->textures
[ST_ATTACHMENT_BACK_LEFT
];
1924 screen
->set_damage_region(screen
, resource
,
1925 drawable
->num_damage_rects
,
1926 drawable
->damage_rects
);
1930 static __DRI2bufferDamageExtension dri2BufferDamageExtension
= {
1931 .base
= { __DRI2_BUFFER_DAMAGE
, 1 },
1935 * \brief the DRI2ConfigQueryExtension configQueryb method
1938 dri2GalliumConfigQueryb(__DRIscreen
*sPriv
, const char *var
,
1941 struct dri_screen
*screen
= dri_screen(sPriv
);
1943 if (!driCheckOption(&screen
->dev
->option_cache
, var
, DRI_BOOL
))
1944 return dri2ConfigQueryExtension
.configQueryb(sPriv
, var
, val
);
1946 *val
= driQueryOptionb(&screen
->dev
->option_cache
, var
);
1952 * \brief the DRI2ConfigQueryExtension configQueryi method
1955 dri2GalliumConfigQueryi(__DRIscreen
*sPriv
, const char *var
, int *val
)
1957 struct dri_screen
*screen
= dri_screen(sPriv
);
1959 if (!driCheckOption(&screen
->dev
->option_cache
, var
, DRI_INT
) &&
1960 !driCheckOption(&screen
->dev
->option_cache
, var
, DRI_ENUM
))
1961 return dri2ConfigQueryExtension
.configQueryi(sPriv
, var
, val
);
1963 *val
= driQueryOptioni(&screen
->dev
->option_cache
, var
);
1969 * \brief the DRI2ConfigQueryExtension configQueryf method
1972 dri2GalliumConfigQueryf(__DRIscreen
*sPriv
, const char *var
, float *val
)
1974 struct dri_screen
*screen
= dri_screen(sPriv
);
1976 if (!driCheckOption(&screen
->dev
->option_cache
, var
, DRI_FLOAT
))
1977 return dri2ConfigQueryExtension
.configQueryf(sPriv
, var
, val
);
1979 *val
= driQueryOptionf(&screen
->dev
->option_cache
, var
);
1985 * \brief the DRI2ConfigQueryExtension struct.
1987 * We first query the driver option cache. Then the dri2 option cache.
1989 static const __DRI2configQueryExtension dri2GalliumConfigQueryExtension
= {
1990 .base
= { __DRI2_CONFIG_QUERY
, 1 },
1992 .configQueryb
= dri2GalliumConfigQueryb
,
1993 .configQueryi
= dri2GalliumConfigQueryi
,
1994 .configQueryf
= dri2GalliumConfigQueryf
,
1998 * \brief the DRI2blobExtension set_cache_funcs method
2001 set_blob_cache_funcs(__DRIscreen
*sPriv
, __DRIblobCacheSet set
,
2002 __DRIblobCacheGet get
)
2004 struct dri_screen
*screen
= dri_screen(sPriv
);
2005 struct pipe_screen
*pscreen
= screen
->base
.screen
;
2007 if (!pscreen
->get_disk_shader_cache
)
2010 struct disk_cache
*cache
= pscreen
->get_disk_shader_cache(pscreen
);
2015 disk_cache_set_callbacks(cache
, set
, get
);
2018 static const __DRI2blobExtension driBlobExtension
= {
2019 .base
= { __DRI2_BLOB
, 1 },
2020 .set_cache_funcs
= set_blob_cache_funcs
2024 * Backend function init_screen.
2027 static const __DRIextension
*dri_screen_extensions
[] = {
2028 &driTexBufferExtension
.base
,
2029 &dri2FlushExtension
.base
,
2030 &dri2ImageExtension
.base
,
2031 &dri2RendererQueryExtension
.base
,
2032 &dri2GalliumConfigQueryExtension
.base
,
2033 &dri2ThrottleExtension
.base
,
2034 &dri2FenceExtension
.base
,
2035 &dri2BufferDamageExtension
.base
,
2036 &dri2InteropExtension
.base
,
2037 &dri2NoErrorExtension
.base
,
2038 &driBlobExtension
.base
,
2042 static const __DRIextension
*dri_robust_screen_extensions
[] = {
2043 &driTexBufferExtension
.base
,
2044 &dri2FlushExtension
.base
,
2045 &dri2ImageExtension
.base
,
2046 &dri2RendererQueryExtension
.base
,
2047 &dri2GalliumConfigQueryExtension
.base
,
2048 &dri2ThrottleExtension
.base
,
2049 &dri2FenceExtension
.base
,
2050 &dri2InteropExtension
.base
,
2051 &dri2BufferDamageExtension
.base
,
2052 &dri2Robustness
.base
,
2053 &dri2NoErrorExtension
.base
,
2054 &driBlobExtension
.base
,
2059 * This is the driver specific part of the createNewScreen entry point.
2061 * Returns the struct gl_config supported by this driver.
2063 static const __DRIconfig
**
2064 dri2_init_screen(__DRIscreen
* sPriv
)
2066 const __DRIconfig
**configs
;
2067 struct dri_screen
*screen
;
2068 struct pipe_screen
*pscreen
= NULL
;
2070 screen
= CALLOC_STRUCT(dri_screen
);
2074 screen
->sPriv
= sPriv
;
2075 screen
->fd
= sPriv
->fd
;
2076 (void) mtx_init(&screen
->opencl_func_mutex
, mtx_plain
);
2078 sPriv
->driverPrivate
= (void *)screen
;
2080 if (pipe_loader_drm_probe_fd(&screen
->dev
, screen
->fd
)) {
2081 dri_init_options(screen
);
2083 pscreen
= pipe_loader_create_screen(screen
->dev
);
2089 screen
->throttle
= pscreen
->get_param(pscreen
, PIPE_CAP_THROTTLE
);
2091 if (pscreen
->resource_create_with_modifiers
)
2092 dri2ImageExtension
.createImageWithModifiers
=
2093 dri2_create_image_with_modifiers
;
2095 if (pscreen
->get_param(pscreen
, PIPE_CAP_DMABUF
)) {
2098 if (drmGetCap(sPriv
->fd
, DRM_CAP_PRIME
, &cap
) == 0 &&
2099 (cap
& DRM_PRIME_CAP_IMPORT
)) {
2100 dri2ImageExtension
.createImageFromFds
= dri2_from_fds
;
2101 dri2ImageExtension
.createImageFromDmaBufs
= dri2_from_dma_bufs
;
2102 dri2ImageExtension
.createImageFromDmaBufs2
= dri2_from_dma_bufs2
;
2103 dri2ImageExtension
.queryDmaBufFormats
= dri2_query_dma_buf_formats
;
2104 dri2ImageExtension
.queryDmaBufModifiers
=
2105 dri2_query_dma_buf_modifiers
;
2106 dri2ImageExtension
.queryDmaBufFormatModifierAttribs
=
2107 dri2_query_dma_buf_format_modifier_attribs
;
2111 if (pscreen
->set_damage_region
)
2112 dri2BufferDamageExtension
.set_damage_region
= dri2_set_damage_region
;
2114 if (pscreen
->get_param(pscreen
, PIPE_CAP_DEVICE_RESET_STATUS_QUERY
)) {
2115 sPriv
->extensions
= dri_robust_screen_extensions
;
2116 screen
->has_reset_status_query
= true;
2119 sPriv
->extensions
= dri_screen_extensions
;
2121 configs
= dri_init_screen_helper(screen
, pscreen
);
2123 goto destroy_screen
;
2125 screen
->can_share_buffer
= true;
2126 screen
->auto_fake_front
= dri_with_format(sPriv
);
2127 screen
->broken_invalidate
= !sPriv
->dri2
.useInvalidate
;
2128 screen
->lookup_egl_image
= dri2_lookup_egl_image
;
2133 dri_destroy_screen_helper(screen
);
2137 pipe_loader_release(&screen
->dev
, 1);
2144 * This is the driver specific part of the createNewScreen entry point.
2146 * Returns the struct gl_config supported by this driver.
2148 static const __DRIconfig
**
2149 dri_kms_init_screen(__DRIscreen
* sPriv
)
2151 #if defined(GALLIUM_SOFTPIPE)
2152 const __DRIconfig
**configs
;
2153 struct dri_screen
*screen
;
2154 struct pipe_screen
*pscreen
= NULL
;
2157 screen
= CALLOC_STRUCT(dri_screen
);
2161 screen
->sPriv
= sPriv
;
2162 screen
->fd
= sPriv
->fd
;
2164 sPriv
->driverPrivate
= (void *)screen
;
2166 if (pipe_loader_sw_probe_kms(&screen
->dev
, screen
->fd
)) {
2167 dri_init_options(screen
);
2168 pscreen
= pipe_loader_create_screen(screen
->dev
);
2174 if (pscreen
->resource_create_with_modifiers
)
2175 dri2ImageExtension
.createImageWithModifiers
=
2176 dri2_create_image_with_modifiers
;
2178 if (drmGetCap(sPriv
->fd
, DRM_CAP_PRIME
, &cap
) == 0 &&
2179 (cap
& DRM_PRIME_CAP_IMPORT
)) {
2180 dri2ImageExtension
.createImageFromFds
= dri2_from_fds
;
2181 dri2ImageExtension
.createImageFromDmaBufs
= dri2_from_dma_bufs
;
2182 dri2ImageExtension
.createImageFromDmaBufs2
= dri2_from_dma_bufs2
;
2183 dri2ImageExtension
.queryDmaBufFormats
= dri2_query_dma_buf_formats
;
2184 dri2ImageExtension
.queryDmaBufModifiers
= dri2_query_dma_buf_modifiers
;
2187 sPriv
->extensions
= dri_screen_extensions
;
2189 configs
= dri_init_screen_helper(screen
, pscreen
);
2191 goto destroy_screen
;
2193 screen
->can_share_buffer
= false;
2194 screen
->auto_fake_front
= dri_with_format(sPriv
);
2195 screen
->broken_invalidate
= !sPriv
->dri2
.useInvalidate
;
2196 screen
->lookup_egl_image
= dri2_lookup_egl_image
;
2201 dri_destroy_screen_helper(screen
);
2205 pipe_loader_release(&screen
->dev
, 1);
2208 #endif // GALLIUM_SOFTPIPE
2213 dri2_create_buffer(__DRIscreen
* sPriv
,
2214 __DRIdrawable
* dPriv
,
2215 const struct gl_config
* visual
, boolean isPixmap
)
2217 struct dri_drawable
*drawable
= NULL
;
2219 if (!dri_create_buffer(sPriv
, dPriv
, visual
, isPixmap
))
2222 drawable
= dPriv
->driverPrivate
;
2224 drawable
->allocate_textures
= dri2_allocate_textures
;
2225 drawable
->flush_frontbuffer
= dri2_flush_frontbuffer
;
2226 drawable
->update_tex_buffer
= dri2_update_tex_buffer
;
2227 drawable
->flush_swapbuffers
= dri2_flush_swapbuffers
;
2233 * DRI driver virtual function table.
2235 * DRI versions differ in their implementation of init_screen and swap_buffers.
2237 const struct __DriverAPIRec galliumdrm_driver_api
= {
2238 .InitScreen
= dri2_init_screen
,
2239 .DestroyScreen
= dri_destroy_screen
,
2240 .CreateContext
= dri_create_context
,
2241 .DestroyContext
= dri_destroy_context
,
2242 .CreateBuffer
= dri2_create_buffer
,
2243 .DestroyBuffer
= dri_destroy_buffer
,
2244 .MakeCurrent
= dri_make_current
,
2245 .UnbindContext
= dri_unbind_context
,
2247 .AllocateBuffer
= dri2_allocate_buffer
,
2248 .ReleaseBuffer
= dri2_release_buffer
,
2252 * DRI driver virtual function table.
2254 * KMS/DRM version of the DriverAPI above sporting a different InitScreen
2255 * hook. The latter is used to explicitly initialise the kms_swrast driver
2256 * rather than selecting the approapriate driver as suggested by the loader.
2258 const struct __DriverAPIRec dri_kms_driver_api
= {
2259 .InitScreen
= dri_kms_init_screen
,
2260 .DestroyScreen
= dri_destroy_screen
,
2261 .CreateContext
= dri_create_context
,
2262 .DestroyContext
= dri_destroy_context
,
2263 .CreateBuffer
= dri2_create_buffer
,
2264 .DestroyBuffer
= dri_destroy_buffer
,
2265 .MakeCurrent
= dri_make_current
,
2266 .UnbindContext
= dri_unbind_context
,
2268 .AllocateBuffer
= dri2_allocate_buffer
,
2269 .ReleaseBuffer
= dri2_release_buffer
,
2272 /* This is the table of extensions that the loader will dlsym() for. */
2273 const __DRIextension
*galliumdrm_driver_extensions
[] = {
2274 &driCoreExtension
.base
,
2275 &driImageDriverExtension
.base
,
2276 &driDRI2Extension
.base
,
2277 &gallium_config_options
.base
,
2281 /* vim: set sw=3 ts=8 sts=3 expandtab: */