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 2024 12 15 16:57:03 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 ico ***/
253
254extern const gp_loader gp_ico;
255
256int gp_match_ico(const void *buf);
257
258int gp_read_ico_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
259 gp_progress_cb *callback);
260
261static inline gp_pixmap *gp_load_ico(const char *src_path,
262 gp_progress_cb *callback)
263{
264 return gp_loader_load_image(&gp_ico, src_path, callback);
265}
266
267static inline gp_pixmap *gp_read_ico(gp_io *io, gp_progress_cb *callback)
268{
269 return gp_loader_read_image(&gp_ico, io, callback);
270}
271/*** Function prototypes for webp ***/
272
273extern const gp_loader gp_webp;
274
275int gp_match_webp(const void *buf);
276
277int gp_read_webp_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
278 gp_progress_cb *callback);
279
280static inline gp_pixmap *gp_load_webp(const char *src_path,
281 gp_progress_cb *callback)
282{
283 return gp_loader_load_image(&gp_webp, src_path, callback);
284}
285
286static inline gp_pixmap *gp_read_webp(gp_io *io, gp_progress_cb *callback)
287{
288 return gp_loader_read_image(&gp_webp, io, callback);
289}
290/*** Function prototypes for jp2 ***/
291
292extern const gp_loader gp_jp2;
293
294int gp_match_jp2(const void *buf);
295
296int gp_read_jp2_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
297 gp_progress_cb *callback);
298
299static inline gp_pixmap *gp_load_jp2(const char *src_path,
300 gp_progress_cb *callback)
301{
302 return gp_loader_load_image(&gp_jp2, src_path, callback);
303}
304
305static inline gp_pixmap *gp_read_jp2(gp_io *io, gp_progress_cb *callback)
306{
307 return gp_loader_read_image(&gp_jp2, io, callback);
308}
309/*** Function prototypes for pcx ***/
310
311extern const gp_loader gp_pcx;
312
313int gp_match_pcx(const void *buf);
314
315int gp_read_pcx_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
316 gp_progress_cb *callback);
317
318static inline gp_pixmap *gp_load_pcx(const char *src_path,
319 gp_progress_cb *callback)
320{
321 return gp_loader_load_image(&gp_pcx, src_path, callback);
322}
323
324static inline gp_pixmap *gp_read_pcx(gp_io *io, gp_progress_cb *callback)
325{
326 return gp_loader_read_image(&gp_pcx, io, callback);
327}
328/*** Function prototypes for gif ***/
329
330extern const gp_loader gp_gif;
331
332int gp_match_gif(const void *buf);
333
334int gp_read_gif_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
335 gp_progress_cb *callback);
336
337static inline gp_pixmap *gp_load_gif(const char *src_path,
338 gp_progress_cb *callback)
339{
340 return gp_loader_load_image(&gp_gif, src_path, callback);
341}
342
343static inline gp_pixmap *gp_read_gif(gp_io *io, gp_progress_cb *callback)
344{
345 return gp_loader_read_image(&gp_gif, io, callback);
346}
347/*** Function prototypes for psp ***/
348
349extern const gp_loader gp_psp;
350
351int gp_match_psp(const void *buf);
352
353int gp_read_psp_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
354 gp_progress_cb *callback);
355
356static inline gp_pixmap *gp_load_psp(const char *src_path,
357 gp_progress_cb *callback)
358{
359 return gp_loader_load_image(&gp_psp, src_path, callback);
360}
361
362static inline gp_pixmap *gp_read_psp(gp_io *io, gp_progress_cb *callback)
363{
364 return gp_loader_read_image(&gp_psp, io, callback);
365}
366/*** Function prototypes for psd ***/
367
368extern const gp_loader gp_psd;
369
370int gp_match_psd(const void *buf);
371
372int gp_read_psd_ex(gp_io *io, gp_pixmap **img, gp_storage *storage,
373 gp_progress_cb *callback);
374
375static inline gp_pixmap *gp_load_psd(const char *src_path,
376 gp_progress_cb *callback)
377{
378 return gp_loader_load_image(&gp_psd, src_path, callback);
379}
380
381static inline gp_pixmap *gp_read_psd(gp_io *io, gp_progress_cb *callback)
382{
383 return gp_loader_read_image(&gp_psd, io, callback);
384}
385#endif /* GP_LOADERS_GEN_H */
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.9.8