GFXprim
2D bitmap graphics library with emphasis on speed and correctness
Loading...
Searching...
No Matches
gp_loaders.gen.h
1// SPDX-License-Identifier: GPL-2.1-or-later
2/*
3 * gp_loaders.gen.h
4 *
5 * GENERATED on 2025 10 02 10:16:51 from gp_loaders.gen.h.t
6 *
7 * DO NOT MODIFY THIS FILE DIRECTLY!
8 */
9#ifndef GP_LOADERS_GEN_H
10#define GP_LOADERS_GEN_H
11
12/*
13 * Inline functions for loading and saving various pixmap formats.
14 *
15 * Copyright (C) 2017 Cyril Hrubis <metan@ucw.cz>
16 */
17#include <loaders/gp_loader.h>
18
19
20/*** Function prototypes for bmp ***/
21
22extern const gp_loader gp_bmp;
23
24int gp_match_bmp(const void *buf);
25
26int gp_read_bmp_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
27 gp_progress_cb *callback);
28
29static inline gp_pixmap *gp_load_bmp(const char *src_path,
30 gp_progress_cb *callback)
31{
32 return gp_loader_load_image(&gp_bmp, src_path, callback);
33}
34
35static inline gp_pixmap *gp_read_bmp(gp_io *io, gp_progress_cb *callback)
36{
37 return gp_loader_read_image(&gp_bmp, io, callback);
38}
39
40int gp_write_bmp(const gp_pixmap *src, gp_io *io,
41 gp_progress_cb *callback);
42
43static inline int gp_save_bmp(const gp_pixmap *src, const char *dst_path,
44 gp_progress_cb *callback)
45{
46 return gp_loader_save_image(&gp_bmp, src, dst_path, callback);
47}
48
49/*** Function prototypes for jpg ***/
50
51extern const gp_loader gp_jpg;
52
53int gp_match_jpg(const void *buf);
54
55int gp_read_jpg_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
56 gp_progress_cb *callback);
57
58static inline gp_pixmap *gp_load_jpg(const char *src_path,
59 gp_progress_cb *callback)
60{
61 return gp_loader_load_image(&gp_jpg, src_path, callback);
62}
63
64static inline gp_pixmap *gp_read_jpg(gp_io *io, gp_progress_cb *callback)
65{
66 return gp_loader_read_image(&gp_jpg, io, callback);
67}
68
69int gp_write_jpg(const gp_pixmap *src, gp_io *io,
70 gp_progress_cb *callback);
71
72static inline int gp_save_jpg(const gp_pixmap *src, const char *dst_path,
73 gp_progress_cb *callback)
74{
75 return gp_loader_save_image(&gp_jpg, src, dst_path, callback);
76}
77
78/*** Function prototypes for png ***/
79
80extern const gp_loader gp_png;
81
82int gp_match_png(const void *buf);
83
84int gp_read_png_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
85 gp_progress_cb *callback);
86
87static inline gp_pixmap *gp_load_png(const char *src_path,
88 gp_progress_cb *callback)
89{
90 return gp_loader_load_image(&gp_png, src_path, callback);
91}
92
93static inline gp_pixmap *gp_read_png(gp_io *io, gp_progress_cb *callback)
94{
95 return gp_loader_read_image(&gp_png, io, callback);
96}
97
98int gp_write_png(const gp_pixmap *src, gp_io *io,
99 gp_progress_cb *callback);
100
101static inline int gp_save_png(const gp_pixmap *src, const char *dst_path,
102 gp_progress_cb *callback)
103{
104 return gp_loader_save_image(&gp_png, src, dst_path, callback);
105}
106
107/*** Function prototypes for tiff ***/
108
109extern const gp_loader gp_tiff;
110
111int gp_match_tiff(const void *buf);
112
113int gp_read_tiff_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
114 gp_progress_cb *callback);
115
116static inline gp_pixmap *gp_load_tiff(const char *src_path,
117 gp_progress_cb *callback)
118{
119 return gp_loader_load_image(&gp_tiff, src_path, callback);
120}
121
122static inline gp_pixmap *gp_read_tiff(gp_io *io, gp_progress_cb *callback)
123{
124 return gp_loader_read_image(&gp_tiff, io, callback);
125}
126
127int gp_write_tiff(const gp_pixmap *src, gp_io *io,
128 gp_progress_cb *callback);
129
130static inline int gp_save_tiff(const gp_pixmap *src, const char *dst_path,
131 gp_progress_cb *callback)
132{
133 return gp_loader_save_image(&gp_tiff, src, dst_path, callback);
134}
135
136/*** Function prototypes for pbm ***/
137
138extern const gp_loader gp_pbm;
139
140int gp_match_pbm(const void *buf);
141
142int gp_read_pbm_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
143 gp_progress_cb *callback);
144
145static inline gp_pixmap *gp_load_pbm(const char *src_path,
146 gp_progress_cb *callback)
147{
148 return gp_loader_load_image(&gp_pbm, src_path, callback);
149}
150
151static inline gp_pixmap *gp_read_pbm(gp_io *io, gp_progress_cb *callback)
152{
153 return gp_loader_read_image(&gp_pbm, io, callback);
154}
155
156int gp_write_pbm(const gp_pixmap *src, gp_io *io,
157 gp_progress_cb *callback);
158
159static inline int gp_save_pbm(const gp_pixmap *src, const char *dst_path,
160 gp_progress_cb *callback)
161{
162 return gp_loader_save_image(&gp_pbm, src, dst_path, callback);
163}
164
165/*** Function prototypes for pgm ***/
166
167extern const gp_loader gp_pgm;
168
169int gp_match_pgm(const void *buf);
170
171int gp_read_pgm_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
172 gp_progress_cb *callback);
173
174static inline gp_pixmap *gp_load_pgm(const char *src_path,
175 gp_progress_cb *callback)
176{
177 return gp_loader_load_image(&gp_pgm, src_path, callback);
178}
179
180static inline gp_pixmap *gp_read_pgm(gp_io *io, gp_progress_cb *callback)
181{
182 return gp_loader_read_image(&gp_pgm, io, callback);
183}
184
185int gp_write_pgm(const gp_pixmap *src, gp_io *io,
186 gp_progress_cb *callback);
187
188static inline int gp_save_pgm(const gp_pixmap *src, const char *dst_path,
189 gp_progress_cb *callback)
190{
191 return gp_loader_save_image(&gp_pgm, src, dst_path, callback);
192}
193
194/*** Function prototypes for ppm ***/
195
196extern const gp_loader gp_ppm;
197
198int gp_match_ppm(const void *buf);
199
200int gp_read_ppm_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
201 gp_progress_cb *callback);
202
203static inline gp_pixmap *gp_load_ppm(const char *src_path,
204 gp_progress_cb *callback)
205{
206 return gp_loader_load_image(&gp_ppm, src_path, callback);
207}
208
209static inline gp_pixmap *gp_read_ppm(gp_io *io, gp_progress_cb *callback)
210{
211 return gp_loader_read_image(&gp_ppm, io, callback);
212}
213
214int gp_write_ppm(const gp_pixmap *src, gp_io *io,
215 gp_progress_cb *callback);
216
217static inline int gp_save_ppm(const gp_pixmap *src, const char *dst_path,
218 gp_progress_cb *callback)
219{
220 return gp_loader_save_image(&gp_ppm, src, dst_path, callback);
221}
222
223/*** Function prototypes for pnm ***/
224
225extern const gp_loader gp_pnm;
226
227int gp_match_pnm(const void *buf);
228
229int gp_read_pnm_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
230 gp_progress_cb *callback);
231
232static inline gp_pixmap *gp_load_pnm(const char *src_path,
233 gp_progress_cb *callback)
234{
235 return gp_loader_load_image(&gp_pnm, src_path, callback);
236}
237
238static inline gp_pixmap *gp_read_pnm(gp_io *io, gp_progress_cb *callback)
239{
240 return gp_loader_read_image(&gp_pnm, io, callback);
241}
242
243int gp_write_pnm(const gp_pixmap *src, gp_io *io,
244 gp_progress_cb *callback);
245
246static inline int gp_save_pnm(const gp_pixmap *src, const char *dst_path,
247 gp_progress_cb *callback)
248{
249 return gp_loader_save_image(&gp_pnm, src, dst_path, callback);
250}
251
252/*** Function prototypes for webp ***/
253
254extern const gp_loader gp_webp;
255
256int gp_match_webp(const void *buf);
257
258int gp_read_webp_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
259 gp_progress_cb *callback);
260
261static inline gp_pixmap *gp_load_webp(const char *src_path,
262 gp_progress_cb *callback)
263{
264 return gp_loader_load_image(&gp_webp, src_path, callback);
265}
266
267static inline gp_pixmap *gp_read_webp(gp_io *io, gp_progress_cb *callback)
268{
269 return gp_loader_read_image(&gp_webp, io, callback);
270}
271
272int gp_write_webp(const gp_pixmap *src, gp_io *io,
273 gp_progress_cb *callback);
274
275static inline int gp_save_webp(const gp_pixmap *src, const char *dst_path,
276 gp_progress_cb *callback)
277{
278 return gp_loader_save_image(&gp_webp, src, dst_path, callback);
279}
280
281/*** Function prototypes for ico ***/
282
283extern const gp_loader gp_ico;
284
285int gp_match_ico(const void *buf);
286
287int gp_read_ico_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
288 gp_progress_cb *callback);
289
290static inline gp_pixmap *gp_load_ico(const char *src_path,
291 gp_progress_cb *callback)
292{
293 return gp_loader_load_image(&gp_ico, src_path, callback);
294}
295
296static inline gp_pixmap *gp_read_ico(gp_io *io, gp_progress_cb *callback)
297{
298 return gp_loader_read_image(&gp_ico, io, callback);
299}
300/*** Function prototypes for jp2 ***/
301
302extern const gp_loader gp_jp2;
303
304int gp_match_jp2(const void *buf);
305
306int gp_read_jp2_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
307 gp_progress_cb *callback);
308
309static inline gp_pixmap *gp_load_jp2(const char *src_path,
310 gp_progress_cb *callback)
311{
312 return gp_loader_load_image(&gp_jp2, src_path, callback);
313}
314
315static inline gp_pixmap *gp_read_jp2(gp_io *io, gp_progress_cb *callback)
316{
317 return gp_loader_read_image(&gp_jp2, io, callback);
318}
319/*** Function prototypes for pcx ***/
320
321extern const gp_loader gp_pcx;
322
323int gp_match_pcx(const void *buf);
324
325int gp_read_pcx_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
326 gp_progress_cb *callback);
327
328static inline gp_pixmap *gp_load_pcx(const char *src_path,
329 gp_progress_cb *callback)
330{
331 return gp_loader_load_image(&gp_pcx, src_path, callback);
332}
333
334static inline gp_pixmap *gp_read_pcx(gp_io *io, gp_progress_cb *callback)
335{
336 return gp_loader_read_image(&gp_pcx, io, callback);
337}
338/*** Function prototypes for gif ***/
339
340extern const gp_loader gp_gif;
341
342int gp_match_gif(const void *buf);
343
344int gp_read_gif_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
345 gp_progress_cb *callback);
346
347static inline gp_pixmap *gp_load_gif(const char *src_path,
348 gp_progress_cb *callback)
349{
350 return gp_loader_load_image(&gp_gif, src_path, callback);
351}
352
353static inline gp_pixmap *gp_read_gif(gp_io *io, gp_progress_cb *callback)
354{
355 return gp_loader_read_image(&gp_gif, io, callback);
356}
357/*** Function prototypes for psp ***/
358
359extern const gp_loader gp_psp;
360
361int gp_match_psp(const void *buf);
362
363int gp_read_psp_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
364 gp_progress_cb *callback);
365
366static inline gp_pixmap *gp_load_psp(const char *src_path,
367 gp_progress_cb *callback)
368{
369 return gp_loader_load_image(&gp_psp, src_path, callback);
370}
371
372static inline gp_pixmap *gp_read_psp(gp_io *io, gp_progress_cb *callback)
373{
374 return gp_loader_read_image(&gp_psp, io, callback);
375}
376/*** Function prototypes for psd ***/
377
378extern const gp_loader gp_psd;
379
380int gp_match_psd(const void *buf);
381
382int gp_read_psd_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
383 gp_progress_cb *callback);
384
385static inline gp_pixmap *gp_load_psd(const char *src_path,
386 gp_progress_cb *callback)
387{
388 return gp_loader_load_image(&gp_psd, src_path, callback);
389}
390
391static inline gp_pixmap *gp_read_psd(gp_io *io, gp_progress_cb *callback)
392{
393 return gp_loader_read_image(&gp_psd, io, callback);
394}
395/*** Function prototypes for heif ***/
396
397extern const gp_loader gp_heif;
398
399int gp_match_heif(const void *buf);
400
401int gp_read_heif_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
402 gp_progress_cb *callback);
403
404static inline gp_pixmap *gp_load_heif(const char *src_path,
405 gp_progress_cb *callback)
406{
407 return gp_loader_load_image(&gp_heif, src_path, callback);
408}
409
410static inline gp_pixmap *gp_read_heif(gp_io *io, gp_progress_cb *callback)
411{
412 return gp_loader_read_image(&gp_heif, io, callback);
413}
414#endif /* GP_LOADERS_GEN_H */
gp_io
An I/O abstraction.
Definition gp_io.h:23
gp_pixmap
A pixmap buffer.
Definition gp_pixmap.h:33
gp_progress_cb
Progress callback.
Definition gp_progress_callback.h:28
Generated by doxygen 1.12.0