AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-12 20:00:09 +00:00
Code Issues Projects Releases Wiki Activity
486157f6bf
gtk/gdk/gdkdmabuf.c

1081 lines
35 KiB
C
Raw Normal View History

dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
/* gdkdmabuf.c
*
* Copyright 2023 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkdmabufprivate.h"
#include "gdkdebugprivate.h"
dmabuf: Add a fallback list of fourccs That way, we can work with older libdrm versions. The list was generated via a bit of sed and grep from the current dmabuf-fourcc.h, which is why I put it into its own file and included all the formats, no matter how old they are.
2023-11-25 00:33:04 +00:00
#include "gdkdmabuffourccprivate.h"
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
#include "gdkdmabuftextureprivate.h"
#include "gdkmemoryformatprivate.h"
build: Check for drm/drm_fourcc.h too It's part of the kernel headers package so I did not check for libdrm. As a side effect I checked the #define to HAVE_DMABUF.
2023-10-22 15:23:37 +00:00
#ifdef HAVE_DMABUF
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <linux/dma-buf.h>
#include <epoxy/egl.h>
typedef struct _GdkDrmFormatInfo GdkDrmFormatInfo;
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
struct _GdkDrmFormatInfo
{
guint32 fourcc;
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
GdkMemoryFormat memory_format;
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
void (* download) (guchar *dst_data,
gsize dst_stride,
GdkMemoryFormat dst_format,
gsize width,
gsize height,
const GdkDmabuf *dmabuf,
const guchar *src_datas[GDK_DMABUF_MAX_PLANES],
gsize sizes[GDK_DMABUF_MAX_PLANES]);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
};
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
static void
download_memcpy (guchar *dst_data,
gsize dst_stride,
GdkMemoryFormat dst_format,
gsize width,
gsize height,
const GdkDmabuf *dmabuf,
const guchar *src_datas[GDK_DMABUF_MAX_PLANES],
gsize sizes[GDK_DMABUF_MAX_PLANES])
{
const guchar *src_data;
gsize src_stride;
guint bpp;
bpp = gdk_memory_format_bytes_per_pixel (dst_format);
src_stride = dmabuf->planes[0].stride;
src_data = src_datas[0] + dmabuf->planes[0].offset;
g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + (height - 1) * dst_stride + width * bpp);
if (dst_stride == src_stride)
memcpy (dst_data, src_data, (height - 1) * dst_stride + width * bpp);
else
{
gsize i;
for (i = 0; i < height; i++)
memcpy (dst_data + i * dst_stride, src_data + i * src_stride, width * bpp);
}
}
dmabuf: Add support for separate alpha formats Support dmabuf formats with alpha in a separate plane. Related: #6208
2023-11-14 01:46:33 +00:00
static void
download_memcpy_3_1 (guchar *dst_data,
gsize dst_stride,
GdkMemoryFormat dst_format,
gsize width,
gsize height,
const GdkDmabuf *dmabuf,
const guchar *src_datas[GDK_DMABUF_MAX_PLANES],
gsize sizes[GDK_DMABUF_MAX_PLANES])
{
guint a;
guchar *dst_row;
const guchar *src_data, *src_row;
gsize src_stride;
g_assert (dmabuf->n_planes == 2);
download_memcpy (dst_data, dst_stride, dst_format, width, height, dmabuf, src_datas, sizes);
switch ((int)dst_format)
{
case GDK_MEMORY_A8R8G8B8:
case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
case GDK_MEMORY_A8B8G8R8:
case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
a = 0;
break;
case GDK_MEMORY_R8G8B8A8:
case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
case GDK_MEMORY_B8G8R8A8:
case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
a = 3;
break;
default:
g_assert_not_reached ();
}
src_stride = dmabuf->planes[1].stride;
src_data = src_datas[1];
for (gsize y = 0; y < height; y++)
{
dst_row = dst_data + y * dst_stride;
src_row = src_data + y * src_stride;
for (gsize x = 0; x < width; x++)
dst_row[4 * x + a] = src_row[x];
}
}
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
typedef struct _YUVCoefficients YUVCoefficients;
struct _YUVCoefficients
{
int v_to_r;
int u_to_g;
int v_to_g;
int u_to_b;
};
/* multiplied by 65536 */
//static const YUVCoefficients itu601_narrow = { 104597, -25675, -53279, 132201 };
static const YUVCoefficients itu601_wide = { 74711, -25864, -38050, 133176 };
static inline void
get_uv_values (const YUVCoefficients *coeffs,
guint8 u,
guint8 v,
int *out_r,
int *out_g,
int *out_b)
{
int u2 = (int) u - 127;
int v2 = (int) v - 127;
*out_r = coeffs->v_to_r * v2;
*out_g = coeffs->u_to_g * u2 + coeffs->v_to_g * v2;
*out_b = coeffs->u_to_b * u2;
}
static inline void
set_rgb_values (guint8 rgb[3],
guint8 y,
int r,
int g,
int b)
{
int y2 = y * 65536;
rgb[0] = CLAMP ((y2 + r) >> 16, 0, 255);
rgb[1] = CLAMP ((y2 + g) >> 16, 0, 255);
rgb[2] = CLAMP ((y2 + b) >> 16, 0, 255);
}
static void
download_nv12 (guchar *dst_data,
gsize dst_stride,
GdkMemoryFormat dst_format,
gsize width,
gsize height,
const GdkDmabuf *dmabuf,
const guchar *src_data[GDK_DMABUF_MAX_PLANES],
gsize sizes[GDK_DMABUF_MAX_PLANES])
{
const guchar *y_data, *uv_data;
gsize x, y, y_stride, uv_stride;
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
gsize U, V, X_SUB, Y_SUB;
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
switch (dmabuf->fourcc)
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
{
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
case DRM_FORMAT_NV12:
U = 0; V = 1; X_SUB = 2; Y_SUB = 2;
break;
case DRM_FORMAT_NV21:
U = 1; V = 0; X_SUB = 2; Y_SUB = 2;
break;
case DRM_FORMAT_NV16:
U = 0; V = 1; X_SUB = 2; Y_SUB = 1;
break;
case DRM_FORMAT_NV61:
U = 1; V = 0; X_SUB = 2; Y_SUB = 1;
break;
case DRM_FORMAT_NV24:
U = 0; V = 1; X_SUB = 1; Y_SUB = 1;
break;
case DRM_FORMAT_NV42:
U = 1; V = 0; X_SUB = 1; Y_SUB = 1;
break;
default:
g_assert_not_reached ();
return;
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
}
y_stride = dmabuf->planes[0].stride;
y_data = src_data[0] + dmabuf->planes[0].offset;
g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * y_stride);
uv_stride = dmabuf->planes[1].stride;
uv_data = src_data[1] + dmabuf->planes[1].offset;
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
g_return_if_fail (sizes[1] >= dmabuf->planes[1].offset + (height + Y_SUB - 1) / Y_SUB * uv_stride);
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
for (y = 0; y < height; y += Y_SUB)
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
{
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
for (x = 0; x < width; x += X_SUB)
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
{
int r, g, b;
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
gsize xs, ys;
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
get_uv_values (&itu601_wide, uv_data[x / X_SUB * 2 + U], uv_data[x / X_SUB * 2 + V], &r, &g, &b);
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
for (ys = 0; ys < Y_SUB && y + ys < height; ys++)
for (xs = 0; xs < X_SUB && x + xs < width; xs++)
set_rgb_values (&dst_data[3 * (x + xs) + dst_stride * ys], y_data[x + xs + y_stride * ys], r, g, b);
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
}
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
dst_data += Y_SUB * dst_stride;
y_data += Y_SUB * y_stride;
dmabuf: Add support for NV12 and NV21 This is as-good-as-necessary and doesn't do any fancy colorspace magic or chroma whatevering. That's a task for the future.
2023-10-20 11:30:52 +00:00
uv_data += uv_stride;
}
}
dmabuf: Add support for 3 plane YUV formats
2023-10-23 00:51:27 +00:00
static void
download_yuv_3 (guchar *dst_data,
gsize dst_stride,
GdkMemoryFormat dst_format,
gsize width,
gsize height,
const GdkDmabuf *dmabuf,
const guchar *src_data[GDK_DMABUF_MAX_PLANES],
gsize sizes[GDK_DMABUF_MAX_PLANES])
{
const guchar *y_data, *u_data, *v_data;
gsize x, y, y_stride, u_stride, v_stride;
gsize U, V, X_SUB, Y_SUB;
switch (dmabuf->fourcc)
{
case DRM_FORMAT_YUV410:
U = 1; V = 2; X_SUB = 4; Y_SUB = 4;
break;
case DRM_FORMAT_YVU410:
U = 2; V = 1; X_SUB = 4; Y_SUB = 4;
break;
case DRM_FORMAT_YUV411:
U = 1; V = 2; X_SUB = 4; Y_SUB = 1;
break;
case DRM_FORMAT_YVU411:
U = 2; V = 1; X_SUB = 4; Y_SUB = 1;
break;
case DRM_FORMAT_YUV420:
U = 1; V = 2; X_SUB = 2; Y_SUB = 2;
break;
case DRM_FORMAT_YVU420:
U = 2; V = 1; X_SUB = 2; Y_SUB = 2;
break;
case DRM_FORMAT_YUV422:
U = 1; V = 2; X_SUB = 2; Y_SUB = 1;
break;
case DRM_FORMAT_YVU422:
U = 2; V = 1; X_SUB = 2; Y_SUB = 1;
break;
case DRM_FORMAT_YUV444:
U = 1; V = 2; X_SUB = 1; Y_SUB = 1;
break;
case DRM_FORMAT_YVU444:
U = 2; V = 1; X_SUB = 1; Y_SUB = 1;
break;
default:
g_assert_not_reached ();
return;
}
y_stride = dmabuf->planes[0].stride;
y_data = src_data[0] + dmabuf->planes[0].offset;
g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * y_stride);
u_stride = dmabuf->planes[U].stride;
u_data = src_data[U] + dmabuf->planes[U].offset;
g_return_if_fail (sizes[U] >= dmabuf->planes[U].offset + (height + Y_SUB - 1) / Y_SUB * u_stride);
v_stride = dmabuf->planes[V].stride;
v_data = src_data[V] + dmabuf->planes[V].offset;
g_return_if_fail (sizes[V] >= dmabuf->planes[V].offset + (height + Y_SUB - 1) / Y_SUB * v_stride);
for (y = 0; y < height; y += Y_SUB)
{
for (x = 0; x < width; x += X_SUB)
{
int r, g, b;
gsize xs, ys;
get_uv_values (&itu601_wide, u_data[x / X_SUB], v_data[x / X_SUB], &r, &g, &b);
for (ys = 0; ys < Y_SUB && y + ys < height; ys++)
for (xs = 0; xs < X_SUB && x + xs < width; xs++)
set_rgb_values (&dst_data[3 * (x + xs) + dst_stride * ys], y_data[x + xs + y_stride * ys], r, g, b);
}
dst_data += Y_SUB * dst_stride;
y_data += Y_SUB * y_stride;
u_data += u_stride;
v_data += v_stride;
}
}
dmabuf: Support YUYV and friends Same as the NV12 support, but necessary for the poor people stuck on Intel laptops.
2023-10-20 11:54:05 +00:00
static void
download_yuyv (guchar *dst_data,
gsize dst_stride,
GdkMemoryFormat dst_format,
gsize width,
gsize height,
const GdkDmabuf *dmabuf,
const guchar *src_datas[GDK_DMABUF_MAX_PLANES],
gsize sizes[GDK_DMABUF_MAX_PLANES])
{
const guchar *src_data;
gsize x, y, src_stride;
gsize Y1, Y2, U, V;
switch (dmabuf->fourcc)
{
case DRM_FORMAT_YUYV:
Y1 = 0; U = 1; Y2 = 2; V = 3;
break;
case DRM_FORMAT_YVYU:
Y1 = 0; V = 1; Y2 = 2; U = 3;
break;
case DRM_FORMAT_UYVY:
U = 0; Y1 = 1; V = 2; Y2 = 3;
break;
case DRM_FORMAT_VYUY:
V = 0; Y1 = 1; U = 2; Y2 = 3;
break;
default:
g_assert_not_reached ();
return;
}
src_stride = dmabuf->planes[0].stride;
src_data = src_datas[0] + dmabuf->planes[0].offset;
g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * src_stride);
for (y = 0; y < height; y ++)
{
for (x = 0; x < width; x += 2)
{
int r, g, b;
get_uv_values (&itu601_wide, src_data[2 * x + U], src_data[2 * x + V], &r, &g, &b);
set_rgb_values (&dst_data[3 * x], src_data[2 * x + Y1], r, g, b);
if (x + 1 < width)
set_rgb_values (&dst_data[3 * (x + 1)], src_data[2 * x + Y2], r, g, b);
}
dst_data += dst_stride;
src_data += src_stride;
}
}
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
static const GdkDrmFormatInfo supported_formats[] = {
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
#if 0
/* palette formats?! */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_C1, GDK_MEMORY_, NULL },
{ DRM_FORMAT_C2, GDK_MEMORY_, NULL },
{ DRM_FORMAT_C4, GDK_MEMORY_, NULL },
{ DRM_FORMAT_C8, GDK_MEMORY_, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
#endif
/* darkness */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_D1, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_D2, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_D4, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_D8, GDK_MEMORY_G8, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* red only - we treat this as gray */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_R1, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_R2, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_R4, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_R8, GDK_MEMORY_G8, NULL },
{ DRM_FORMAT_R10, GDK_MEMORY_G16, NULL },
{ DRM_FORMAT_R12, GDK_MEMORY_G16, NULL },
{ DRM_FORMAT_R16, GDK_MEMORY_G16, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 2 channels - FIXME: Should this be gray + alpha? */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_RG88, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_GR88, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_RG1616, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_GR1616, GDK_MEMORY_R16G16B16, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* <8bit per channel RGB(A) */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_RGB332, GDK_MEMORY_B8G8R8, NULL },
{ DRM_FORMAT_BGR233, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_XRGB4444, GDK_MEMORY_B8G8R8, NULL },
{ DRM_FORMAT_XBGR4444, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_RGBX4444, GDK_MEMORY_B8G8R8, NULL },
{ DRM_FORMAT_BGRX4444, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_ARGB4444, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_ABGR4444, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_RGBA4444, GDK_MEMORY_A8B8G8R8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_BGRA4444, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_XRGB1555, GDK_MEMORY_B8G8R8, NULL },
{ DRM_FORMAT_XBGR1555, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_RGBX5551, GDK_MEMORY_B8G8R8, NULL },
{ DRM_FORMAT_BGRX5551, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_ARGB1555, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_ABGR1555, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_RGBA5551, GDK_MEMORY_A8B8G8R8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_BGRA5551, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_RGB565, GDK_MEMORY_B8G8R8, NULL },
{ DRM_FORMAT_BGR565, GDK_MEMORY_R8G8B8, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 8bit RGB */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_RGB888, GDK_MEMORY_R8G8B8, download_memcpy },
{ DRM_FORMAT_BGR888, GDK_MEMORY_B8G8R8, download_memcpy },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 8bit RGBA */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_BGRA8888, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, download_memcpy },
{ DRM_FORMAT_ABGR8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, download_memcpy },
{ DRM_FORMAT_ARGB8888, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, download_memcpy },
{ DRM_FORMAT_RGBA8888, GDK_MEMORY_A8B8G8R8_PREMULTIPLIED, download_memcpy },
{ DRM_FORMAT_BGRX8888, GDK_MEMORY_X8R8G8B8, download_memcpy },
{ DRM_FORMAT_XBGR8888, GDK_MEMORY_R8G8B8X8, download_memcpy },
{ DRM_FORMAT_XRGB8888, GDK_MEMORY_B8G8R8X8, download_memcpy },
{ DRM_FORMAT_RGBX8888, GDK_MEMORY_X8B8G8R8, download_memcpy },
{ DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, download_memcpy },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 10bit RGB(A) */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_XRGB2101010, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_XBGR2101010, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_RGBX1010102, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_BGRX1010102, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_ARGB2101010, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
{ DRM_FORMAT_ABGR2101010, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
{ DRM_FORMAT_RGBA1010102, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
{ DRM_FORMAT_BGRA1010102, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 16bit RGB(A) */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_XRGB16161616, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_XBGR16161616, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_ARGB16161616, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
{ DRM_FORMAT_ABGR16161616, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
{ DRM_FORMAT_XRGB16161616F, GDK_MEMORY_R16G16B16_FLOAT, NULL },
{ DRM_FORMAT_XBGR16161616F, GDK_MEMORY_R16G16B16_FLOAT, NULL },
{ DRM_FORMAT_ARGB16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, NULL },
{ DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, NULL },
{ DRM_FORMAT_AXBXGXRX106106106106, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 1-plane YUV formats */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_YUYV, GDK_MEMORY_R8G8B8, download_yuyv },
{ DRM_FORMAT_YVYU, GDK_MEMORY_R8G8B8, download_yuyv },
{ DRM_FORMAT_VYUY, GDK_MEMORY_R8G8B8, download_yuyv },
{ DRM_FORMAT_UYVY, GDK_MEMORY_R8G8B8, download_yuyv },
{ DRM_FORMAT_AYUV, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_AVUY8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_XYUV8888, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_XVUY8888, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_VUY888, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_VUY101010, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Y210, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Y212, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Y216, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Y410, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Y412, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Y416, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_XVYU2101010, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_XVYU12_16161616, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_XVYU16161616, GDK_MEMORY_R16G16B16, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* tiled YUV */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_Y0L0, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_X0L0, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_Y0L2, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_X0L2, GDK_MEMORY_R16G16B16, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* non-linear YUV */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_YUV420_8BIT, GDK_MEMORY_R8G8B8, NULL },
{ DRM_FORMAT_YUV420_10BIT, GDK_MEMORY_R16G16B16, NULL },
Cosmetics: Typo fix
2023-11-15 17:48:13 +00:00
/* 2 plane RGB + A */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_BGRX8888_A8, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, download_memcpy_3_1 },
{ DRM_FORMAT_RGBX8888_A8, GDK_MEMORY_A8B8G8R8_PREMULTIPLIED, download_memcpy_3_1 },
{ DRM_FORMAT_XBGR8888_A8, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, download_memcpy_3_1 },
{ DRM_FORMAT_XRGB8888_A8, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, download_memcpy_3_1 },
{ DRM_FORMAT_RGB888_A8, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_BGR888_A8, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_RGB565_A8, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, NULL },
{ DRM_FORMAT_BGR565_A8, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 2-plane YUV formats */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_NV12, GDK_MEMORY_R8G8B8, download_nv12 },
{ DRM_FORMAT_NV21, GDK_MEMORY_R8G8B8, download_nv12 },
{ DRM_FORMAT_NV16, GDK_MEMORY_R8G8B8, download_nv12 },
{ DRM_FORMAT_NV61, GDK_MEMORY_R8G8B8, download_nv12 },
{ DRM_FORMAT_NV24, GDK_MEMORY_R8G8B8, download_nv12 },
{ DRM_FORMAT_NV42, GDK_MEMORY_R8G8B8, download_nv12 },
{ DRM_FORMAT_NV15, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_P210, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_P010, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_P012, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_P016, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_P030, GDK_MEMORY_R16G16B16, NULL },
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
/* 3-plane YUV */
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
{ DRM_FORMAT_Q410, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_Q401, GDK_MEMORY_R16G16B16, NULL },
{ DRM_FORMAT_YUV410, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YVU410, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YUV411, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YVU411, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YUV420, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YVU420, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YUV422, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YVU422, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YUV444, GDK_MEMORY_R8G8B8, download_yuv_3 },
{ DRM_FORMAT_YVU444, GDK_MEMORY_R8G8B8, download_yuv_3 },
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
};
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
static const GdkDrmFormatInfo *
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
get_drm_format_info (guint32 fourcc)
{
for (int i = 0; i < G_N_ELEMENTS (supported_formats); i++)
{
if (supported_formats[i].fourcc == fourcc)
return &supported_formats[i];
}
return NULL;
}
dmabuf: Refactor function 1. Don't require passing in a GdkDisplay 2. return TRUE/FALSE if a format was found, so calling code can decide how to handle failure itself
2023-11-23 01:00:30 +00:00
gboolean
gdk_dmabuf_get_memory_format (guint32 fourcc,
gboolean premultiplied,
GdkMemoryFormat *out_format)
dmabuf: NV12 is opaque Getting this wrong matters, since we won't offload textures in non-opaque formats. Found by Robert Mader. At the same time, unify the two places we have for mapping from fourcc to memory format.
2023-11-11 22:56:01 +00:00
{
const GdkDrmFormatInfo *info = get_drm_format_info (fourcc);
dmabuf: Refactor function 1. Don't require passing in a GdkDisplay 2. return TRUE/FALSE if a format was found, so calling code can decide how to handle failure itself
2023-11-23 01:00:30 +00:00
if (info == NULL)
return FALSE;
dmabuf: NV12 is opaque Getting this wrong matters, since we won't offload textures in non-opaque formats. Found by Robert Mader. At the same time, unify the two places we have for mapping from fourcc to memory format.
2023-11-11 22:56:01 +00:00
dmabuf: Refactor function 1. Don't require passing in a GdkDisplay 2. return TRUE/FALSE if a format was found, so calling code can decide how to handle failure itself
2023-11-23 01:00:30 +00:00
if (premultiplied)
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
*out_format = gdk_memory_format_get_premultiplied (info->memory_format);
dmabuf: Refactor function 1. Don't require passing in a GdkDisplay 2. return TRUE/FALSE if a format was found, so calling code can decide how to handle failure itself
2023-11-23 01:00:30 +00:00
else
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
*out_format = gdk_memory_format_get_straight (info->memory_format);
dmabuf: Add a debug message for format fallback This may be helpful in pinpointing why a dmabuf format behaves unexpectedly.
2023-11-11 23:51:28 +00:00
dmabuf: Refactor function 1. Don't require passing in a GdkDisplay 2. return TRUE/FALSE if a format was found, so calling code can decide how to handle failure itself
2023-11-23 01:00:30 +00:00
return TRUE;
dmabuf: NV12 is opaque Getting this wrong matters, since we won't offload textures in non-opaque formats. Found by Robert Mader. At the same time, unify the two places we have for mapping from fourcc to memory format.
2023-11-11 22:56:01 +00:00
}
dmabuf: Add gdk_dmabuf_get_fourcc() Returns the fourcc for a given GdkMemoryFormat. Not sure if this is the best name, but I didn't know a better one.
2023-11-24 10:05:01 +00:00
gboolean
gdk_dmabuf_get_fourcc (GdkMemoryFormat format,
guint32 *out_fourcc)
{
/* we're not walking the list on purpose, so that we can keep track
* of exact matches here. Certain DRM formats map to the same memory
* format and we don't want the list to accidentally get mixed up.
*/
switch (format)
{
case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
case GDK_MEMORY_B8G8R8A8:
*out_fourcc = DRM_FORMAT_ARGB8888;
return TRUE;
case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
case GDK_MEMORY_A8R8G8B8:
*out_fourcc = DRM_FORMAT_BGRA8888;
return TRUE;
case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
case GDK_MEMORY_A8B8G8R8:
*out_fourcc = DRM_FORMAT_RGBA8888;
return TRUE;
case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
case GDK_MEMORY_R8G8B8A8:
*out_fourcc = DRM_FORMAT_ABGR8888;
return TRUE;
case GDK_MEMORY_R8G8B8:
*out_fourcc = DRM_FORMAT_BGR888;
return TRUE;
case GDK_MEMORY_B8G8R8:
*out_fourcc = DRM_FORMAT_RGB888;
return TRUE;
case GDK_MEMORY_B8G8R8X8:
*out_fourcc = DRM_FORMAT_XRGB8888;
return TRUE;
case GDK_MEMORY_X8R8G8B8:
*out_fourcc = DRM_FORMAT_BGRX8888;
return TRUE;
case GDK_MEMORY_R8G8B8X8:
*out_fourcc = DRM_FORMAT_XBGR8888;
return TRUE;
case GDK_MEMORY_X8B8G8R8:
*out_fourcc = DRM_FORMAT_RGBX8888;
return TRUE;
case GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED:
case GDK_MEMORY_R16G16B16A16_FLOAT:
*out_fourcc = DRM_FORMAT_ABGR16161616F;
return TRUE;
case GDK_MEMORY_R16G16B16A16_PREMULTIPLIED:
case GDK_MEMORY_R16G16B16A16:
*out_fourcc = DRM_FORMAT_ABGR16161616;
return TRUE;
case GDK_MEMORY_G8:
*out_fourcc = DRM_FORMAT_R8;
return TRUE;
case GDK_MEMORY_G16:
*out_fourcc = DRM_FORMAT_R16;
return TRUE;
case GDK_MEMORY_R16G16B16:
case GDK_MEMORY_R16G16B16_FLOAT:
case GDK_MEMORY_R32G32B32_FLOAT:
case GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED:
case GDK_MEMORY_R32G32B32A32_FLOAT:
case GDK_MEMORY_G8A8_PREMULTIPLIED:
case GDK_MEMORY_G8A8:
case GDK_MEMORY_G16A16_PREMULTIPLIED:
case GDK_MEMORY_G16A16:
case GDK_MEMORY_A8:
case GDK_MEMORY_A16:
case GDK_MEMORY_A16_FLOAT:
case GDK_MEMORY_A32_FLOAT:
return FALSE;
case GDK_MEMORY_N_FORMATS:
default:
g_assert_not_reached ();
return FALSE;
}
}
dmabuf: Allow downloaders to fail initialization When adding the formats of a downloader, allow them to return FALSE to mean "This method is not supported", which is a useful way to opt out when checking GL or Vulkan extensions and finding out that the desired one isn't supported.
2023-10-22 13:59:02 +00:00
static gboolean
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
gdk_dmabuf_direct_downloader_add_formats (const GdkDmabufDownloader *downloader,
GdkDisplay *display,
GdkDmabufFormatsBuilder *builder)
{
gsize i;
for (i = 0; i < G_N_ELEMENTS (supported_formats); i++)
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"%s dmabuf format %.4s:%#" G_GINT64_MODIFIER "x",
downloader->name,
(char *) &supported_formats[i].fourcc, (guint64) DRM_FORMAT_MOD_LINEAR);
dmabuf: Don't print unsupported formats We were confusingly printing "supported format" for dmabuf formats that we end up not adding to our list of supported formats. Don't do that, it is confusing. At the same time, we shuold print out the linear formats we support via mmap.
2023-10-23 02:29:44 +00:00
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
gdk_dmabuf_formats_builder_add_format (builder,
supported_formats[i].fourcc,
DRM_FORMAT_MOD_LINEAR);
}
dmabuf: Allow downloaders to fail initialization When adding the formats of a downloader, allow them to return FALSE to mean "This method is not supported", which is a useful way to opt out when checking GL or Vulkan extensions and finding out that the desired one isn't supported.
2023-10-22 13:59:02 +00:00
return TRUE;
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
}
static gboolean
gdk_dmabuf_direct_downloader_supports (const GdkDmabufDownloader *downloader,
GdkDisplay *display,
const GdkDmabuf *dmabuf,
gboolean premultiplied,
GdkMemoryFormat *out_format,
GError **error)
{
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
const GdkDrmFormatInfo *info;
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
info = get_drm_format_info (dmabuf->fourcc);
dmabuf: Add all formats Add the matching GdkMemoryFormat for all dmabuf formats. This way, we don't fall back to RGBA8 for 10- and 16-bit formats that we don't support natively when EGL or Vulkan use them. Also includes corrections for a few mixups.
2023-11-23 01:01:56 +00:00
if (!info || !info->download)
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
{
dmabuf: Tweak error messages
2023-10-17 01:58:10 +00:00
g_set_error (error,
GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
"Unsupported dmabuf format %.4s",
(char *) &dmabuf->fourcc);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
return FALSE;
}
dmabuf: Tweak error messages
2023-10-17 01:58:10 +00:00
if (dmabuf->modifier != DRM_FORMAT_MOD_LINEAR)
{
g_set_error (error,
GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
"Unsupported dmabuf modifier %#lx (only linear buffers are supported)",
dmabuf->modifier);
return FALSE;
}
memoryformat: Introduce new (private) API Add gdk_memory_format_get_premultiplied() and gdk_memory_format_get_straight() which return the matching premultiplied/straight format. Use this to pick the premultiplied format when uploading GL textures. And remove the duplication in the dmabuf code, where we can now use these functions instead of tracking both the premultiplied and straight alpha versions.
2023-12-11 03:20:32 +00:00
if (premultiplied)
*out_format = gdk_memory_format_get_premultiplied (info->memory_format);
else
*out_format = gdk_memory_format_get_straight (info->memory_format);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
return TRUE;
}
static void
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
gdk_dmabuf_direct_downloader_do_download (const GdkDmabufDownloader *downloader,
GdkTexture *texture,
guchar *data,
gsize stride)
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
{
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
const GdkDrmFormatInfo *info;
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
const GdkDmabuf *dmabuf;
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
const guchar *src_data[GDK_DMABUF_MAX_PLANES];
gsize sizes[GDK_DMABUF_MAX_PLANES];
gsize needs_unmap[GDK_DMABUF_MAX_PLANES] = { FALSE, };
gsize i, j;
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
dmabuf = gdk_dmabuf_texture_get_dmabuf (GDK_DMABUF_TEXTURE (texture));
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
info = get_drm_format_info (dmabuf->fourcc);
Quiet a compiler warning
2023-11-26 13:44:11 +00:00
g_return_if_fail (info && info->download);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (gdk_dmabuf_texture_get_display (GDK_DMABUF_TEXTURE (texture)), DMABUF,
"Using %s for downloading a dmabuf (format %.4s:%#" G_GINT64_MODIFIER "x)",
downloader->name, (char *)&dmabuf->fourcc, dmabuf->modifier);
dmabuf: Improve the debug message Printing the format can only help.
2023-10-21 00:03:27 +00:00
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
for (i = 0; i < dmabuf->n_planes; i++)
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
{
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
for (j = 0; j < i; j++)
{
if (dmabuf->planes[i].fd == dmabuf->planes[j].fd)
break;
}
if (j < i)
{
src_data[i] = src_data[j];
sizes[i] = sizes[j];
continue;
}
dmabuf: Fix NV12 import We were not seeking in the right fd, so our sizes were wrong, and crashes happened.
2023-10-20 23:51:05 +00:00
sizes[i] = lseek (dmabuf->planes[i].fd, 0, SEEK_END);
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
if (sizes[i] == (off_t) -1)
{
g_warning ("Failed to seek dmabuf: %s", g_strerror (errno));
goto out;
}
Cosmetics: Typo fix
2023-11-15 17:48:13 +00:00
/* be a good citizen and seek back to the start, as the docs recommend */
dmabuf: Seek back to the start https://docs.kernel.org/driver-api/dma-buf.html recommends doing that, so we do that.
2023-10-23 14:56:33 +00:00
lseek (dmabuf->planes[i].fd, 0, SEEK_SET);
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
dmabuf: Add gdk_dmabuf_ioctl() The function is a copy of libdrm's drmIoctl() and handles EINTR and EAGAIN error.s Use it for the sync ioctls in the dmabuf mmaping calls.
2023-11-26 04:28:34 +00:00
if (gdk_dmabuf_ioctl (dmabuf->planes[i].fd, DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_START|DMA_BUF_SYNC_READ }) < 0)
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
g_warning ("Failed to sync dmabuf: %s", g_strerror (errno));
src_data[i] = mmap (NULL, sizes[i], PROT_READ, MAP_SHARED, dmabuf->planes[i].fd, dmabuf->planes[i].offset);
if (src_data[i] == NULL)
{
g_warning ("Failed to mmap dmabuf: %s", g_strerror (errno));
goto out;
}
needs_unmap[i] = TRUE;
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
}
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
info->download (data,
stride,
gdk_texture_get_format (texture),
gdk_texture_get_width (texture),
gdk_texture_get_height (texture),
dmabuf,
src_data,
sizes);
out:
for (i = 0; i < dmabuf->n_planes; i++)
{
if (!needs_unmap[i])
continue;
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
dmabuf: Fix the mmap logic We want to unmap the buffers we mapped in the first loop, so pass the right pointers here.
2023-10-20 23:58:58 +00:00
munmap ((void *)src_data[i], sizes[i]);
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
dmabuf: Add gdk_dmabuf_ioctl() The function is a copy of libdrm's drmIoctl() and handles EINTR and EAGAIN error.s Use it for the sync ioctls in the dmabuf mmaping calls.
2023-11-26 04:28:34 +00:00
if (gdk_dmabuf_ioctl (dmabuf->planes[i].fd, DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_END|DMA_BUF_SYNC_READ }) < 0)
dmabuf: Improve download 1. Split out the download function from the mmap'ing of the plane(s) 2. Make the code mmap() all the planes 3. Determine size using lseek() as documented by libdrm, instead of trying to guess it from the format. 4. Fix some bugs, like switcheroos of width and height
2023-10-20 10:21:34 +00:00
g_warning ("Failed to sync dmabuf: %s", g_strerror (errno));
}
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
}
static void
gdk_dmabuf_direct_downloader_download (const GdkDmabufDownloader *downloader,
GdkTexture *texture,
GdkMemoryFormat format,
guchar *data,
gsize stride)
{
GdkMemoryFormat src_format = gdk_texture_get_format (texture);
if (format == src_format)
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
gdk_dmabuf_direct_downloader_do_download (downloader, texture, data, stride);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
else
{
unsigned int width, height;
guchar *src_data;
gsize src_stride;
width = gdk_texture_get_width (texture);
height = gdk_texture_get_height (texture);
dmabuf: Allocate the intermediate buffer properly. We should use the stride from the buffer's format, not from the dmabuf.
2023-10-20 10:12:23 +00:00
src_stride = width * gdk_memory_format_bytes_per_pixel (src_format);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
src_data = g_new (guchar, src_stride * height);
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
gdk_dmabuf_direct_downloader_do_download (downloader, texture, src_data, src_stride);
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
gdk_memory_convert (data, stride, format,
src_data, src_stride, src_format,
width, height);
g_free (src_data);
}
}
const GdkDmabufDownloader *
gdk_dmabuf_get_direct_downloader (void)
{
static const GdkDmabufDownloader downloader = {
dmabuf: Give downloaders a name Add name to the downloader struct, and add it to the debug spew for newly created dmabuf textures.
2023-10-21 23:19:21 +00:00
"mmap",
dmabuf: Split out GdkDmabuf and GdkDmabufDownloader GdkDmabuf is a struct encapsulating all the values of a dmabuf, so nothing to see here. GdkDmabufDownloader is a vtable for a thing that can download dmabufs. For now only one implementation exists, so this just looks like a ton of work for no benefit. The only neat thing is that gdkdmabuftexture.c got a whole lot tidier.
2023-10-15 03:21:23 +00:00
gdk_dmabuf_direct_downloader_add_formats,
gdk_dmabuf_direct_downloader_supports,
gdk_dmabuf_direct_downloader_download,
};
return &downloader;
}
dmabuf: Add gdk_dmabuf_ioctl() The function is a copy of libdrm's drmIoctl() and handles EINTR and EAGAIN error.s Use it for the sync ioctls in the dmabuf mmaping calls.
2023-11-26 04:28:34 +00:00
int
gdk_dmabuf_ioctl (int fd,
unsigned long request,
void *arg)
{
int ret;
do {
ret = ioctl (fd, request, arg);
} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
return ret;
}
dmabuf: Add gdk_dmabuf_import/export_sync_fd() Vulkan needs this. This code is following the code that compositors with Wayland support - like wlroots - are doing. The code was introduced to Linux in https://lore.kernel.org/dri-devel/20220506180216.2095060-1-jason@jlekstrand.net/
2023-11-26 04:58:57 +00:00
#if !defined(DMA_BUF_IOCTL_IMPORT_SYNC_FILE)
struct dma_buf_import_sync_file
{
__u32 flags;
__s32 fd;
};
#define DMA_BUF_IOCTL_IMPORT_SYNC_FILE _IOW(DMA_BUF_BASE, 3, struct dma_buf_import_sync_file)
#endif
gboolean
gdk_dmabuf_import_sync_file (int dmabuf_fd,
guint32 flags,
int sync_file_fd)
{
struct dma_buf_import_sync_file data = {
.flags = flags,
.fd = sync_file_fd,
};
if (gdk_dmabuf_ioctl (dmabuf_fd, DMA_BUF_IOCTL_IMPORT_SYNC_FILE, &data) != 0)
{
GDK_DEBUG (DMABUF, "Importing dmabuf sync failed: %s", g_strerror (errno));
return FALSE;
}
return TRUE;
}
#if !defined(DMA_BUF_IOCTL_EXPORT_SYNC_FILE)
struct dma_buf_export_sync_file
{
__u32 flags;
__s32 fd;
};
#define DMA_BUF_IOCTL_EXPORT_SYNC_FILE _IOWR(DMA_BUF_BASE, 2, struct dma_buf_export_sync_file)
#endif
int
gdk_dmabuf_export_sync_file (int dmabuf_fd,
guint32 flags)
{
struct dma_buf_export_sync_file data = {
.flags = flags,
.fd = -1,
};
if (gdk_dmabuf_ioctl (dmabuf_fd, DMA_BUF_IOCTL_EXPORT_SYNC_FILE, &data) != 0)
{
GDK_DEBUG (DMABUF, "Exporting dmabuf sync failed: %s", g_strerror (errno));
return -1;
}
return data.fd;
}
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
/*
* Tries to sanitize the dmabuf to conform to the values expected
* by Vulkan/EGL which should also be the values expected by
* Wayland compositors
*
* We put these sanitized values into the GdkDmabufTexture, by
* sanitizing the input from GdkDmabufTextureBuilder, which are
* controlled by the callers.
*
* Things we do here:
dmabuf: Update a comment
2023-10-23 03:14:07 +00:00
*
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
* 1. Disallow any dmabuf format that we do not know.
*
dmabuf: Allow implicit modifiers Remove all the roadblocks we've put up to keep implicit modifiers out. Our importing code already handles them as a signal that says 'No modifiers, please!'. Now we just hope for the best and pass things along. This is necessary since some drivers won't produce any explicit modifiers.
2023-10-24 05:08:17 +00:00
* 2. Ignore non-linear modifiers.
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
*
dmabuf: Allow implicit modifiers Remove all the roadblocks we've put up to keep implicit modifiers out. Our importing code already handles them as a signal that says 'No modifiers, please!'. Now we just hope for the best and pass things along. This is necessary since some drivers won't produce any explicit modifiers.
2023-10-24 05:08:17 +00:00
* 3. Try and fix various inconsistencies between V4L and Mesa
* for linear modifiers, like the e.g. single-plane NV12.
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
*
* *** WARNING ***
*
* This function is not absolutely perfect, you do not have a
* perfect dmabuf afterwards.
*
* In particular, it doesn't check sizes.
*
* *** WARNING ***
*/
gboolean
gdk_dmabuf_sanitize (GdkDmabuf *dest,
gsize width,
gsize height,
const GdkDmabuf *src,
GError **error)
{
const GdkDrmFormatInfo *info;
dmabuf: Ensure the number of planes is sane Make it a programming error when setting planes to 0 and throw a GError if somebody uses more than GDK_DMABUF_MAX_PLANES.
2023-10-20 10:10:28 +00:00
if (src->n_planes > GDK_DMABUF_MAX_PLANES)
{
g_set_error (error,
GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
"GTK only support dmabufs with %u planes, not %u",
GDK_DMABUF_MAX_PLANES, src->n_planes);
return FALSE;
}
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
info = get_drm_format_info (src->fourcc);
if (info == NULL)
{
g_set_error (error,
GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
"Unsupported dmabuf format %.4s",
(char *) &src->fourcc);
return FALSE;
}
*dest = *src;
dmabuf: Reject the INVALID modifier Trying to use it is a programming error, applications should have code that uses real modifiers. Also add a check to the formatsbuilder so our code doesn't include the invalid modifier by accident. We don't really know how to deal with it, so better force applications to figure out what to do.
2023-10-22 14:51:02 +00:00
if (src->modifier)
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
return TRUE;
switch (dest->fourcc)
{
case DRM_FORMAT_NV12:
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
case DRM_FORMAT_NV21:
case DRM_FORMAT_NV16:
case DRM_FORMAT_NV61:
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
if (dest->n_planes == 1)
{
dest->n_planes = 2;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = dest->planes[0].stride;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
}
break;
dmabuf: Add NV16, NV61, NV24 and NV42 and sanitize them and NV21.
2023-10-22 23:41:25 +00:00
case DRM_FORMAT_NV24:
case DRM_FORMAT_NV42:
if (dest->n_planes == 1)
{
dest->n_planes = 2;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = dest->planes[0].stride * 2;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
}
break;
dmabuf: Add support for 3 plane YUV formats
2023-10-23 00:51:27 +00:00
case DRM_FORMAT_YUV410:
case DRM_FORMAT_YVU410:
if (dest->n_planes == 1)
{
dest->n_planes = 3;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = (dest->planes[0].stride + 3) / 4;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
dest->planes[2].fd = dest->planes[1].fd;
dest->planes[2].stride = dest->planes[1].stride;
dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * ((height + 3) / 4);
}
break;
case DRM_FORMAT_YUV411:
case DRM_FORMAT_YVU411:
if (dest->n_planes == 1)
{
dest->n_planes = 3;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = (dest->planes[0].stride + 3) / 4;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
dest->planes[2].fd = dest->planes[1].fd;
dest->planes[2].stride = dest->planes[1].stride;
dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * height;
}
break;
case DRM_FORMAT_YUV420:
case DRM_FORMAT_YVU420:
if (dest->n_planes == 1)
{
dest->n_planes = 3;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = (dest->planes[0].stride + 1) / 2;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
dest->planes[2].fd = dest->planes[1].fd;
dest->planes[2].stride = dest->planes[1].stride;
dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * ((height + 1) / 2);
}
break;
case DRM_FORMAT_YUV422:
case DRM_FORMAT_YVU422:
if (dest->n_planes == 1)
{
dest->n_planes = 3;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = (dest->planes[0].stride + 1) / 2;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
dest->planes[2].fd = dest->planes[1].fd;
dest->planes[2].stride = dest->planes[1].stride;
dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * height;
}
break;
case DRM_FORMAT_YUV444:
case DRM_FORMAT_YVU444:
if (dest->n_planes == 1)
{
dest->n_planes = 3;
dest->planes[1].fd = dest->planes[0].fd;
dest->planes[1].stride = dest->planes[0].stride;
dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
dest->planes[2].fd = dest->planes[1].fd;
dest->planes[2].stride = dest->planes[1].stride;
dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * height;
}
break;
dmabuf: Add gdk_dmabuf_sanitize() Tries to sanitize the dmabuf to conform to the values expected by Vulkan/EGL which should also be the values expected by Wayland compositors We put these sanitized values into the GdkDmabufTexture, by sanitizing the input from GdkDmabufTextureBuilder, which are controlled by the callers. Things we do here: 1. Disallow any dmabuf format that we do not know. 1. Treat the INVALID modifier the same as LINEAR. 2. Ignore all other modifiers. 3. Try and fix various inconsistencies between V4L and Mesa, like NV12. *** WARNING *** This function is not absolutely perfect, you do not have a perfect dmabuf afterwards. In particular, it doesn't check sizes.
2023-10-20 10:08:18 +00:00
default:
break;
}
return TRUE;
}
dmabuf: Add gdk_dmabuf_is_disjoint() No users yet, but Vulkan will use this later. So have it available already.
2023-10-21 19:23:11 +00:00
/*
* gdk_dmabuf_is_disjoint:
* @dmabuf: a sanitized GdkDmabuf
*
* A dmabuf is considered disjoint if it uses more than
* 1 file descriptor.
*
* Returns: %TRUE if the dmabuf is disjoint
**/
gboolean
gdk_dmabuf_is_disjoint (const GdkDmabuf *dmabuf)
{
unsigned i;
for (i = 1; i < dmabuf->n_planes; i++)
{
if (dmabuf->planes[0].fd != dmabuf->planes[i].fd)
return TRUE;
}
return FALSE;
}
build: Check for drm/drm_fourcc.h too It's part of the kernel headers package so I did not check for libdrm. As a side effect I checked the #define to HAVE_DMABUF.
2023-10-22 15:23:37 +00:00
#endif /* HAVE_DMABUF */
Reference in New Issue Copy Permalink