1 /* GIMP - The GNU Image Manipulation Program
2 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 */
17
18 #include "config.h"
19
20 #include <string.h>
21
22 #include <cairo.h>
23 #include <gegl.h>
24 #include <gdk-pixbuf/gdk-pixbuf.h>
25
26 #include "libgimpbase/gimpbase.h"
27 #include "libgimpmath/gimpmath.h"
28 #include "libgimpcolor/gimpcolor.h"
29
30 #include "core-types.h"
31
32 #include "gimp-memsize.h"
33 #include "gimpparamspecs.h"
34
35
36 gint64
gimp_g_type_instance_get_memsize(GTypeInstance * instance)37 gimp_g_type_instance_get_memsize (GTypeInstance *instance)
38 {
39 if (instance)
40 {
41 GTypeQuery type_query;
42
43 g_type_query (G_TYPE_FROM_INSTANCE (instance), &type_query);
44
45 return type_query.instance_size;
46 }
47
48 return 0;
49 }
50
51 gint64
gimp_g_object_get_memsize(GObject * object)52 gimp_g_object_get_memsize (GObject *object)
53 {
54 if (object)
55 return gimp_g_type_instance_get_memsize ((GTypeInstance *) object);
56
57 return 0;
58 }
59
60 gint64
gimp_g_hash_table_get_memsize(GHashTable * hash,gint64 data_size)61 gimp_g_hash_table_get_memsize (GHashTable *hash,
62 gint64 data_size)
63 {
64 if (hash)
65 return (2 * sizeof (gint) +
66 5 * sizeof (gpointer) +
67 g_hash_table_size (hash) * (3 * sizeof (gpointer) + data_size));
68
69 return 0;
70 }
71
72 typedef struct
73 {
74 GimpMemsizeFunc func;
75 gint64 memsize;
76 gint64 gui_size;
77 } HashMemsize;
78
79 static void
hash_memsize_foreach(gpointer key,gpointer value,HashMemsize * memsize)80 hash_memsize_foreach (gpointer key,
81 gpointer value,
82 HashMemsize *memsize)
83 {
84 gint64 gui_size = 0;
85
86 memsize->memsize += memsize->func (value, &gui_size);
87 memsize->gui_size += gui_size;
88 }
89
90 gint64
gimp_g_hash_table_get_memsize_foreach(GHashTable * hash,GimpMemsizeFunc func,gint64 * gui_size)91 gimp_g_hash_table_get_memsize_foreach (GHashTable *hash,
92 GimpMemsizeFunc func,
93 gint64 *gui_size)
94 {
95 HashMemsize memsize;
96
97 g_return_val_if_fail (func != NULL, 0);
98
99 if (! hash)
100 return 0;
101
102 memsize.func = func;
103 memsize.memsize = 0;
104 memsize.gui_size = 0;
105
106 g_hash_table_foreach (hash, (GHFunc) hash_memsize_foreach, &memsize);
107
108 if (gui_size)
109 *gui_size = memsize.gui_size;
110
111 return memsize.memsize + gimp_g_hash_table_get_memsize (hash, 0);
112 }
113
114 gint64
gimp_g_slist_get_memsize(GSList * slist,gint64 data_size)115 gimp_g_slist_get_memsize (GSList *slist,
116 gint64 data_size)
117 {
118 return g_slist_length (slist) * (data_size + sizeof (GSList));
119 }
120
121 gint64
gimp_g_slist_get_memsize_foreach(GSList * slist,GimpMemsizeFunc func,gint64 * gui_size)122 gimp_g_slist_get_memsize_foreach (GSList *slist,
123 GimpMemsizeFunc func,
124 gint64 *gui_size)
125 {
126 GSList *l;
127 gint64 memsize = 0;
128
129 g_return_val_if_fail (func != NULL, 0);
130
131 for (l = slist; l; l = g_slist_next (l))
132 memsize += sizeof (GSList) + func (l->data, gui_size);
133
134 return memsize;
135 }
136
137 gint64
gimp_g_list_get_memsize(GList * list,gint64 data_size)138 gimp_g_list_get_memsize (GList *list,
139 gint64 data_size)
140 {
141 return g_list_length (list) * (data_size + sizeof (GList));
142 }
143
144 gint64
gimp_g_list_get_memsize_foreach(GList * list,GimpMemsizeFunc func,gint64 * gui_size)145 gimp_g_list_get_memsize_foreach (GList *list,
146 GimpMemsizeFunc func,
147 gint64 *gui_size)
148 {
149 GList *l;
150 gint64 memsize = 0;
151
152 g_return_val_if_fail (func != NULL, 0);
153
154 for (l = list; l; l = g_list_next (l))
155 memsize += sizeof (GList) + func (l->data, gui_size);
156
157 return memsize;
158 }
159
160 gint64
gimp_g_queue_get_memsize(GQueue * queue,gint64 data_size)161 gimp_g_queue_get_memsize (GQueue *queue,
162 gint64 data_size)
163 {
164 if (queue)
165 {
166 return sizeof (GQueue) +
167 g_queue_get_length (queue) * (data_size + sizeof (GList));
168 }
169
170 return 0;
171 }
172
173 gint64
gimp_g_queue_get_memsize_foreach(GQueue * queue,GimpMemsizeFunc func,gint64 * gui_size)174 gimp_g_queue_get_memsize_foreach (GQueue *queue,
175 GimpMemsizeFunc func,
176 gint64 *gui_size)
177 {
178 gint64 memsize = 0;
179
180 g_return_val_if_fail (func != NULL, 0);
181
182 if (queue)
183 {
184 GList *l;
185
186 memsize = sizeof (GQueue);
187
188 for (l = queue->head; l; l = g_list_next (l))
189 memsize += sizeof (GList) + func (l->data, gui_size);
190 }
191
192 return memsize;
193 }
194
195 gint64
gimp_g_value_get_memsize(GValue * value)196 gimp_g_value_get_memsize (GValue *value)
197 {
198 gint64 memsize = 0;
199
200 if (! value)
201 return 0;
202
203 if (G_VALUE_HOLDS_STRING (value))
204 {
205 memsize += gimp_string_get_memsize (g_value_get_string (value));
206 }
207 else if (G_VALUE_HOLDS_BOXED (value))
208 {
209 if (GIMP_VALUE_HOLDS_RGB (value))
210 {
211 memsize += sizeof (GimpRGB);
212 }
213 else if (GIMP_VALUE_HOLDS_MATRIX2 (value))
214 {
215 memsize += sizeof (GimpMatrix2);
216 }
217 else if (GIMP_VALUE_HOLDS_PARASITE (value))
218 {
219 memsize += gimp_parasite_get_memsize (g_value_get_boxed (value),
220 NULL);
221 }
222 else if (GIMP_VALUE_HOLDS_ARRAY (value) ||
223 GIMP_VALUE_HOLDS_INT8_ARRAY (value) ||
224 GIMP_VALUE_HOLDS_INT16_ARRAY (value) ||
225 GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
226 GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
227 {
228 GimpArray *array = g_value_get_boxed (value);
229
230 if (array)
231 memsize += sizeof (GimpArray) +
232 (array->static_data ? 0 : array->length);
233 }
234 else if (GIMP_VALUE_HOLDS_STRING_ARRAY (value))
235 {
236 GimpArray *array = g_value_get_boxed (value);
237
238 if (array)
239 {
240 memsize += sizeof (GimpArray);
241
242 if (! array->static_data)
243 {
244 gchar **tmp = (gchar **) array->data;
245 gint i;
246
247 memsize += array->length * sizeof (gchar *);
248
249 for (i = 0; i < array->length; i++)
250 memsize += gimp_string_get_memsize (tmp[i]);
251 }
252 }
253 }
254 else
255 {
256 g_printerr ("%s: unhandled boxed value type: %s\n",
257 G_STRFUNC, G_VALUE_TYPE_NAME (value));
258 }
259 }
260 else if (G_VALUE_HOLDS_OBJECT (value))
261 {
262 g_printerr ("%s: unhandled object value type: %s\n",
263 G_STRFUNC, G_VALUE_TYPE_NAME (value));
264 }
265
266 return memsize + sizeof (GValue);
267 }
268
269 gint64
gimp_g_param_spec_get_memsize(GParamSpec * pspec)270 gimp_g_param_spec_get_memsize (GParamSpec *pspec)
271 {
272 gint64 memsize = 0;
273
274 if (! pspec)
275 return 0;
276
277 if (! (pspec->flags & G_PARAM_STATIC_NAME))
278 memsize += gimp_string_get_memsize (g_param_spec_get_name (pspec));
279
280 if (! (pspec->flags & G_PARAM_STATIC_NICK))
281 memsize += gimp_string_get_memsize (g_param_spec_get_nick (pspec));
282
283 if (! (pspec->flags & G_PARAM_STATIC_BLURB))
284 memsize += gimp_string_get_memsize (g_param_spec_get_blurb (pspec));
285
286 return memsize + gimp_g_type_instance_get_memsize ((GTypeInstance *) pspec);
287 }
288
289 gint64
gimp_gegl_buffer_get_memsize(GeglBuffer * buffer)290 gimp_gegl_buffer_get_memsize (GeglBuffer *buffer)
291 {
292 if (buffer)
293 {
294 const Babl *format = gegl_buffer_get_format (buffer);
295
296 return (babl_format_get_bytes_per_pixel (format) *
297 gegl_buffer_get_width (buffer) *
298 gegl_buffer_get_height (buffer) +
299 gimp_g_object_get_memsize (G_OBJECT (buffer)));
300 }
301
302 return 0;
303 }
304
305 gint64
gimp_gegl_pyramid_get_memsize(GeglBuffer * buffer)306 gimp_gegl_pyramid_get_memsize (GeglBuffer *buffer)
307 {
308 if (buffer)
309 {
310 const Babl *format = gegl_buffer_get_format (buffer);
311
312 /* The pyramid levels constitute a geometric sum with a ratio of 1/4. */
313 return ((gint64) babl_format_get_bytes_per_pixel (format) *
314 (gint64) gegl_buffer_get_width (buffer) *
315 (gint64) gegl_buffer_get_height (buffer) * 1.33 +
316 gimp_g_object_get_memsize (G_OBJECT (buffer)));
317 }
318
319 return 0;
320 }
321
322 gint64
gimp_string_get_memsize(const gchar * string)323 gimp_string_get_memsize (const gchar *string)
324 {
325 if (string)
326 return strlen (string) + 1;
327
328 return 0;
329 }
330
331 gint64
gimp_parasite_get_memsize(GimpParasite * parasite,gint64 * gui_size)332 gimp_parasite_get_memsize (GimpParasite *parasite,
333 gint64 *gui_size)
334 {
335 if (parasite)
336 return (sizeof (GimpParasite) +
337 gimp_string_get_memsize (parasite->name) +
338 parasite->size);
339
340 return 0;
341 }
342