]> mj.ucw.cz Git - libucw.git/blob - images/io-main.c
much faster downscaling of JPEGs
[libucw.git] / images / io-main.c
1 /*
2  *      Image Library -- Image compression/decompression interface
3  *
4  *      (c) 2006 Pavel Charvat <pchar@ucw.cz>
5  *
6  *      This software may be freely distributed and used according to the terms
7  *      of the GNU Lesser General Public License.
8  */
9
10 #undef LOCAL_DEBUG
11
12 #include "lib/lib.h"
13 #include "images/images.h"
14 #include "images/io-main.h"
15 #include <string.h>
16
17 void
18 image_io_init(struct image_thread *it, struct image_io *io)
19 {
20   DBG("image_io_init()");
21   bzero(io, sizeof(*io));
22   io->thread = it;
23   io->internal_pool = mp_new(1024);
24 }
25
26 static inline void
27 image_io_read_cancel(struct image_io *io)
28 {
29   if (io->read_cancel)
30     {
31       io->read_cancel(io);
32       io->read_cancel = NULL;
33     }
34 }
35
36 static inline void
37 image_io_image_destroy(struct image_io *io)
38 {
39   if (io->image_destroy)
40     {
41       image_destroy(io->image);
42       io->image_destroy = 0;
43       io->image = NULL;
44     }
45 }
46
47 void
48 image_io_cleanup(struct image_io *io)
49 {
50   DBG("image_io_cleanup()");
51   image_io_read_cancel(io);
52   image_io_image_destroy(io);
53   mp_delete(io->internal_pool);
54 }
55
56 void
57 image_io_reset(struct image_io *io)
58 {
59   DBG("image_io_reset()");
60   image_io_read_cancel(io);
61   image_io_image_destroy(io);
62   struct mempool *pool = io->internal_pool;
63   mp_flush(pool);
64   bzero(io, sizeof(*io));
65   io->internal_pool = pool;
66 }
67
68 int
69 image_io_read_header(struct image_io *io)
70 {
71   DBG("image_io_read_header()");
72   image_io_read_cancel(io);
73   image_io_image_destroy(io);
74   switch (io->format) {
75     case IMAGE_FORMAT_JPEG:
76 #if defined(CONFIG_IMAGES_LIBJPEG)
77       return libjpeg_read_header(io);
78 #elif defined(CONFIG_IMAGES_LIBMAGICK)
79       return libmagick_read_header(io);
80 #endif
81       break;
82
83     case IMAGE_FORMAT_PNG:
84 #if defined(CONFIG_IMAGES_LIBPNG)
85       return libpng_read_header(io);
86 #elif defined(CONFIG_IMAGES_LIBMAGICK)
87       return libmagick_read_header(io);
88 #endif
89       break;
90
91     case IMAGE_FORMAT_GIF:
92 #if defined(CONFIG_IMAGES_LIBUNGIF) || defined(CONFIG_IMAGES_LIBGIF)
93       return libungif_read_header(io);
94 #elif defined(CONFIG_IMAGES_LIBMAGICK)
95       return libmagick_read_header(io);
96 #endif
97       break;
98
99     case IMAGE_FORMAT_UNDEFINED:
100       // FIXME: auto-detect
101       break;
102
103     default:
104       ASSERT(0);
105   }
106   image_thread_err(io->thread, IMAGE_ERR_INVALID_FILE_FORMAT, "Image format not supported.");
107   return 0;
108 }
109
110 struct image *
111 image_io_read_data(struct image_io *io, int ref)
112 {
113   DBG("image_io_read_data()");
114   ASSERT(io->read_cancel);
115   io->read_cancel = NULL;
116   int result;
117   switch (io->format) {
118     case IMAGE_FORMAT_JPEG:
119 #if defined(CONFIG_IMAGES_LIBJPEG)
120       result = libjpeg_read_data(io);
121 #elif defined(CONFIG_IMAGES_LIBMAGICK)
122       result = libmagick_read_data(io);
123 #else
124       ASSERT(0);
125 #endif
126       break;
127
128     case IMAGE_FORMAT_PNG:
129 #if defined(CONFIG_IMAGES_LIBPNG)
130       result = libpng_read_data(io);
131 #elif defined(CONFIG_IMAGES_LIBMAGICK)
132       result = libmagick_read_data(io);
133 #else
134       ASSERT(0);
135 #endif
136       break;
137
138     case IMAGE_FORMAT_GIF:
139 #if defined(CONFIG_IMAGES_LIBUNGIF) || defined(CONFIG_IMAGES_LIBGIF)
140       result = libungif_read_data(io);
141 #elif defined(CONFIG_IMAGES_LIBMAGICK)
142       result = libmagick_read_data(io);
143 #else
144       ASSERT(0);
145 #endif
146       break;
147
148     default:
149       ASSERT(0);
150   }
151   if (result)
152     {
153       if (ref)
154         io->image_destroy = 0;
155       return io->image;
156     }
157   else
158     return NULL;
159 }
160
161 struct image *
162 image_io_read(struct image_io *io, int ref)
163 {
164   if (!image_io_read_header(io))
165     return NULL;
166   return image_io_read_data(io, ref);
167 }
168
169 int
170 image_io_write(struct image_io *io)
171 {
172   DBG("image_io_write()");
173   image_io_read_cancel(io);
174   switch (io->format) {
175     case IMAGE_FORMAT_JPEG:
176 #if defined(CONFIG_IMAGES_LIBJPEG)
177       return libjpeg_write(io);
178 #elif defined(CONFIG_IMAGES_LIBMAGICK)
179       return libmagick_write(io);
180 #endif
181       break;
182
183     case IMAGE_FORMAT_PNG:
184 #if defined(CONFIG_IMAGES_LIBPNG)
185       return libpng_write(io);
186 #elif defined(CONFIG_IMAGES_LIBMAGICK)
187       return libmagick_write(io);
188 #endif
189       break;
190
191     case IMAGE_FORMAT_GIF:
192 #if defined(CONFIG_IMAGES_LIBMAGICK)
193       return libmagick_write(io);
194 #endif
195       break;
196
197     default:
198       break;
199   }
200   image_thread_err(io->thread, IMAGE_ERR_INVALID_FILE_FORMAT, "Image format not supported.");
201   return 0;
202 }
203
204 byte *
205 image_format_to_extension(enum image_format format)
206 {
207   switch (format)
208     {
209       case IMAGE_FORMAT_JPEG:
210         return "jpg";
211       case IMAGE_FORMAT_PNG:
212         return "png";
213       case IMAGE_FORMAT_GIF:
214         return "gif";
215       default:
216         return NULL;
217     }
218 }
219
220 enum image_format
221 image_extension_to_format(byte *extension)
222 {
223   if (!strcasecmp(extension, "jpg"))
224     return IMAGE_FORMAT_JPEG;
225   if (!strcasecmp(extension, "jpeg"))
226     return IMAGE_FORMAT_JPEG;
227   if (!strcasecmp(extension, "png"))
228     return IMAGE_FORMAT_PNG;
229   if (!strcasecmp(extension, "gif"))
230     return IMAGE_FORMAT_GIF;
231   return IMAGE_FORMAT_UNDEFINED;
232 }
233
234 enum image_format
235 image_file_name_to_format(byte *file_name)
236 {
237   byte *extension = strrchr(file_name, '.');
238   return extension ? image_extension_to_format(extension + 1) : IMAGE_FORMAT_UNDEFINED;
239 }
240
241 struct image *
242 image_io_read_data_prepare(struct image_io_read_data_internals *rdi, struct image_io *io, uns cols, uns rows, uns flags)
243 {
244   DBG("image_io_read_data_prepare()");
245   if (rdi->need_transformations = io->cols != cols || io->rows != rows || io->flags != flags)
246     {
247       rdi->need_destroy = 1;
248       return rdi->image = image_new(io->thread, cols, rows, flags & IMAGE_IO_IMAGE_FLAGS, NULL);
249     }
250   else
251     {
252       rdi->need_destroy = !io->pool;
253       return rdi->image = image_new(io->thread, io->cols, io->rows, io->flags & IMAGE_IO_IMAGE_FLAGS, io->pool);
254     }
255 }
256
257 int
258 image_io_read_data_finish(struct image_io_read_data_internals *rdi, struct image_io *io)
259 {
260   DBG("image_io_read_data_finish()");
261   if (rdi->need_transformations)
262     {
263       /* Scale the image */
264       if (io->cols != rdi->image->cols || io->rows != rdi->image->rows)
265         {
266           DBG("Scaling image");
267           rdi->need_destroy = rdi->need_transformations || !io->pool;
268           struct image *img = image_new(io->thread, io->cols, io->rows, rdi->image->flags, rdi->need_transformations ? NULL : io->pool);
269           if (unlikely(!img))
270             {
271               image_destroy(rdi->image);
272               return 0;
273             }
274           if (unlikely(!image_scale(io->thread, img, rdi->image)))
275             {
276               image_destroy(rdi->image);
277               if (rdi->need_destroy)
278                 image_destroy(img);
279               return 0;
280             }
281           rdi->image = img;
282         }
283
284       /* Merge with background */
285       if ((io->flags ^ rdi->image->flags) & IMAGE_ALPHA)
286         {
287           DBG("Aplying background");
288           rdi->need_destroy = rdi->need_transformations || !io->pool;
289           struct image *img = image_new(io->thread, io->cols, io->rows, io->flags, rdi->need_transformations ? NULL : io->pool);
290           if (unlikely(!img))
291             {
292               image_destroy(rdi->image);
293               return 0;
294             }
295           if (unlikely(!image_apply_background(io->thread, img, rdi->image, &io->background_color)))
296             {
297               image_destroy(rdi->image);
298               if (rdi->need_destroy)
299                 image_destroy(img);
300               return 0;
301             }
302           rdi->image = img;
303         }
304     }
305
306   /* Success */
307   io->image = rdi->image;
308   io->image_destroy = rdi->need_destroy;
309   return 1;
310 }
311
312 void
313 image_io_read_data_break(struct image_io_read_data_internals *rdi, struct image_io *io UNUSED)
314 {
315   DBG("image_io_read_data_break()");
316   if (rdi->need_destroy)
317     image_destroy(rdi->image);
318 }