AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-08 17:50:10 +00:00
Code Issues Projects Releases Wiki Activity
ebc3600f78
gtk/gdk/gdkmemoryformatprivate.h

127 lines
8.0 KiB
C
Raw Normal View History

memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
/*
* Copyright © 2021 Benjamin Otte
*
* 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.1 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/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
Convert headers to #pragma once The conversion was done by guard2one.
2023-03-31 19:11:10 +00:00
#pragma once
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
gdk: Split enums from types Add gdkenums.h for enums and keep gdktypes.h for types. Makes both files easier to read.
2021-10-25 00:14:18 +00:00
#include "gdkenums.h"
memoryformat: Change some private API Make gdk_memory_format_gl_format take the GdkGLContext, instead of just a gles boolean. This will let us check for extensions that may be needed for certain formats. Update all callers.
2023-10-19 17:46:34 +00:00
#include "gdktypes.h"
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
gsk: Support swizzle for gray and alpha formats Swizzling is needed to display one channel memory formats as gray etc.
2023-05-26 12:45:05 +00:00
#include <epoxy/gl.h>
memoryformat: Add Vulkan format information This is not used yet, but I want to add it, so that it exists. That way, when we add new formats, people don't forget to add the Vulkan formats.
2023-12-15 07:27:09 +00:00
#ifdef GDK_RENDERING_VULKAN
#include <vulkan/vulkan.h>
#endif
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
G_BEGIN_DECLS
gdk: Rework gdk_pixbuf_get_from_texture() Make it use gdk_memory_texture_from_texture(). Also make gdk_memory_format_alpha() privately available so that we can detect if an image contains an alpha channel.
2021-09-25 22:22:20 +00:00
typedef enum {
GDK_MEMORY_ALPHA_PREMULTIPLIED,
GDK_MEMORY_ALPHA_STRAIGHT,
GDK_MEMORY_ALPHA_OPAQUE
} GdkMemoryAlpha;
memoryformat: Add gdk_memory_format_get_depth() Replace gdk_memory_format_prefers_high_depth with the more generic gdk_memory_format_get_depth() that returns the depth of the individual channels. Also make the GL renderer use that to pick the generic F16 format instead of immediately going for F32 when uploading textures.
2023-06-15 18:02:46 +00:00
typedef enum {
gdk: Add GDK_MEMORY_NONE depth That's basically the "undefined" value. We need that when drawing nothing, which so far only happens with empty container nodes. But empty container nodes can be children of other nodes, and that makes things propagate. So instead of catching them, force the whole rest of the code to deal with an undefined depth. We also can't just set a random depth, because that will cause merging to fail.
2024-07-03 20:40:45 +00:00
GDK_MEMORY_NONE,
memoryformat: Add gdk_memory_format_get_depth() Replace gdk_memory_format_prefers_high_depth with the more generic gdk_memory_format_get_depth() that returns the depth of the individual channels. Also make the GL renderer use that to pick the generic F16 format instead of immediately going for F32 when uploading textures.
2023-06-15 18:02:46 +00:00
GDK_MEMORY_U8,
gdk: Add GDK_MEMORY_U8_SRGB depth This is an experiment for now, but it seems that encoding srgb inside the depth makes sense, as we not just use depth to decide on the GL fbconfigs/Vulkan formats to pick, depth also encodes how the [0...1] color values are quantized when stored. Let's see where this goes.
2024-06-26 17:40:55 +00:00
GDK_MEMORY_U8_SRGB,
memoryformat: Add gdk_memory_format_get_depth() Replace gdk_memory_format_prefers_high_depth with the more generic gdk_memory_format_get_depth() that returns the depth of the individual channels. Also make the GL renderer use that to pick the generic F16 format instead of immediately going for F32 when uploading textures.
2023-06-15 18:02:46 +00:00
GDK_MEMORY_U16,
GDK_MEMORY_FLOAT16,
gdk: Add GDK_N_DEPTHS to the enum We are indexing arrays by the number of depths, and when adding depths we don't want to forget to grow those arrays.
2024-06-26 18:01:13 +00:00
GDK_MEMORY_FLOAT32,
GDK_N_DEPTHS
memoryformat: Add gdk_memory_format_get_depth() Replace gdk_memory_format_prefers_high_depth with the more generic gdk_memory_format_get_depth() that returns the depth of the individual channels. Also make the GL renderer use that to pick the generic F16 format instead of immediately going for F32 when uploading textures.
2023-06-15 18:02:46 +00:00
} GdkMemoryDepth;
rendernode: Make sure depth variable has enough bits This will be relevant when we add new values to it.
2024-07-03 16:36:49 +00:00
#define GDK_MEMORY_DEPTH_BITS 3
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
gsize gdk_memory_format_alignment (GdkMemoryFormat format) G_GNUC_CONST;
gdk: Rework gdk_pixbuf_get_from_texture() Make it use gdk_memory_texture_from_texture(). Also make gdk_memory_format_alpha() privately available so that we can detect if an image contains an alpha channel.
2021-09-25 22:22:20 +00:00
GdkMemoryAlpha gdk_memory_format_alpha (GdkMemoryFormat format) G_GNUC_CONST;
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
gsize gdk_memory_format_bytes_per_pixel (GdkMemoryFormat format) G_GNUC_CONST;
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 gdk_memory_format_get_premultiplied (GdkMemoryFormat format) G_GNUC_CONST;
GdkMemoryFormat gdk_memory_format_get_straight (GdkMemoryFormat format) G_GNUC_CONST;
memoryformat: Add gdk_memory_format_get_fallbacks() Track fallback formats to use in the memoryformat directly instead of using in the GL uploading code. First of all, this allows sharing the code and ensuring all our renderers use the same fallback mechanism. But also, this allows tracking fallbacks per-format which is useful because the fallback formats aren't really a tree. We want to make FLOAT16 fall back to FLOAT32 when not available, but we also want FLOAT32 fall back to FLOAT16. By tracking the fallbacks per-format, we can achieve that.
2023-12-11 03:23:16 +00:00
const GdkMemoryFormat * gdk_memory_format_get_fallbacks (GdkMemoryFormat format) G_GNUC_CONST;
gdk: Add GDK_MEMORY_U8_SRGB depth This is an experiment for now, but it seems that encoding srgb inside the depth makes sense, as we not just use depth to decide on the GL fbconfigs/Vulkan formats to pick, depth also encodes how the [0...1] color values are quantized when stored. Let's see where this goes.
2024-06-26 17:40:55 +00:00
GdkMemoryDepth gdk_memory_format_get_depth (GdkMemoryFormat format,
gboolean srgb) G_GNUC_CONST;
memoryformat: Split out a function It's used in many places and attaching a name to what it does is useful.
2024-07-02 20:46:56 +00:00
gsize gdk_memory_format_min_buffer_size (GdkMemoryFormat format,
gsize stride,
gsize width,
gsize height) G_GNUC_CONST;
gdk: Add GDK_MEMORY_U8_SRGB depth This is an experiment for now, but it seems that encoding srgb inside the depth makes sense, as we not just use depth to decide on the GL fbconfigs/Vulkan formats to pick, depth also encodes how the [0...1] color values are quantized when stored. Let's see where this goes.
2024-06-26 17:40:55 +00:00
gboolean gdk_memory_depth_is_srgb (GdkMemoryDepth depth) G_GNUC_CONST;
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
GdkMemoryDepth gdk_memory_depth_merge (GdkMemoryDepth depth1,
GdkMemoryDepth depth2) G_GNUC_CONST;
gl: Make gdk_memory_format_gl_format() no longer check support Now that we have gdk_gl_context_get_memory_flags() and code can use that function, make the code do that. Remove support checks from gdk_memory_format_gl_format(). This is an initial naive port that doesn't try to make use of the finer-grained flags yet.
2023-12-07 04:49:22 +00:00
GdkMemoryFormat gdk_memory_depth_get_format (GdkMemoryDepth depth) G_GNUC_CONST;
gdk: Add function to query alpha format for depth It's meant to be used in renderers.
2023-07-21 23:11:19 +00:00
GdkMemoryFormat gdk_memory_depth_get_alpha_format (GdkMemoryDepth depth) G_GNUC_CONST;
memoryformat: Add a debug helper I need this often enough that I'll just put it here.
2024-08-07 12:21:01 +00:00
const char * gdk_memory_depth_get_name (GdkMemoryDepth depth);
gl: Make gdk_memory_format_gl_format() no longer check support Now that we have gdk_gl_context_get_memory_flags() and code can use that function, make the code do that. Remove support checks from gdk_memory_format_gl_format(). This is an initial naive port that doesn't try to make use of the finer-grained flags yet.
2023-12-07 04:49:22 +00:00
void gdk_memory_format_gl_format (GdkMemoryFormat format,
gl: Require GL/GLES flag when looking up memory formats This code just adds the argument to the function and fixes all callers. It's separate because it's just a bunch of boilerplate.
2024-01-16 19:10:50 +00:00
gboolean gles,
memoryformat: Fix variable types Use the same types that GL uses.
2023-12-11 04:31:32 +00:00
GLint *out_internal_format,
gdk: Allow querying GL SRGB formats Nobody is using this yet.
2024-06-17 20:10:24 +00:00
GLint *out_internal_srgb_format,
memoryformat: Fix variable types Use the same types that GL uses.
2023-12-11 04:31:32 +00:00
GLenum *out_format,
GLenum *out_type,
gl: Add a new alternative format Add an "RGBA" format that just maps to the swizzled version of the default format. This way, BGR gets mapped to RGB + swizzling first before trying to map it to the default format for the depth. The benefit here is that this format has the same memory width, so uploading/downloading code can treat it equivalent to the original format and there's no conversion neccessary later.
2023-12-09 06:17:51 +00:00
GLint out_swizzle[4]);
gboolean gdk_memory_format_gl_rgba_format (GdkMemoryFormat format,
gl: Require GL/GLES flag when looking up memory formats This code just adds the argument to the function and fixes all callers. It's separate because it's just a bunch of boilerplate.
2024-01-16 19:10:50 +00:00
gboolean gles,
gl: Add a new alternative format Add an "RGBA" format that just maps to the swizzled version of the default format. This way, BGR gets mapped to RGB + swizzling first before trying to map it to the default format for the depth. The benefit here is that this format has the same memory width, so uploading/downloading code can treat it equivalent to the original format and there's no conversion neccessary later.
2023-12-09 06:17:51 +00:00
GdkMemoryFormat *out_actual_format,
memoryformat: Fix variable types Use the same types that GL uses.
2023-12-11 04:31:32 +00:00
GLint *out_internal_format,
gdk: Allow querying Vulkan SRGB formats Nobody is using this yet, this is just infrastructure.
2024-06-17 20:10:02 +00:00
GLint *out_internal_srgb_format,
memoryformat: Fix variable types Use the same types that GL uses.
2023-12-11 04:31:32 +00:00
GLenum *out_format,
GLenum *out_type,
gl: Add a new alternative format Add an "RGBA" format that just maps to the swizzled version of the default format. This way, BGR gets mapped to RGB + swizzling first before trying to map it to the default format for the depth. The benefit here is that this format has the same memory width, so uploading/downloading code can treat it equivalent to the original format and there's no conversion neccessary later.
2023-12-09 06:17:51 +00:00
GLint out_swizzle[4]);
memoryformat: Add Vulkan format information This is not used yet, but I want to add it, so that it exists. That way, when we add new formats, people don't forget to add the Vulkan formats.
2023-12-15 07:27:09 +00:00
#ifdef GDK_RENDERING_VULKAN
VkFormat gdk_memory_format_vk_format (GdkMemoryFormat format,
VkComponentMapping *out_swizzle);
gdk: Allow querying Vulkan SRGB formats Nobody is using this yet, this is just infrastructure.
2024-06-17 20:10:02 +00:00
VkFormat gdk_memory_format_vk_srgb_format (GdkMemoryFormat format);
memoryformat: Add Vulkan format information This is not used yet, but I want to add it, so that it exists. That way, when we add new formats, people don't forget to add the Vulkan formats.
2023-12-15 07:27:09 +00:00
VkFormat gdk_memory_format_vk_rgba_format (GdkMemoryFormat format,
GdkMemoryFormat *out_rgba_format,
VkComponentMapping *out_swizzle);
#endif
memoryformat: Put dmabuf fourccs into the big format table I'm concentrating the data about memory formats, and this part was missing.
2023-12-16 09:27:24 +00:00
guint32 gdk_memory_format_get_dmabuf_fourcc (GdkMemoryFormat format);
Give memory formats a name This is useful in debugging. The names I chose are shortened a bit from the enum values. We use just a single depth, * for premultiplied, and f for float.
2024-06-09 19:52:18 +00:00
const char * gdk_memory_format_get_name (GdkMemoryFormat format);
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
void gdk_memory_convert (guchar *dest_data,
gsize dest_stride,
GdkMemoryFormat dest_format,
texturedownloader: Add color state ... and plumb the color state through the downloading machinery, where no matter what path it takes it ends up in gdk_memory_convert_color_state() or gdk_memory_convert(). The 2nd of those has been expanded to optionally do colorstate conversion when the 2 colorstates are different.
2024-07-13 22:51:05 +00:00
GdkColorState *src_cs,
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
const guchar *src_data,
gsize src_stride,
GdkMemoryFormat src_format,
texturedownloader: Add color state ... and plumb the color state through the downloading machinery, where no matter what path it takes it ends up in gdk_memory_convert_color_state() or gdk_memory_convert(). The 2nd of those has been expanded to optionally do colorstate conversion when the 2 colorstates are different.
2024-07-13 22:51:05 +00:00
GdkColorState *dest_cs,
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
gsize width,
gsize height);
gdk: Add gdk_memory_format_convert_color_state This allows in-place color state conversions.
2024-06-19 12:24:35 +00:00
void gdk_memory_convert_color_state (guchar *data,
gsize stride,
GdkMemoryFormat format,
GdkColorState *src_color_state,
GdkColorState *dest_color_state,
gsize width,
gsize height);
gpu: Allow uploading of mipmap levels when tiling This allows uploading less memory but requires computing lod levels on the CPU which is slow because it reads through all of the memory and so far entirely not optimized. However, it uses significantly less VRAM. This is done by adding a gdk_memory_mipmap() function that does this task. The texture upload op now accepts a lod level and if that is >0 it uses gdk_memory_mipmap() on the source texture.
2024-08-27 02:48:43 +00:00
void gdk_memory_mipmap (guchar *dest,
gsize dest_stride,
memoryformat: Take src_format and dest_format Why do we need this? Because RGB images are provided in RGB format but GPUs can't handle RGB, only RGBA, so we need to convert. And we need to do that without allocating too much memory, because allocating memory is slow. Which means in aprticular we need to do the conversion after mipmapping, not before (like we were doing).
2024-08-27 03:59:54 +00:00
GdkMemoryFormat dest_format,
gpu: Allow uploading of mipmap levels when tiling This allows uploading less memory but requires computing lod levels on the CPU which is slow because it reads through all of the memory and so far entirely not optimized. However, it uses significantly less VRAM. This is done by adding a gdk_memory_mipmap() function that does this task. The texture upload op now accepts a lod level and if that is >0 it uses gdk_memory_mipmap() on the source texture.
2024-08-27 02:48:43 +00:00
const guchar *src,
gsize src_stride,
memoryformat: Take src_format and dest_format Why do we need this? Because RGB images are provided in RGB format but GPUs can't handle RGB, only RGBA, so we need to convert. And we need to do that without allocating too much memory, because allocating memory is slow. Which means in aprticular we need to do the conversion after mipmapping, not before (like we were doing).
2024-08-27 03:59:54 +00:00
GdkMemoryFormat src_format,
gpu: Allow uploading of mipmap levels when tiling This allows uploading less memory but requires computing lod levels on the CPU which is slow because it reads through all of the memory and so far entirely not optimized. However, it uses significantly less VRAM. This is done by adding a gdk_memory_mipmap() function that does this task. The texture upload op now accepts a lod level and if that is >0 it uses gdk_memory_mipmap() on the source texture.
2024-08-27 02:48:43 +00:00
gsize src_width,
gsize src_height,
memoryformat: Add linear/nearest choice for mipmaping linear will average all the pixels for the lod, nearest will just pick one (using the same method as OpenGL/Vulkan, picking bottom right center). This doesn't really make linear/nearest filtering work as it should (because it's still a form of mipmaps), but it has 2 advantages: 1. it gets closer to the desired effect 2. it is a lot faster Because only 1 pixel is chosen from the original image, instead of averaging all pixels, a lot less memory needs to be accessed, and because memory access is the bottleneck for large images, the speedup is almost linear with the number of pixels not accessed. And that means that even for lot level 3, aka 1/8th scale, only 1/64 of the pixels need to be accessed, and everything is 50x faster. Switching gtk4-demo --run=image_scaling to linear/nearest makes all the lag go away for me, even with a 64k x 64k image.
2024-09-03 04:12:03 +00:00
guint lod_level,
gboolean linear);
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
G_END_DECLS
Reference in New Issue Copy Permalink