GPencil: Fix unreported problem when use Onion Skin in several windows
[blender.git] / source / blender / imbuf / intern / jpeg.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup imbuf
22  */
23
24 /* This little block needed for linking to Blender... */
25 #include <stdio.h>
26 #include <setjmp.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_utildefines.h"
31 #include "BLI_string.h"
32 #include "BLI_fileops.h"
33
34 #include "BKE_idprop.h"
35
36 #include "imbuf.h"
37 #include "IMB_imbuf_types.h"
38 #include "IMB_imbuf.h"
39 #include "IMB_metadata.h"
40 #include "IMB_filetype.h"
41 #include "jpeglib.h"
42 #include "jerror.h"
43
44 #include "IMB_colormanagement.h"
45 #include "IMB_colormanagement_intern.h"
46
47 /* the types are from the jpeg lib */
48 static void jpeg_error(j_common_ptr cinfo) ATTR_NORETURN;
49 static void init_source(j_decompress_ptr cinfo);
50 static boolean fill_input_buffer(j_decompress_ptr cinfo);
51 static void skip_input_data(j_decompress_ptr cinfo, long num_bytes);
52 static void term_source(j_decompress_ptr cinfo);
53 static void memory_source(j_decompress_ptr cinfo, const unsigned char *buffer, size_t size);
54 static boolean handle_app1(j_decompress_ptr cinfo);
55 static ImBuf *ibJpegImageFromCinfo(struct jpeg_decompress_struct *cinfo, int flags);
56
57 static const uchar jpeg_default_quality = 75;
58 static uchar ibuf_quality;
59
60 int imb_is_a_jpeg(const unsigned char *mem)
61 {
62   if ((mem[0] == 0xFF) && (mem[1] == 0xD8)) {
63     return 1;
64   }
65   return 0;
66 }
67
68 /*----------------------------------------------------------
69  * JPG ERROR HANDLING
70  *---------------------------------------------------------- */
71
72 typedef struct my_error_mgr {
73   struct jpeg_error_mgr pub; /* "public" fields */
74
75   jmp_buf setjmp_buffer; /* for return to caller */
76 } my_error_mgr;
77
78 typedef my_error_mgr *my_error_ptr;
79
80 static void jpeg_error(j_common_ptr cinfo)
81 {
82   my_error_ptr err = (my_error_ptr)cinfo->err;
83
84   /* Always display the message */
85   (*cinfo->err->output_message)(cinfo);
86
87   /* Let the memory manager delete any temp files before we die */
88   jpeg_destroy(cinfo);
89
90   /* return control to the setjmp point */
91   longjmp(err->setjmp_buffer, 1);
92 }
93
94 /*----------------------------------------------------------
95  * INPUT HANDLER FROM MEMORY
96  *---------------------------------------------------------- */
97
98 #if 0
99 typedef struct {
100   unsigned char *buffer;
101   int filled;
102 } buffer_struct;
103 #endif
104
105 typedef struct {
106   struct jpeg_source_mgr pub; /* public fields */
107
108   const unsigned char *buffer;
109   int size;
110   JOCTET terminal[2];
111 } my_source_mgr;
112
113 typedef my_source_mgr *my_src_ptr;
114
115 static void init_source(j_decompress_ptr cinfo)
116 {
117   (void)cinfo; /* unused */
118 }
119
120 static boolean fill_input_buffer(j_decompress_ptr cinfo)
121 {
122   my_src_ptr src = (my_src_ptr)cinfo->src;
123
124   /* Since we have given all we have got already
125    * we simply fake an end of file
126    */
127
128   src->pub.next_input_byte = src->terminal;
129   src->pub.bytes_in_buffer = 2;
130   src->terminal[0] = (JOCTET)0xFF;
131   src->terminal[1] = (JOCTET)JPEG_EOI;
132
133   return true;
134 }
135
136 static void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
137 {
138   my_src_ptr src = (my_src_ptr)cinfo->src;
139
140   if (num_bytes > 0) {
141     /* prevent skipping over file end */
142     size_t skip_size = (size_t)num_bytes <= src->pub.bytes_in_buffer ? num_bytes :
143                                                                        src->pub.bytes_in_buffer;
144
145     src->pub.next_input_byte = src->pub.next_input_byte + skip_size;
146     src->pub.bytes_in_buffer = src->pub.bytes_in_buffer - skip_size;
147   }
148 }
149
150 static void term_source(j_decompress_ptr cinfo)
151 {
152   (void)cinfo; /* unused */
153 }
154
155 static void memory_source(j_decompress_ptr cinfo, const unsigned char *buffer, size_t size)
156 {
157   my_src_ptr src;
158
159   if (cinfo->src == NULL) { /* first time for this JPEG object? */
160     cinfo->src = (struct jpeg_source_mgr *)(*cinfo->mem->alloc_small)(
161         (j_common_ptr)cinfo, JPOOL_PERMANENT, sizeof(my_source_mgr));
162   }
163
164   src = (my_src_ptr)cinfo->src;
165   src->pub.init_source = init_source;
166   src->pub.fill_input_buffer = fill_input_buffer;
167   src->pub.skip_input_data = skip_input_data;
168   src->pub.resync_to_restart = jpeg_resync_to_restart;
169   src->pub.term_source = term_source;
170
171   src->pub.bytes_in_buffer = size;
172   src->pub.next_input_byte = buffer;
173
174   src->buffer = buffer;
175   src->size = size;
176 }
177
178 #define MAKESTMT(stuff) \
179   do { \
180     stuff \
181   } while (0)
182
183 #define INPUT_VARS(cinfo) \
184   struct jpeg_source_mgr *datasrc = (cinfo)->src; \
185   const JOCTET *next_input_byte = datasrc->next_input_byte; \
186   size_t bytes_in_buffer = datasrc->bytes_in_buffer
187
188 /* Unload the local copies --- do this only at a restart boundary */
189 #define INPUT_SYNC(cinfo) \
190   (datasrc->next_input_byte = next_input_byte, datasrc->bytes_in_buffer = bytes_in_buffer)
191
192 /* Reload the local copies --- seldom used except in MAKE_BYTE_AVAIL */
193 #define INPUT_RELOAD(cinfo) \
194   (next_input_byte = datasrc->next_input_byte, bytes_in_buffer = datasrc->bytes_in_buffer)
195
196 /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
197  * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
198  * but we must reload the local copies after a successful fill.
199  */
200 #define MAKE_BYTE_AVAIL(cinfo, action) \
201   if (bytes_in_buffer == 0) { \
202     if (!(*datasrc->fill_input_buffer)(cinfo)) { \
203       action; \
204     } \
205     INPUT_RELOAD(cinfo); \
206   } \
207   (void)0
208
209 /* Read a byte into variable V.
210  * If must suspend, take the specified action (typically "return false").
211  */
212 #define INPUT_BYTE(cinfo, V, action) \
213   MAKESTMT(MAKE_BYTE_AVAIL(cinfo, action); bytes_in_buffer--; V = GETJOCTET(*next_input_byte++);)
214
215 /* As above, but read two bytes interpreted as an unsigned 16-bit integer.
216  * V should be declared unsigned int or perhaps INT32.
217  */
218 #define INPUT_2BYTES(cinfo, V, action) \
219   MAKESTMT(MAKE_BYTE_AVAIL(cinfo, action); bytes_in_buffer--; \
220            V = ((unsigned int)GETJOCTET(*next_input_byte++)) << 8; \
221            MAKE_BYTE_AVAIL(cinfo, action); \
222            bytes_in_buffer--; \
223            V += GETJOCTET(*next_input_byte++);)
224
225 struct NeoGeo_Word {
226   uchar pad1;
227   uchar pad2;
228   uchar pad3;
229   uchar quality;
230 };
231 BLI_STATIC_ASSERT(sizeof(struct NeoGeo_Word) == 4, "Must be 4 bytes");
232
233 static boolean handle_app1(j_decompress_ptr cinfo)
234 {
235   INT32 length; /* initialized by the macro */
236   INT32 i;
237   char neogeo[128];
238
239   INPUT_VARS(cinfo);
240
241   INPUT_2BYTES(cinfo, length, return false);
242   length -= 2;
243
244   if (length < 16) {
245     for (i = 0; i < length; i++) {
246       INPUT_BYTE(cinfo, neogeo[i], return false);
247     }
248     length = 0;
249     if (STREQLEN(neogeo, "NeoGeo", 6)) {
250       struct NeoGeo_Word *neogeo_word = (struct NeoGeo_Word *)(neogeo + 6);
251       ibuf_quality = neogeo_word->quality;
252     }
253   }
254   INPUT_SYNC(cinfo); /* do before skip_input_data */
255   if (length > 0) {
256     (*cinfo->src->skip_input_data)(cinfo, length);
257   }
258   return true;
259 }
260
261 static ImBuf *ibJpegImageFromCinfo(struct jpeg_decompress_struct *cinfo, int flags)
262 {
263   JSAMPARRAY row_pointer;
264   JSAMPLE *buffer = NULL;
265   int row_stride;
266   int x, y, depth, r, g, b, k;
267   struct ImBuf *ibuf = NULL;
268   uchar *rect;
269   jpeg_saved_marker_ptr marker;
270   char *str, *key, *value;
271
272   /* install own app1 handler */
273   ibuf_quality = jpeg_default_quality;
274   jpeg_set_marker_processor(cinfo, 0xe1, handle_app1);
275   cinfo->dct_method = JDCT_FLOAT;
276   jpeg_save_markers(cinfo, JPEG_COM, 0xffff);
277
278   if (jpeg_read_header(cinfo, false) == JPEG_HEADER_OK) {
279     x = cinfo->image_width;
280     y = cinfo->image_height;
281     depth = cinfo->num_components;
282
283     if (cinfo->jpeg_color_space == JCS_YCCK) {
284       cinfo->out_color_space = JCS_CMYK;
285     }
286
287     jpeg_start_decompress(cinfo);
288
289     if (flags & IB_test) {
290       jpeg_abort_decompress(cinfo);
291       ibuf = IMB_allocImBuf(x, y, 8 * depth, 0);
292     }
293     else if ((ibuf = IMB_allocImBuf(x, y, 8 * depth, IB_rect)) == NULL) {
294       jpeg_abort_decompress(cinfo);
295     }
296     else {
297       row_stride = cinfo->output_width * depth;
298
299       row_pointer = (*cinfo->mem->alloc_sarray)((j_common_ptr)cinfo, JPOOL_IMAGE, row_stride, 1);
300
301       for (y = ibuf->y - 1; y >= 0; y--) {
302         jpeg_read_scanlines(cinfo, row_pointer, 1);
303         rect = (uchar *)(ibuf->rect + y * ibuf->x);
304         buffer = row_pointer[0];
305
306         switch (depth) {
307           case 1:
308             for (x = ibuf->x; x > 0; x--) {
309               rect[3] = 255;
310               rect[0] = rect[1] = rect[2] = *buffer++;
311               rect += 4;
312             }
313             break;
314           case 3:
315             for (x = ibuf->x; x > 0; x--) {
316               rect[3] = 255;
317               rect[0] = *buffer++;
318               rect[1] = *buffer++;
319               rect[2] = *buffer++;
320               rect += 4;
321             }
322             break;
323           case 4:
324             for (x = ibuf->x; x > 0; x--) {
325               r = *buffer++;
326               g = *buffer++;
327               b = *buffer++;
328               k = *buffer++;
329
330               r = (r * k) / 255;
331               g = (g * k) / 255;
332               b = (b * k) / 255;
333
334               rect[3] = 255;
335               rect[2] = b;
336               rect[1] = g;
337               rect[0] = r;
338               rect += 4;
339             }
340             break;
341         }
342       }
343
344       marker = cinfo->marker_list;
345       while (marker) {
346         if (marker->marker != JPEG_COM) {
347           goto next_stamp_marker;
348         }
349
350         /*
351          * JPEG marker strings are not null-terminated,
352          * create a null-terminated copy before going further
353          */
354         str = BLI_strdupn((char *)marker->data, marker->data_length);
355
356         /*
357          * Because JPEG format don't support the
358          * pair "key/value" like PNG, we store the
359          * stamp-info in a single "encode" string:
360          * "Blender:key:value"
361          *
362          * That is why we need split it to the
363          * common key/value here.
364          */
365         if (!STREQLEN(str, "Blender", 7)) {
366           /*
367            * Maybe the file have text that
368            * we don't know "what it's", in that
369            * case we keep the text (with a
370            * key "None").
371            * This is only for don't "lose"
372            * the information when we write
373            * it back to disk.
374            */
375           IMB_metadata_ensure(&ibuf->metadata);
376           IMB_metadata_set_field(ibuf->metadata, "None", str);
377           ibuf->flags |= IB_metadata;
378           MEM_freeN(str);
379           goto next_stamp_marker;
380         }
381
382         key = strchr(str, ':');
383         /*
384          * A little paranoid, but the file maybe
385          * is broken... and a "extra" check is better
386          * then segfault ;)
387          */
388         if (!key) {
389           MEM_freeN(str);
390           goto next_stamp_marker;
391         }
392
393         key++;
394         value = strchr(key, ':');
395         if (!value) {
396           MEM_freeN(str);
397           goto next_stamp_marker;
398         }
399
400         *value = '\0'; /* need finish the key string */
401         value++;
402         IMB_metadata_ensure(&ibuf->metadata);
403         IMB_metadata_set_field(ibuf->metadata, key, value);
404         ibuf->flags |= IB_metadata;
405         MEM_freeN(str);
406       next_stamp_marker:
407         marker = marker->next;
408       }
409
410       jpeg_finish_decompress(cinfo);
411     }
412
413     jpeg_destroy((j_common_ptr)cinfo);
414     if (ibuf) {
415       ibuf->ftype = IMB_FTYPE_JPG;
416       ibuf->foptions.quality = MIN2(ibuf_quality, 100);
417     }
418   }
419
420   return (ibuf);
421 }
422
423 ImBuf *imb_load_jpeg(const unsigned char *buffer,
424                      size_t size,
425                      int flags,
426                      char colorspace[IM_MAX_SPACE])
427 {
428   struct jpeg_decompress_struct _cinfo, *cinfo = &_cinfo;
429   struct my_error_mgr jerr;
430   ImBuf *ibuf;
431
432   if (!imb_is_a_jpeg(buffer)) {
433     return NULL;
434   }
435
436   colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);
437
438   cinfo->err = jpeg_std_error(&jerr.pub);
439   jerr.pub.error_exit = jpeg_error;
440
441   /* Establish the setjmp return context for my_error_exit to use. */
442   if (setjmp(jerr.setjmp_buffer)) {
443     /* If we get here, the JPEG code has signaled an error.
444      * We need to clean up the JPEG object, close the input file, and return.
445      */
446     jpeg_destroy_decompress(cinfo);
447     return NULL;
448   }
449
450   jpeg_create_decompress(cinfo);
451   memory_source(cinfo, buffer, size);
452
453   ibuf = ibJpegImageFromCinfo(cinfo, flags);
454
455   return (ibuf);
456 }
457
458 static void write_jpeg(struct jpeg_compress_struct *cinfo, struct ImBuf *ibuf)
459 {
460   JSAMPLE *buffer = NULL;
461   JSAMPROW row_pointer[1];
462   uchar *rect;
463   int x, y;
464   char neogeo[128];
465   struct NeoGeo_Word *neogeo_word;
466
467   jpeg_start_compress(cinfo, true);
468
469   strcpy(neogeo, "NeoGeo");
470   neogeo_word = (struct NeoGeo_Word *)(neogeo + 6);
471   memset(neogeo_word, 0, sizeof(*neogeo_word));
472   neogeo_word->quality = ibuf->foptions.quality;
473   jpeg_write_marker(cinfo, 0xe1, (JOCTET *)neogeo, 10);
474   if (ibuf->metadata) {
475     IDProperty *prop;
476     /* Static storage array for the short metadata. */
477     char static_text[1024];
478     const int static_text_size = ARRAY_SIZE(static_text);
479     for (prop = ibuf->metadata->data.group.first; prop; prop = prop->next) {
480       if (prop->type == IDP_STRING) {
481         int text_len;
482         if (!strcmp(prop->name, "None")) {
483           jpeg_write_marker(cinfo, JPEG_COM, (JOCTET *)IDP_String(prop), prop->len + 1);
484         }
485
486         char *text = static_text;
487         int text_size = static_text_size;
488         /* 7 is for Blender, 2 colon separators, length of property
489          * name and property value, followed by the NULL-terminator. */
490         const int text_length_required = 7 + 2 + strlen(prop->name) + strlen(IDP_String(prop)) + 1;
491         if (text_length_required <= static_text_size) {
492           text = MEM_mallocN(text_length_required, "jpeg metadata field");
493           text_size = text_length_required;
494         }
495
496         /*
497          * The JPEG format don't support a pair "key/value"
498          * like PNG, so we "encode" the stamp in a
499          * single string:
500          * "Blender:key:value"
501          *
502          * The first "Blender" is a simple identify to help
503          * in the read process.
504          */
505         text_len = BLI_snprintf(text, text_size, "Blender:%s:%s", prop->name, IDP_String(prop));
506         jpeg_write_marker(cinfo, JPEG_COM, (JOCTET *)text, text_len + 1);
507
508         /* TODO(sergey): Ideally we will try to re-use allocation as
509          * much as possible. In practice, such long fields don't happen
510          * often. */
511         if (text != static_text) {
512           MEM_freeN(text);
513         }
514       }
515     }
516   }
517
518   row_pointer[0] = MEM_mallocN(sizeof(JSAMPLE) * cinfo->input_components * cinfo->image_width,
519                                "jpeg row_pointer");
520
521   for (y = ibuf->y - 1; y >= 0; y--) {
522     rect = (uchar *)(ibuf->rect + y * ibuf->x);
523     buffer = row_pointer[0];
524
525     switch (cinfo->in_color_space) {
526       case JCS_RGB:
527         for (x = 0; x < ibuf->x; x++) {
528           *buffer++ = rect[0];
529           *buffer++ = rect[1];
530           *buffer++ = rect[2];
531           rect += 4;
532         }
533         break;
534       case JCS_GRAYSCALE:
535         for (x = 0; x < ibuf->x; x++) {
536           *buffer++ = rect[0];
537           rect += 4;
538         }
539         break;
540       case JCS_UNKNOWN:
541         memcpy(buffer, rect, 4 * ibuf->x);
542         break;
543       /* default was missing... intentional ? */
544       default:
545         /* do nothing */
546         break;
547     }
548
549     jpeg_write_scanlines(cinfo, row_pointer, 1);
550   }
551
552   jpeg_finish_compress(cinfo);
553   MEM_freeN(row_pointer[0]);
554 }
555
556 static int init_jpeg(FILE *outfile, struct jpeg_compress_struct *cinfo, struct ImBuf *ibuf)
557 {
558   int quality;
559
560   quality = ibuf->foptions.quality;
561   if (quality <= 0) {
562     quality = jpeg_default_quality;
563   }
564   if (quality > 100) {
565     quality = 100;
566   }
567
568   jpeg_create_compress(cinfo);
569   jpeg_stdio_dest(cinfo, outfile);
570
571   cinfo->image_width = ibuf->x;
572   cinfo->image_height = ibuf->y;
573
574   cinfo->in_color_space = JCS_RGB;
575   if (ibuf->planes == 8) {
576     cinfo->in_color_space = JCS_GRAYSCALE;
577   }
578 #if 0
579   /* just write RGBA as RGB,
580    * unsupported feature only confuses other s/w */
581
582   if (ibuf->planes == 32) {
583     cinfo->in_color_space = JCS_UNKNOWN;
584   }
585 #endif
586   switch (cinfo->in_color_space) {
587     case JCS_RGB:
588       cinfo->input_components = 3;
589       break;
590     case JCS_GRAYSCALE:
591       cinfo->input_components = 1;
592       break;
593     case JCS_UNKNOWN:
594       cinfo->input_components = 4;
595       break;
596     /* default was missing... intentional ? */
597     default:
598       /* do nothing */
599       break;
600   }
601   jpeg_set_defaults(cinfo);
602
603   /* own settings */
604
605   cinfo->dct_method = JDCT_FLOAT;
606   jpeg_set_quality(cinfo, quality, true);
607
608   return (0);
609 }
610
611 static int save_stdjpeg(const char *name, struct ImBuf *ibuf)
612 {
613   FILE *outfile;
614   struct jpeg_compress_struct _cinfo, *cinfo = &_cinfo;
615   struct my_error_mgr jerr;
616
617   if ((outfile = BLI_fopen(name, "wb")) == NULL) {
618     return 0;
619   }
620
621   cinfo->err = jpeg_std_error(&jerr.pub);
622   jerr.pub.error_exit = jpeg_error;
623
624   /* Establish the setjmp return context for jpeg_error to use. */
625   if (setjmp(jerr.setjmp_buffer)) {
626     /* If we get here, the JPEG code has signaled an error.
627      * We need to clean up the JPEG object, close the input file, and return.
628      */
629     jpeg_destroy_compress(cinfo);
630     fclose(outfile);
631     remove(name);
632     return 0;
633   }
634
635   init_jpeg(outfile, cinfo, ibuf);
636
637   write_jpeg(cinfo, ibuf);
638
639   fclose(outfile);
640   jpeg_destroy_compress(cinfo);
641
642   return 1;
643 }
644
645 int imb_savejpeg(struct ImBuf *ibuf, const char *name, int flags)
646 {
647
648   ibuf->flags = flags;
649   return save_stdjpeg(name, ibuf);
650 }