Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / image.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 bke
22  */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <fcntl.h>
27 #include <math.h>
28 #ifndef WIN32
29 #  include <unistd.h>
30 #else
31 #  include <io.h>
32 #endif
33
34 #include <time.h>
35
36 #include "CLG_log.h"
37
38 #include "MEM_guardedalloc.h"
39
40 #include "IMB_colormanagement.h"
41 #include "IMB_imbuf_types.h"
42 #include "IMB_imbuf.h"
43 #include "IMB_moviecache.h"
44 #include "IMB_metadata.h"
45
46 #ifdef WITH_OPENEXR
47 #  include "intern/openexr/openexr_multi.h"
48 #endif
49
50 #include "DNA_packedFile_types.h"
51 #include "DNA_scene_types.h"
52 #include "DNA_object_types.h"
53 #include "DNA_camera_types.h"
54 #include "DNA_sequence_types.h"
55 #include "DNA_brush_types.h"
56 #include "DNA_mesh_types.h"
57 #include "DNA_meshdata_types.h"
58
59 #include "BLI_blenlib.h"
60 #include "BLI_math_vector.h"
61 #include "BLI_mempool.h"
62 #include "BLI_system.h"
63 #include "BLI_threads.h"
64 #include "BLI_timecode.h" /* for stamp timecode format */
65 #include "BLI_utildefines.h"
66
67 #include "BKE_colortools.h"
68 #include "BKE_global.h"
69 #include "BKE_icons.h"
70 #include "BKE_image.h"
71 #include "BKE_library.h"
72 #include "BKE_main.h"
73 #include "BKE_packedFile.h"
74 #include "BKE_report.h"
75 #include "BKE_scene.h"
76 #include "BKE_node.h"
77 #include "BKE_sequencer.h" /* seq_foreground_frame_get() */
78 #include "BKE_workspace.h"
79
80 #include "BLF_api.h"
81
82 #include "PIL_time.h"
83
84 #include "RE_pipeline.h"
85
86 #include "GPU_draw.h"
87
88 #include "BLI_sys_types.h"  // for intptr_t support
89
90 #include "DEG_depsgraph.h"
91 #include "DEG_depsgraph_query.h"
92
93 /* for image user iteration */
94 #include "DNA_node_types.h"
95 #include "DNA_space_types.h"
96 #include "DNA_screen_types.h"
97 #include "DNA_view3d_types.h"
98
99 static CLG_LogRef LOG = {"bke.image"};
100 static SpinLock image_spin;
101
102 /* prototypes */
103 static int image_num_files(struct Image *ima);
104 static ImBuf *image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock);
105 static void image_update_views_format(Image *ima, ImageUser *iuser);
106 static void image_add_view(Image *ima, const char *viewname, const char *filepath);
107
108 /* max int, to indicate we don't store sequences in ibuf */
109 #define IMA_NO_INDEX 0x7FEFEFEF
110
111 /* quick lookup: supports 1 million frames, thousand passes */
112 #define IMA_MAKE_INDEX(frame, index) (((frame) << 10) + (index))
113 #define IMA_INDEX_FRAME(index) ((index) >> 10)
114 #if 0
115 #  define IMA_INDEX_PASS(index) (index & ~1023)
116 #endif
117
118 /* ******** IMAGE CACHE ************* */
119
120 typedef struct ImageCacheKey {
121   int index;
122 } ImageCacheKey;
123
124 static unsigned int imagecache_hashhash(const void *key_v)
125 {
126   const ImageCacheKey *key = key_v;
127   return key->index;
128 }
129
130 static bool imagecache_hashcmp(const void *a_v, const void *b_v)
131 {
132   const ImageCacheKey *a = a_v;
133   const ImageCacheKey *b = b_v;
134
135   return (a->index != b->index);
136 }
137
138 static void imagecache_keydata(void *userkey, int *framenr, int *proxy, int *render_flags)
139 {
140   ImageCacheKey *key = userkey;
141
142   *framenr = IMA_INDEX_FRAME(key->index);
143   *proxy = IMB_PROXY_NONE;
144   *render_flags = 0;
145 }
146
147 static void imagecache_put(Image *image, int index, ImBuf *ibuf)
148 {
149   ImageCacheKey key;
150
151   if (image->cache == NULL) {
152     // char cache_name[64];
153     // SNPRINTF(cache_name, "Image Datablock %s", image->id.name);
154
155     image->cache = IMB_moviecache_create(
156         "Image Datablock Cache", sizeof(ImageCacheKey), imagecache_hashhash, imagecache_hashcmp);
157     IMB_moviecache_set_getdata_callback(image->cache, imagecache_keydata);
158   }
159
160   key.index = index;
161
162   IMB_moviecache_put(image->cache, &key, ibuf);
163 }
164
165 static struct ImBuf *imagecache_get(Image *image, int index)
166 {
167   if (image->cache) {
168     ImageCacheKey key;
169     key.index = index;
170     return IMB_moviecache_get(image->cache, &key);
171   }
172
173   return NULL;
174 }
175
176 void BKE_images_init(void)
177 {
178   BLI_spin_init(&image_spin);
179 }
180
181 void BKE_images_exit(void)
182 {
183   BLI_spin_end(&image_spin);
184 }
185
186 /* ***************** ALLOC & FREE, DATA MANAGING *************** */
187
188 static void image_free_cached_frames(Image *image)
189 {
190   if (image->cache) {
191     IMB_moviecache_free(image->cache);
192     image->cache = NULL;
193   }
194 }
195
196 static void image_free_packedfiles(Image *ima)
197 {
198   while (ima->packedfiles.last) {
199     ImagePackedFile *imapf = ima->packedfiles.last;
200     if (imapf->packedfile) {
201       freePackedFile(imapf->packedfile);
202     }
203     BLI_remlink(&ima->packedfiles, imapf);
204     MEM_freeN(imapf);
205   }
206 }
207
208 void BKE_image_free_packedfiles(Image *ima)
209 {
210   image_free_packedfiles(ima);
211 }
212
213 void BKE_image_free_views(Image *image)
214 {
215   BLI_freelistN(&image->views);
216 }
217
218 static void image_free_anims(Image *ima)
219 {
220   while (ima->anims.last) {
221     ImageAnim *ia = ima->anims.last;
222     if (ia->anim) {
223       IMB_free_anim(ia->anim);
224       ia->anim = NULL;
225     }
226     BLI_remlink(&ima->anims, ia);
227     MEM_freeN(ia);
228   }
229 }
230
231 /**
232  * Simply free the image data from memory,
233  * on display the image can load again (except for render buffers).
234  */
235 void BKE_image_free_buffers_ex(Image *ima, bool do_lock)
236 {
237   if (do_lock) {
238     BLI_spin_lock(&image_spin);
239   }
240   image_free_cached_frames(ima);
241
242   image_free_anims(ima);
243
244   if (ima->rr) {
245     RE_FreeRenderResult(ima->rr);
246     ima->rr = NULL;
247   }
248
249   if (!G.background) {
250     /* Background mode doesn't use opnegl,
251      * so we can avoid freeing GPU images and save some
252      * time by skipping mutex lock.
253      */
254     GPU_free_image(ima);
255   }
256
257   ima->ok = IMA_OK;
258
259   if (do_lock) {
260     BLI_spin_unlock(&image_spin);
261   }
262 }
263
264 void BKE_image_free_buffers(Image *ima)
265 {
266   BKE_image_free_buffers_ex(ima, false);
267 }
268
269 /** Free (or release) any data used by this image (does not free the image itself). */
270 void BKE_image_free(Image *ima)
271 {
272   /* Also frees animdata. */
273   BKE_image_free_buffers(ima);
274
275   image_free_packedfiles(ima);
276
277   LISTBASE_FOREACH (RenderSlot *, slot, &ima->renderslots) {
278     if (slot->render) {
279       RE_FreeRenderResult(slot->render);
280       slot->render = NULL;
281     }
282   }
283   BLI_freelistN(&ima->renderslots);
284
285   BKE_image_free_views(ima);
286   MEM_SAFE_FREE(ima->stereo3d_format);
287
288   BKE_icon_id_delete(&ima->id);
289   BKE_previewimg_free(&ima->preview);
290 }
291
292 /* only image block itself */
293 static void image_init(Image *ima, short source, short type)
294 {
295   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(ima, id));
296
297   ima->ok = IMA_OK;
298
299   ima->aspx = ima->aspy = 1.0;
300   ima->gen_x = 1024;
301   ima->gen_y = 1024;
302   ima->gen_type = IMA_GENTYPE_GRID;
303
304   ima->source = source;
305   ima->type = type;
306
307   if (source == IMA_SRC_VIEWER) {
308     ima->flag |= IMA_VIEW_AS_RENDER;
309   }
310
311   if (type == IMA_TYPE_R_RESULT) {
312     for (int i = 0; i < 8; i++) {
313       BKE_image_add_renderslot(ima, NULL);
314     }
315   }
316
317   BKE_color_managed_colorspace_settings_init(&ima->colorspace_settings);
318   ima->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Image Stereo Format");
319 }
320
321 void BKE_image_init(struct Image *image)
322 {
323   if (image) {
324     image_init(image, IMA_SRC_GENERATED, IMA_TYPE_UV_TEST);
325   }
326 }
327
328 static Image *image_alloc(Main *bmain, const char *name, short source, short type)
329 {
330   Image *ima;
331
332   ima = BKE_libblock_alloc(bmain, ID_IM, name, 0);
333   if (ima) {
334     image_init(ima, source, type);
335   }
336
337   return ima;
338 }
339
340 /* Get the ibuf from an image cache by it's index and frame.
341  * Local use here only.
342  *
343  * Returns referenced image buffer if it exists, callee is to
344  * call IMB_freeImBuf to de-reference the image buffer after
345  * it's done handling it.
346  */
347 static ImBuf *image_get_cached_ibuf_for_index_frame(Image *ima, int index, int frame)
348 {
349   if (index != IMA_NO_INDEX) {
350     index = IMA_MAKE_INDEX(frame, index);
351   }
352
353   return imagecache_get(ima, index);
354 }
355
356 /* no ima->ibuf anymore, but listbase */
357 static void image_assign_ibuf(Image *ima, ImBuf *ibuf, int index, int frame)
358 {
359   if (ibuf) {
360     if (index != IMA_NO_INDEX) {
361       index = IMA_MAKE_INDEX(frame, index);
362     }
363
364     imagecache_put(ima, index, ibuf);
365   }
366 }
367
368 static void copy_image_packedfiles(ListBase *lb_dst, const ListBase *lb_src)
369 {
370   const ImagePackedFile *imapf_src;
371
372   BLI_listbase_clear(lb_dst);
373   for (imapf_src = lb_src->first; imapf_src; imapf_src = imapf_src->next) {
374     ImagePackedFile *imapf_dst = MEM_mallocN(sizeof(ImagePackedFile), "Image Packed Files (copy)");
375     STRNCPY(imapf_dst->filepath, imapf_src->filepath);
376
377     if (imapf_src->packedfile) {
378       imapf_dst->packedfile = dupPackedFile(imapf_src->packedfile);
379     }
380
381     BLI_addtail(lb_dst, imapf_dst);
382   }
383 }
384
385 /**
386  * Only copy internal data of Image ID from source to already allocated/initialized destination.
387  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
388  *
389  * WARNING! This function will not handle ID user count!
390  *
391  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
392  */
393 void BKE_image_copy_data(Main *UNUSED(bmain), Image *ima_dst, const Image *ima_src, const int flag)
394 {
395   BKE_color_managed_colorspace_settings_copy(&ima_dst->colorspace_settings,
396                                              &ima_src->colorspace_settings);
397
398   copy_image_packedfiles(&ima_dst->packedfiles, &ima_src->packedfiles);
399
400   ima_dst->stereo3d_format = MEM_dupallocN(ima_src->stereo3d_format);
401   BLI_duplicatelist(&ima_dst->views, &ima_src->views);
402
403   /* Cleanup stuff that cannot be copied. */
404   ima_dst->cache = NULL;
405   ima_dst->rr = NULL;
406
407   BLI_duplicatelist(&ima_dst->renderslots, &ima_src->renderslots);
408   LISTBASE_FOREACH (RenderSlot *, slot, &ima_dst->renderslots) {
409     slot->render = NULL;
410   }
411
412   BLI_listbase_clear(&ima_dst->anims);
413
414   for (int i = 0; i < TEXTARGET_COUNT; i++) {
415     ima_dst->gputexture[i] = NULL;
416   }
417
418   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
419     BKE_previewimg_id_copy(&ima_dst->id, &ima_src->id);
420   }
421   else {
422     ima_dst->preview = NULL;
423   }
424 }
425
426 /* empty image block, of similar type and filename */
427 Image *BKE_image_copy(Main *bmain, const Image *ima)
428 {
429   Image *ima_copy;
430   BKE_id_copy(bmain, &ima->id, (ID **)&ima_copy);
431   return ima_copy;
432 }
433
434 void BKE_image_make_local(Main *bmain, Image *ima, const bool lib_local)
435 {
436   BKE_id_make_local_generic(bmain, &ima->id, true, lib_local);
437 }
438
439 void BKE_image_merge(Main *bmain, Image *dest, Image *source)
440 {
441   /* sanity check */
442   if (dest && source && dest != source) {
443     BLI_spin_lock(&image_spin);
444     if (source->cache != NULL) {
445       struct MovieCacheIter *iter;
446       iter = IMB_moviecacheIter_new(source->cache);
447       while (!IMB_moviecacheIter_done(iter)) {
448         ImBuf *ibuf = IMB_moviecacheIter_getImBuf(iter);
449         ImageCacheKey *key = IMB_moviecacheIter_getUserKey(iter);
450         imagecache_put(dest, key->index, ibuf);
451         IMB_moviecacheIter_step(iter);
452       }
453       IMB_moviecacheIter_free(iter);
454     }
455     BLI_spin_unlock(&image_spin);
456
457     BKE_id_free(bmain, source);
458   }
459 }
460
461 /* note, we could be clever and scale all imbuf's but since some are mipmaps its not so simple */
462 bool BKE_image_scale(Image *image, int width, int height)
463 {
464   ImBuf *ibuf;
465   void *lock;
466
467   ibuf = BKE_image_acquire_ibuf(image, NULL, &lock);
468
469   if (ibuf) {
470     IMB_scaleImBuf(ibuf, width, height);
471     ibuf->userflags |= IB_BITMAPDIRTY;
472   }
473
474   BKE_image_release_ibuf(image, ibuf, lock);
475
476   return (ibuf != NULL);
477 }
478
479 bool BKE_image_has_opengl_texture(Image *ima)
480 {
481   for (int i = 0; i < TEXTARGET_COUNT; i++) {
482     if (ima->gputexture[i]) {
483       return true;
484     }
485   }
486   return false;
487 }
488
489 static void image_init_color_management(Image *ima)
490 {
491   ImBuf *ibuf;
492   char name[FILE_MAX];
493
494   BKE_image_user_file_path(NULL, ima, name);
495
496   /* will set input color space to image format default's */
497   ibuf = IMB_loadiffname(name, IB_test | IB_alphamode_detect, ima->colorspace_settings.name);
498
499   if (ibuf) {
500     if (ibuf->flags & IB_alphamode_premul) {
501       ima->alpha_mode = IMA_ALPHA_PREMUL;
502     }
503     else {
504       ima->alpha_mode = IMA_ALPHA_STRAIGHT;
505     }
506
507     IMB_freeImBuf(ibuf);
508   }
509 }
510
511 char BKE_image_alpha_mode_from_extension_ex(const char *filepath)
512 {
513   if (BLI_path_extension_check_n(filepath, ".exr", ".cin", ".dpx", ".hdr", NULL)) {
514     return IMA_ALPHA_PREMUL;
515   }
516   else {
517     return IMA_ALPHA_STRAIGHT;
518   }
519 }
520
521 void BKE_image_alpha_mode_from_extension(Image *image)
522 {
523   image->alpha_mode = BKE_image_alpha_mode_from_extension_ex(image->name);
524 }
525
526 Image *BKE_image_load(Main *bmain, const char *filepath)
527 {
528   Image *ima;
529   int file;
530   char str[FILE_MAX];
531
532   STRNCPY(str, filepath);
533   BLI_path_abs(str, BKE_main_blendfile_path(bmain));
534
535   /* exists? */
536   file = BLI_open(str, O_BINARY | O_RDONLY, 0);
537   if (file == -1) {
538     return NULL;
539   }
540   close(file);
541
542   ima = image_alloc(bmain, BLI_path_basename(filepath), IMA_SRC_FILE, IMA_TYPE_IMAGE);
543   STRNCPY(ima->name, filepath);
544
545   if (BLI_path_extension_check_array(filepath, imb_ext_movie)) {
546     ima->source = IMA_SRC_MOVIE;
547   }
548
549   image_init_color_management(ima);
550
551   return ima;
552 }
553
554 /* checks if image was already loaded, then returns same image */
555 /* otherwise creates new. */
556 /* does not load ibuf itself */
557 /* pass on optional frame for #name images */
558 Image *BKE_image_load_exists_ex(Main *bmain, const char *filepath, bool *r_exists)
559 {
560   Image *ima;
561   char str[FILE_MAX], strtest[FILE_MAX];
562
563   STRNCPY(str, filepath);
564   BLI_path_abs(str, BKE_main_blendfile_path_from_global());
565
566   /* first search an identical filepath */
567   for (ima = bmain->images.first; ima; ima = ima->id.next) {
568     if (ima->source != IMA_SRC_VIEWER && ima->source != IMA_SRC_GENERATED) {
569       STRNCPY(strtest, ima->name);
570       BLI_path_abs(strtest, ID_BLEND_PATH(bmain, &ima->id));
571
572       if (BLI_path_cmp(strtest, str) == 0) {
573         if ((BKE_image_has_anim(ima) == false) || (ima->id.us == 0)) {
574           id_us_plus(&ima->id); /* officially should not, it doesn't link here! */
575           if (ima->ok == 0) {
576             ima->ok = IMA_OK;
577           }
578           if (r_exists) {
579             *r_exists = true;
580           }
581           return ima;
582         }
583       }
584     }
585   }
586
587   if (r_exists) {
588     *r_exists = false;
589   }
590   return BKE_image_load(bmain, filepath);
591 }
592
593 Image *BKE_image_load_exists(Main *bmain, const char *filepath)
594 {
595   return BKE_image_load_exists_ex(bmain, filepath, NULL);
596 }
597
598 static ImBuf *add_ibuf_size(unsigned int width,
599                             unsigned int height,
600                             const char *name,
601                             int depth,
602                             int floatbuf,
603                             short gen_type,
604                             const float color[4],
605                             ColorManagedColorspaceSettings *colorspace_settings)
606 {
607   ImBuf *ibuf;
608   unsigned char *rect = NULL;
609   float *rect_float = NULL;
610
611   if (floatbuf) {
612     ibuf = IMB_allocImBuf(width, height, depth, IB_rectfloat);
613
614     if (colorspace_settings->name[0] == '\0') {
615       const char *colorspace = IMB_colormanagement_role_colorspace_name_get(
616           COLOR_ROLE_DEFAULT_FLOAT);
617
618       STRNCPY(colorspace_settings->name, colorspace);
619     }
620
621     if (ibuf != NULL) {
622       rect_float = ibuf->rect_float;
623       IMB_colormanagement_check_is_data(ibuf, colorspace_settings->name);
624     }
625   }
626   else {
627     ibuf = IMB_allocImBuf(width, height, depth, IB_rect);
628
629     if (colorspace_settings->name[0] == '\0') {
630       const char *colorspace = IMB_colormanagement_role_colorspace_name_get(
631           COLOR_ROLE_DEFAULT_BYTE);
632
633       STRNCPY(colorspace_settings->name, colorspace);
634     }
635
636     if (ibuf != NULL) {
637       rect = (unsigned char *)ibuf->rect;
638       IMB_colormanagement_assign_rect_colorspace(ibuf, colorspace_settings->name);
639     }
640   }
641
642   if (!ibuf) {
643     return NULL;
644   }
645
646   STRNCPY(ibuf->name, name);
647   ibuf->userflags |= IB_BITMAPDIRTY;
648
649   switch (gen_type) {
650     case IMA_GENTYPE_GRID:
651       BKE_image_buf_fill_checker(rect, rect_float, width, height);
652       break;
653     case IMA_GENTYPE_GRID_COLOR:
654       BKE_image_buf_fill_checker_color(rect, rect_float, width, height);
655       break;
656     default:
657       BKE_image_buf_fill_color(rect, rect_float, width, height, color);
658       break;
659   }
660
661   return ibuf;
662 }
663
664 /* adds new image block, creates ImBuf and initializes color */
665 Image *BKE_image_add_generated(Main *bmain,
666                                unsigned int width,
667                                unsigned int height,
668                                const char *name,
669                                int depth,
670                                int floatbuf,
671                                short gen_type,
672                                const float color[4],
673                                const bool stereo3d)
674 {
675   /* on save, type is changed to FILE in editsima.c */
676   Image *ima = image_alloc(bmain, name, IMA_SRC_GENERATED, IMA_TYPE_UV_TEST);
677
678   if (ima) {
679     int view_id;
680     const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
681
682     /* STRNCPY(ima->name, name); */ /* don't do this, this writes in ain invalid filepath! */
683     ima->gen_x = width;
684     ima->gen_y = height;
685     ima->gen_type = gen_type;
686     ima->gen_flag |= (floatbuf ? IMA_GEN_FLOAT : 0);
687     ima->gen_depth = depth;
688     copy_v4_v4(ima->gen_color, color);
689
690     for (view_id = 0; view_id < 2; view_id++) {
691       ImBuf *ibuf;
692       ibuf = add_ibuf_size(
693           width, height, ima->name, depth, floatbuf, gen_type, color, &ima->colorspace_settings);
694       image_assign_ibuf(ima, ibuf, stereo3d ? view_id : IMA_NO_INDEX, 0);
695
696       /* image_assign_ibuf puts buffer to the cache, which increments user counter. */
697       IMB_freeImBuf(ibuf);
698       if (!stereo3d) {
699         break;
700       }
701
702       image_add_view(ima, names[view_id], "");
703     }
704
705     ima->ok = IMA_OK_LOADED;
706   }
707
708   return ima;
709 }
710
711 /* Create an image image from ibuf. The refcount of ibuf is increased,
712  * caller should take care to drop its reference by calling
713  * IMB_freeImBuf if needed. */
714 Image *BKE_image_add_from_imbuf(Main *bmain, ImBuf *ibuf, const char *name)
715 {
716   /* on save, type is changed to FILE in editsima.c */
717   Image *ima;
718
719   if (name == NULL) {
720     name = BLI_path_basename(ibuf->name);
721   }
722
723   ima = image_alloc(bmain, name, IMA_SRC_FILE, IMA_TYPE_IMAGE);
724
725   if (ima) {
726     STRNCPY(ima->name, ibuf->name);
727     image_assign_ibuf(ima, ibuf, IMA_NO_INDEX, 0);
728     ima->ok = IMA_OK_LOADED;
729   }
730
731   return ima;
732 }
733
734 /* Pack image buffer to memory as PNG or EXR. */
735 static bool image_memorypack_imbuf(Image *ima, ImBuf *ibuf, const char *filepath)
736 {
737   ibuf->ftype = (ibuf->rect_float) ? IMB_FTYPE_OPENEXR : IMB_FTYPE_PNG;
738
739   IMB_saveiff(ibuf, filepath, IB_rect | IB_mem);
740
741   if (ibuf->encodedbuffer == NULL) {
742     CLOG_STR_ERROR(&LOG, "memory save for pack error");
743     IMB_freeImBuf(ibuf);
744     image_free_packedfiles(ima);
745     return false;
746   }
747
748   ImagePackedFile *imapf;
749   PackedFile *pf = MEM_callocN(sizeof(*pf), "PackedFile");
750
751   pf->data = ibuf->encodedbuffer;
752   pf->size = ibuf->encodedsize;
753
754   imapf = MEM_mallocN(sizeof(ImagePackedFile), "Image PackedFile");
755   STRNCPY(imapf->filepath, filepath);
756   imapf->packedfile = pf;
757   BLI_addtail(&ima->packedfiles, imapf);
758
759   ibuf->encodedbuffer = NULL;
760   ibuf->encodedsize = 0;
761   ibuf->userflags &= ~IB_BITMAPDIRTY;
762
763   return true;
764 }
765
766 /* Pack image to memory. */
767 bool BKE_image_memorypack(Image *ima)
768 {
769   bool ok = true;
770
771   image_free_packedfiles(ima);
772
773   if (BKE_image_is_multiview(ima)) {
774     /* Store each view as a separate packed files with R_IMF_VIEWS_INDIVIDUAL. */
775     ImageView *iv;
776     int i;
777
778     for (i = 0, iv = ima->views.first; iv; iv = iv->next, i++) {
779       ImBuf *ibuf = image_get_cached_ibuf_for_index_frame(ima, i, 0);
780
781       if (!ibuf) {
782         ok = false;
783         break;
784       }
785
786       /* if the image was a R_IMF_VIEWS_STEREO_3D we force _L, _R suffices */
787       if (ima->views_format == R_IMF_VIEWS_STEREO_3D) {
788         const char *suffix[2] = {STEREO_LEFT_SUFFIX, STEREO_RIGHT_SUFFIX};
789         BLI_path_suffix(iv->filepath, FILE_MAX, suffix[i], "");
790       }
791
792       ok = ok && image_memorypack_imbuf(ima, ibuf, iv->filepath);
793       IMB_freeImBuf(ibuf);
794     }
795
796     ima->views_format = R_IMF_VIEWS_INDIVIDUAL;
797   }
798   else {
799     ImBuf *ibuf = image_get_cached_ibuf_for_index_frame(ima, IMA_NO_INDEX, 0);
800
801     if (ibuf) {
802       ok = ok && image_memorypack_imbuf(ima, ibuf, ibuf->name);
803       IMB_freeImBuf(ibuf);
804     }
805     else {
806       ok = false;
807     }
808   }
809
810   if (ok && ima->source == IMA_SRC_GENERATED) {
811     ima->source = IMA_SRC_FILE;
812     ima->type = IMA_TYPE_IMAGE;
813   }
814
815   return ok;
816 }
817
818 void BKE_image_packfiles(ReportList *reports, Image *ima, const char *basepath)
819 {
820   const int totfiles = image_num_files(ima);
821
822   if (totfiles == 1) {
823     ImagePackedFile *imapf = MEM_mallocN(sizeof(ImagePackedFile), "Image packed file");
824     BLI_addtail(&ima->packedfiles, imapf);
825     imapf->packedfile = newPackedFile(reports, ima->name, basepath);
826     if (imapf->packedfile) {
827       STRNCPY(imapf->filepath, ima->name);
828     }
829     else {
830       BLI_freelinkN(&ima->packedfiles, imapf);
831     }
832   }
833   else {
834     ImageView *iv;
835     for (iv = ima->views.first; iv; iv = iv->next) {
836       ImagePackedFile *imapf = MEM_mallocN(sizeof(ImagePackedFile), "Image packed file");
837       BLI_addtail(&ima->packedfiles, imapf);
838
839       imapf->packedfile = newPackedFile(reports, iv->filepath, basepath);
840       if (imapf->packedfile) {
841         STRNCPY(imapf->filepath, iv->filepath);
842       }
843       else {
844         BLI_freelinkN(&ima->packedfiles, imapf);
845       }
846     }
847   }
848 }
849
850 void BKE_image_packfiles_from_mem(ReportList *reports,
851                                   Image *ima,
852                                   char *data,
853                                   const size_t data_len)
854 {
855   const int totfiles = image_num_files(ima);
856
857   if (totfiles != 1) {
858     BKE_report(reports, RPT_ERROR, "Cannot pack multiview images from raw data currently...");
859   }
860   else {
861     ImagePackedFile *imapf = MEM_mallocN(sizeof(ImagePackedFile), __func__);
862     BLI_addtail(&ima->packedfiles, imapf);
863     imapf->packedfile = newPackedFileMemory(data, data_len);
864     STRNCPY(imapf->filepath, ima->name);
865   }
866 }
867
868 void BKE_image_tag_time(Image *ima)
869 {
870   ima->lastused = PIL_check_seconds_timer_i();
871 }
872
873 static uintptr_t image_mem_size(Image *image)
874 {
875   uintptr_t size = 0;
876
877   /* viewers have memory depending on other rules, has no valid rect pointer */
878   if (image->source == IMA_SRC_VIEWER) {
879     return 0;
880   }
881
882   BLI_spin_lock(&image_spin);
883   if (image->cache != NULL) {
884     struct MovieCacheIter *iter = IMB_moviecacheIter_new(image->cache);
885
886     while (!IMB_moviecacheIter_done(iter)) {
887       ImBuf *ibuf = IMB_moviecacheIter_getImBuf(iter);
888       ImBuf *ibufm;
889       int level;
890
891       if (ibuf->rect) {
892         size += MEM_allocN_len(ibuf->rect);
893       }
894       if (ibuf->rect_float) {
895         size += MEM_allocN_len(ibuf->rect_float);
896       }
897
898       for (level = 0; level < IMB_MIPMAP_LEVELS; level++) {
899         ibufm = ibuf->mipmap[level];
900         if (ibufm) {
901           if (ibufm->rect) {
902             size += MEM_allocN_len(ibufm->rect);
903           }
904           if (ibufm->rect_float) {
905             size += MEM_allocN_len(ibufm->rect_float);
906           }
907         }
908       }
909
910       IMB_moviecacheIter_step(iter);
911     }
912     IMB_moviecacheIter_free(iter);
913   }
914   BLI_spin_unlock(&image_spin);
915
916   return size;
917 }
918
919 void BKE_image_print_memlist(Main *bmain)
920 {
921   Image *ima;
922   uintptr_t size, totsize = 0;
923
924   for (ima = bmain->images.first; ima; ima = ima->id.next) {
925     totsize += image_mem_size(ima);
926   }
927
928   printf("\ntotal image memory len: %.3f MB\n", (double)totsize / (double)(1024 * 1024));
929
930   for (ima = bmain->images.first; ima; ima = ima->id.next) {
931     size = image_mem_size(ima);
932
933     if (size) {
934       printf("%s len: %.3f MB\n", ima->id.name + 2, (double)size / (double)(1024 * 1024));
935     }
936   }
937 }
938
939 static bool imagecache_check_dirty(ImBuf *ibuf, void *UNUSED(userkey), void *UNUSED(userdata))
940 {
941   return (ibuf->userflags & IB_BITMAPDIRTY) == 0;
942 }
943
944 void BKE_image_free_all_textures(Main *bmain)
945 {
946 #undef CHECK_FREED_SIZE
947
948   Tex *tex;
949   Image *ima;
950 #ifdef CHECK_FREED_SIZE
951   uintptr_t tot_freed_size = 0;
952 #endif
953
954   for (ima = bmain->images.first; ima; ima = ima->id.next) {
955     ima->id.tag &= ~LIB_TAG_DOIT;
956   }
957
958   for (tex = bmain->textures.first; tex; tex = tex->id.next) {
959     if (tex->ima) {
960       tex->ima->id.tag |= LIB_TAG_DOIT;
961     }
962   }
963
964   for (ima = bmain->images.first; ima; ima = ima->id.next) {
965     if (ima->cache && (ima->id.tag & LIB_TAG_DOIT)) {
966 #ifdef CHECK_FREED_SIZE
967       uintptr_t old_size = image_mem_size(ima);
968 #endif
969
970       IMB_moviecache_cleanup(ima->cache, imagecache_check_dirty, NULL);
971
972 #ifdef CHECK_FREED_SIZE
973       tot_freed_size += old_size - image_mem_size(ima);
974 #endif
975     }
976   }
977 #ifdef CHECK_FREED_SIZE
978   printf("%s: freed total %lu MB\n", __func__, tot_freed_size / (1024 * 1024));
979 #endif
980 }
981
982 static bool imagecache_check_free_anim(ImBuf *ibuf, void *UNUSED(userkey), void *userdata)
983 {
984   int except_frame = *(int *)userdata;
985   return (ibuf->userflags & IB_BITMAPDIRTY) == 0 && (ibuf->index != IMA_NO_INDEX) &&
986          (except_frame != IMA_INDEX_FRAME(ibuf->index));
987 }
988
989 /* except_frame is weak, only works for seqs without offset... */
990 void BKE_image_free_anim_ibufs(Image *ima, int except_frame)
991 {
992   BLI_spin_lock(&image_spin);
993   if (ima->cache != NULL) {
994     IMB_moviecache_cleanup(ima->cache, imagecache_check_free_anim, &except_frame);
995   }
996   BLI_spin_unlock(&image_spin);
997 }
998
999 void BKE_image_all_free_anim_ibufs(Main *bmain, int cfra)
1000 {
1001   Image *ima;
1002
1003   for (ima = bmain->images.first; ima; ima = ima->id.next) {
1004     if (BKE_image_is_animated(ima)) {
1005       BKE_image_free_anim_ibufs(ima, cfra);
1006     }
1007   }
1008 }
1009
1010 /* *********** READ AND WRITE ************** */
1011
1012 int BKE_image_imtype_to_ftype(const char imtype, ImbFormatOptions *r_options)
1013 {
1014   memset(r_options, 0, sizeof(*r_options));
1015
1016   if (imtype == R_IMF_IMTYPE_TARGA) {
1017     return IMB_FTYPE_TGA;
1018   }
1019   else if (imtype == R_IMF_IMTYPE_RAWTGA) {
1020     r_options->flag = RAWTGA;
1021     return IMB_FTYPE_TGA;
1022   }
1023   else if (imtype == R_IMF_IMTYPE_IRIS) {
1024     return IMB_FTYPE_IMAGIC;
1025   }
1026 #ifdef WITH_HDR
1027   else if (imtype == R_IMF_IMTYPE_RADHDR) {
1028     return IMB_FTYPE_RADHDR;
1029   }
1030 #endif
1031   else if (imtype == R_IMF_IMTYPE_PNG) {
1032     r_options->quality = 15;
1033     return IMB_FTYPE_PNG;
1034   }
1035 #ifdef WITH_DDS
1036   else if (imtype == R_IMF_IMTYPE_DDS) {
1037     return IMB_FTYPE_DDS;
1038   }
1039 #endif
1040   else if (imtype == R_IMF_IMTYPE_BMP) {
1041     return IMB_FTYPE_BMP;
1042   }
1043 #ifdef WITH_TIFF
1044   else if (imtype == R_IMF_IMTYPE_TIFF) {
1045     return IMB_FTYPE_TIF;
1046   }
1047 #endif
1048   else if (imtype == R_IMF_IMTYPE_OPENEXR || imtype == R_IMF_IMTYPE_MULTILAYER) {
1049     return IMB_FTYPE_OPENEXR;
1050   }
1051 #ifdef WITH_CINEON
1052   else if (imtype == R_IMF_IMTYPE_CINEON) {
1053     return IMB_FTYPE_CINEON;
1054   }
1055   else if (imtype == R_IMF_IMTYPE_DPX) {
1056     return IMB_FTYPE_DPX;
1057   }
1058 #endif
1059 #ifdef WITH_OPENJPEG
1060   else if (imtype == R_IMF_IMTYPE_JP2) {
1061     r_options->flag |= JP2_JP2;
1062     r_options->quality = 90;
1063     return IMB_FTYPE_JP2;
1064   }
1065 #endif
1066   else {
1067     r_options->quality = 90;
1068     return IMB_FTYPE_JPG;
1069   }
1070 }
1071
1072 char BKE_image_ftype_to_imtype(const int ftype, const ImbFormatOptions *options)
1073 {
1074   if (ftype == 0) {
1075     return R_IMF_IMTYPE_TARGA;
1076   }
1077   else if (ftype == IMB_FTYPE_IMAGIC) {
1078     return R_IMF_IMTYPE_IRIS;
1079   }
1080 #ifdef WITH_HDR
1081   else if (ftype == IMB_FTYPE_RADHDR) {
1082     return R_IMF_IMTYPE_RADHDR;
1083   }
1084 #endif
1085   else if (ftype == IMB_FTYPE_PNG) {
1086     return R_IMF_IMTYPE_PNG;
1087   }
1088 #ifdef WITH_DDS
1089   else if (ftype == IMB_FTYPE_DDS) {
1090     return R_IMF_IMTYPE_DDS;
1091   }
1092 #endif
1093   else if (ftype == IMB_FTYPE_BMP) {
1094     return R_IMF_IMTYPE_BMP;
1095   }
1096 #ifdef WITH_TIFF
1097   else if (ftype == IMB_FTYPE_TIF) {
1098     return R_IMF_IMTYPE_TIFF;
1099   }
1100 #endif
1101   else if (ftype == IMB_FTYPE_OPENEXR) {
1102     return R_IMF_IMTYPE_OPENEXR;
1103   }
1104 #ifdef WITH_CINEON
1105   else if (ftype == IMB_FTYPE_CINEON) {
1106     return R_IMF_IMTYPE_CINEON;
1107   }
1108   else if (ftype == IMB_FTYPE_DPX) {
1109     return R_IMF_IMTYPE_DPX;
1110   }
1111 #endif
1112   else if (ftype == IMB_FTYPE_TGA) {
1113     if (options && (options->flag & RAWTGA)) {
1114       return R_IMF_IMTYPE_RAWTGA;
1115     }
1116     else {
1117       return R_IMF_IMTYPE_TARGA;
1118     }
1119   }
1120 #ifdef WITH_OPENJPEG
1121   else if (ftype == IMB_FTYPE_JP2) {
1122     return R_IMF_IMTYPE_JP2;
1123   }
1124 #endif
1125   else {
1126     return R_IMF_IMTYPE_JPEG90;
1127   }
1128 }
1129
1130 bool BKE_imtype_is_movie(const char imtype)
1131 {
1132   switch (imtype) {
1133     case R_IMF_IMTYPE_AVIRAW:
1134     case R_IMF_IMTYPE_AVIJPEG:
1135     case R_IMF_IMTYPE_FFMPEG:
1136     case R_IMF_IMTYPE_H264:
1137     case R_IMF_IMTYPE_THEORA:
1138     case R_IMF_IMTYPE_XVID:
1139       return true;
1140   }
1141   return false;
1142 }
1143
1144 int BKE_imtype_supports_zbuf(const char imtype)
1145 {
1146   switch (imtype) {
1147     case R_IMF_IMTYPE_IRIZ:
1148     case R_IMF_IMTYPE_OPENEXR: /* but not R_IMF_IMTYPE_MULTILAYER */
1149       return 1;
1150   }
1151   return 0;
1152 }
1153
1154 int BKE_imtype_supports_compress(const char imtype)
1155 {
1156   switch (imtype) {
1157     case R_IMF_IMTYPE_PNG:
1158       return 1;
1159   }
1160   return 0;
1161 }
1162
1163 int BKE_imtype_supports_quality(const char imtype)
1164 {
1165   switch (imtype) {
1166     case R_IMF_IMTYPE_JPEG90:
1167     case R_IMF_IMTYPE_JP2:
1168     case R_IMF_IMTYPE_AVIJPEG:
1169       return 1;
1170   }
1171   return 0;
1172 }
1173
1174 int BKE_imtype_requires_linear_float(const char imtype)
1175 {
1176   switch (imtype) {
1177     case R_IMF_IMTYPE_CINEON:
1178     case R_IMF_IMTYPE_DPX:
1179     case R_IMF_IMTYPE_RADHDR:
1180     case R_IMF_IMTYPE_OPENEXR:
1181     case R_IMF_IMTYPE_MULTILAYER:
1182       return true;
1183   }
1184   return 0;
1185 }
1186
1187 char BKE_imtype_valid_channels(const char imtype, bool write_file)
1188 {
1189   char chan_flag = IMA_CHAN_FLAG_RGB; /* assume all support rgb */
1190
1191   /* alpha */
1192   switch (imtype) {
1193     case R_IMF_IMTYPE_BMP:
1194       if (write_file) {
1195         break;
1196       }
1197       ATTR_FALLTHROUGH;
1198     case R_IMF_IMTYPE_TARGA:
1199     case R_IMF_IMTYPE_RAWTGA:
1200     case R_IMF_IMTYPE_IRIS:
1201     case R_IMF_IMTYPE_PNG:
1202     case R_IMF_IMTYPE_TIFF:
1203     case R_IMF_IMTYPE_OPENEXR:
1204     case R_IMF_IMTYPE_MULTILAYER:
1205     case R_IMF_IMTYPE_DDS:
1206     case R_IMF_IMTYPE_JP2:
1207     case R_IMF_IMTYPE_DPX:
1208       chan_flag |= IMA_CHAN_FLAG_ALPHA;
1209       break;
1210   }
1211
1212   /* bw */
1213   switch (imtype) {
1214     case R_IMF_IMTYPE_PNG:
1215     case R_IMF_IMTYPE_JPEG90:
1216     case R_IMF_IMTYPE_TARGA:
1217     case R_IMF_IMTYPE_RAWTGA:
1218     case R_IMF_IMTYPE_TIFF:
1219     case R_IMF_IMTYPE_IRIS:
1220       chan_flag |= IMA_CHAN_FLAG_BW;
1221       break;
1222   }
1223
1224   return chan_flag;
1225 }
1226
1227 char BKE_imtype_valid_depths(const char imtype)
1228 {
1229   switch (imtype) {
1230     case R_IMF_IMTYPE_RADHDR:
1231       return R_IMF_CHAN_DEPTH_32;
1232     case R_IMF_IMTYPE_TIFF:
1233       return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_16;
1234     case R_IMF_IMTYPE_OPENEXR:
1235       return R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_32;
1236     case R_IMF_IMTYPE_MULTILAYER:
1237       return R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_32;
1238     /* eeh, cineon does some strange 10bits per channel */
1239     case R_IMF_IMTYPE_DPX:
1240       return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_10 | R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16;
1241     case R_IMF_IMTYPE_CINEON:
1242       return R_IMF_CHAN_DEPTH_10;
1243     case R_IMF_IMTYPE_JP2:
1244       return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16;
1245     case R_IMF_IMTYPE_PNG:
1246       return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_16;
1247     /* most formats are 8bit only */
1248     default:
1249       return R_IMF_CHAN_DEPTH_8;
1250   }
1251 }
1252
1253 /* string is from command line --render-format arg, keep in sync with
1254  * creator_args.c help info */
1255 char BKE_imtype_from_arg(const char *imtype_arg)
1256 {
1257   if (STREQ(imtype_arg, "TGA")) {
1258     return R_IMF_IMTYPE_TARGA;
1259   }
1260   else if (STREQ(imtype_arg, "IRIS")) {
1261     return R_IMF_IMTYPE_IRIS;
1262   }
1263 #ifdef WITH_DDS
1264   else if (STREQ(imtype_arg, "DDS")) {
1265     return R_IMF_IMTYPE_DDS;
1266   }
1267 #endif
1268   else if (STREQ(imtype_arg, "JPEG")) {
1269     return R_IMF_IMTYPE_JPEG90;
1270   }
1271   else if (STREQ(imtype_arg, "IRIZ")) {
1272     return R_IMF_IMTYPE_IRIZ;
1273   }
1274   else if (STREQ(imtype_arg, "RAWTGA")) {
1275     return R_IMF_IMTYPE_RAWTGA;
1276   }
1277   else if (STREQ(imtype_arg, "AVIRAW")) {
1278     return R_IMF_IMTYPE_AVIRAW;
1279   }
1280   else if (STREQ(imtype_arg, "AVIJPEG")) {
1281     return R_IMF_IMTYPE_AVIJPEG;
1282   }
1283   else if (STREQ(imtype_arg, "PNG")) {
1284     return R_IMF_IMTYPE_PNG;
1285   }
1286   else if (STREQ(imtype_arg, "BMP")) {
1287     return R_IMF_IMTYPE_BMP;
1288   }
1289 #ifdef WITH_HDR
1290   else if (STREQ(imtype_arg, "HDR")) {
1291     return R_IMF_IMTYPE_RADHDR;
1292   }
1293 #endif
1294 #ifdef WITH_TIFF
1295   else if (STREQ(imtype_arg, "TIFF")) {
1296     return R_IMF_IMTYPE_TIFF;
1297   }
1298 #endif
1299 #ifdef WITH_OPENEXR
1300   else if (STREQ(imtype_arg, "OPEN_EXR")) {
1301     return R_IMF_IMTYPE_OPENEXR;
1302   }
1303   else if (STREQ(imtype_arg, "OPEN_EXR_MULTILAYER")) {
1304     return R_IMF_IMTYPE_MULTILAYER;
1305   }
1306   else if (STREQ(imtype_arg, "EXR")) {
1307     return R_IMF_IMTYPE_OPENEXR;
1308   }
1309   else if (STREQ(imtype_arg, "MULTILAYER")) {
1310     return R_IMF_IMTYPE_MULTILAYER;
1311   }
1312 #endif
1313   else if (STREQ(imtype_arg, "FFMPEG")) {
1314     return R_IMF_IMTYPE_FFMPEG;
1315   }
1316 #ifdef WITH_CINEON
1317   else if (STREQ(imtype_arg, "CINEON")) {
1318     return R_IMF_IMTYPE_CINEON;
1319   }
1320   else if (STREQ(imtype_arg, "DPX")) {
1321     return R_IMF_IMTYPE_DPX;
1322   }
1323 #endif
1324 #ifdef WITH_OPENJPEG
1325   else if (STREQ(imtype_arg, "JP2")) {
1326     return R_IMF_IMTYPE_JP2;
1327   }
1328 #endif
1329   else {
1330     return R_IMF_IMTYPE_INVALID;
1331   }
1332 }
1333
1334 static bool do_add_image_extension(char *string,
1335                                    const char imtype,
1336                                    const ImageFormatData *im_format)
1337 {
1338   const char *extension = NULL;
1339   const char *extension_test;
1340   (void)im_format; /* may be unused, depends on build options */
1341
1342   if (imtype == R_IMF_IMTYPE_IRIS) {
1343     if (!BLI_path_extension_check(string, extension_test = ".rgb")) {
1344       extension = extension_test;
1345     }
1346   }
1347   else if (imtype == R_IMF_IMTYPE_IRIZ) {
1348     if (!BLI_path_extension_check(string, extension_test = ".rgb")) {
1349       extension = extension_test;
1350     }
1351   }
1352 #ifdef WITH_HDR
1353   else if (imtype == R_IMF_IMTYPE_RADHDR) {
1354     if (!BLI_path_extension_check(string, extension_test = ".hdr")) {
1355       extension = extension_test;
1356     }
1357   }
1358 #endif
1359   else if (ELEM(imtype,
1360                 R_IMF_IMTYPE_PNG,
1361                 R_IMF_IMTYPE_FFMPEG,
1362                 R_IMF_IMTYPE_H264,
1363                 R_IMF_IMTYPE_THEORA,
1364                 R_IMF_IMTYPE_XVID)) {
1365     if (!BLI_path_extension_check(string, extension_test = ".png")) {
1366       extension = extension_test;
1367     }
1368   }
1369 #ifdef WITH_DDS
1370   else if (imtype == R_IMF_IMTYPE_DDS) {
1371     if (!BLI_path_extension_check(string, extension_test = ".dds")) {
1372       extension = extension_test;
1373     }
1374   }
1375 #endif
1376   else if (ELEM(imtype, R_IMF_IMTYPE_TARGA, R_IMF_IMTYPE_RAWTGA)) {
1377     if (!BLI_path_extension_check(string, extension_test = ".tga")) {
1378       extension = extension_test;
1379     }
1380   }
1381   else if (imtype == R_IMF_IMTYPE_BMP) {
1382     if (!BLI_path_extension_check(string, extension_test = ".bmp")) {
1383       extension = extension_test;
1384     }
1385   }
1386 #ifdef WITH_TIFF
1387   else if (imtype == R_IMF_IMTYPE_TIFF) {
1388     if (!BLI_path_extension_check_n(string, extension_test = ".tif", ".tiff", NULL)) {
1389       extension = extension_test;
1390     }
1391   }
1392 #endif
1393 #ifdef WITH_OPENIMAGEIO
1394   else if (imtype == R_IMF_IMTYPE_PSD) {
1395     if (!BLI_path_extension_check(string, extension_test = ".psd")) {
1396       extension = extension_test;
1397     }
1398   }
1399 #endif
1400 #ifdef WITH_OPENEXR
1401   else if (imtype == R_IMF_IMTYPE_OPENEXR || imtype == R_IMF_IMTYPE_MULTILAYER) {
1402     if (!BLI_path_extension_check(string, extension_test = ".exr")) {
1403       extension = extension_test;
1404     }
1405   }
1406 #endif
1407 #ifdef WITH_CINEON
1408   else if (imtype == R_IMF_IMTYPE_CINEON) {
1409     if (!BLI_path_extension_check(string, extension_test = ".cin")) {
1410       extension = extension_test;
1411     }
1412   }
1413   else if (imtype == R_IMF_IMTYPE_DPX) {
1414     if (!BLI_path_extension_check(string, extension_test = ".dpx")) {
1415       extension = extension_test;
1416     }
1417   }
1418 #endif
1419 #ifdef WITH_OPENJPEG
1420   else if (imtype == R_IMF_IMTYPE_JP2) {
1421     if (im_format) {
1422       if (im_format->jp2_codec == R_IMF_JP2_CODEC_JP2) {
1423         if (!BLI_path_extension_check(string, extension_test = ".jp2")) {
1424           extension = extension_test;
1425         }
1426       }
1427       else if (im_format->jp2_codec == R_IMF_JP2_CODEC_J2K) {
1428         if (!BLI_path_extension_check(string, extension_test = ".j2c")) {
1429           extension = extension_test;
1430         }
1431       }
1432       else {
1433         BLI_assert(!"Unsupported jp2 codec was specified in im_format->jp2_codec");
1434       }
1435     }
1436     else {
1437       if (!BLI_path_extension_check(string, extension_test = ".jp2")) {
1438         extension = extension_test;
1439       }
1440     }
1441   }
1442 #endif
1443   else {  //   R_IMF_IMTYPE_AVIRAW, R_IMF_IMTYPE_AVIJPEG, R_IMF_IMTYPE_JPEG90 etc
1444     if (!(BLI_path_extension_check_n(string, extension_test = ".jpg", ".jpeg", NULL))) {
1445       extension = extension_test;
1446     }
1447   }
1448
1449   if (extension) {
1450     /* prefer this in many cases to avoid .png.tga, but in certain cases it breaks */
1451     /* remove any other known image extension */
1452     if (BLI_path_extension_check_array(string, imb_ext_image)) {
1453       return BLI_path_extension_replace(string, FILE_MAX, extension);
1454     }
1455     else {
1456       return BLI_path_extension_ensure(string, FILE_MAX, extension);
1457     }
1458   }
1459   else {
1460     return false;
1461   }
1462 }
1463
1464 int BKE_image_path_ensure_ext_from_imformat(char *string, const ImageFormatData *im_format)
1465 {
1466   return do_add_image_extension(string, im_format->imtype, im_format);
1467 }
1468
1469 int BKE_image_path_ensure_ext_from_imtype(char *string, const char imtype)
1470 {
1471   return do_add_image_extension(string, imtype, NULL);
1472 }
1473
1474 void BKE_imformat_defaults(ImageFormatData *im_format)
1475 {
1476   memset(im_format, 0, sizeof(*im_format));
1477   im_format->planes = R_IMF_PLANES_RGBA;
1478   im_format->imtype = R_IMF_IMTYPE_PNG;
1479   im_format->depth = R_IMF_CHAN_DEPTH_8;
1480   im_format->quality = 90;
1481   im_format->compress = 15;
1482
1483   BKE_color_managed_display_settings_init(&im_format->display_settings);
1484   BKE_color_managed_view_settings_init_default(&im_format->view_settings,
1485                                                &im_format->display_settings);
1486 }
1487
1488 void BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const ImBuf *imbuf)
1489 {
1490   int ftype = imbuf->ftype;
1491   int custom_flags = imbuf->foptions.flag;
1492   char quality = imbuf->foptions.quality;
1493
1494   BKE_imformat_defaults(im_format);
1495
1496   /* file type */
1497
1498   if (ftype == IMB_FTYPE_IMAGIC) {
1499     im_format->imtype = R_IMF_IMTYPE_IRIS;
1500
1501 #ifdef WITH_HDR
1502   }
1503   else if (ftype == IMB_FTYPE_RADHDR) {
1504     im_format->imtype = R_IMF_IMTYPE_RADHDR;
1505 #endif
1506   }
1507   else if (ftype == IMB_FTYPE_PNG) {
1508     im_format->imtype = R_IMF_IMTYPE_PNG;
1509
1510     if (custom_flags & PNG_16BIT) {
1511       im_format->depth = R_IMF_CHAN_DEPTH_16;
1512     }
1513
1514     im_format->compress = quality;
1515   }
1516
1517 #ifdef WITH_DDS
1518   else if (ftype == IMB_FTYPE_DDS) {
1519     im_format->imtype = R_IMF_IMTYPE_DDS;
1520 #endif
1521   }
1522   else if (ftype == IMB_FTYPE_BMP) {
1523     im_format->imtype = R_IMF_IMTYPE_BMP;
1524
1525 #ifdef WITH_TIFF
1526   }
1527   else if (ftype == IMB_FTYPE_TIF) {
1528     im_format->imtype = R_IMF_IMTYPE_TIFF;
1529     if (custom_flags & TIF_16BIT) {
1530       im_format->depth = R_IMF_CHAN_DEPTH_16;
1531     }
1532     if (custom_flags & TIF_COMPRESS_NONE) {
1533       im_format->tiff_codec = R_IMF_TIFF_CODEC_NONE;
1534     }
1535     if (custom_flags & TIF_COMPRESS_DEFLATE) {
1536       im_format->tiff_codec = R_IMF_TIFF_CODEC_DEFLATE;
1537     }
1538     if (custom_flags & TIF_COMPRESS_LZW) {
1539       im_format->tiff_codec = R_IMF_TIFF_CODEC_LZW;
1540     }
1541     if (custom_flags & TIF_COMPRESS_PACKBITS) {
1542       im_format->tiff_codec = R_IMF_TIFF_CODEC_PACKBITS;
1543     }
1544   }
1545 #endif
1546
1547 #ifdef WITH_OPENEXR
1548   else if (ftype == IMB_FTYPE_OPENEXR) {
1549     im_format->imtype = R_IMF_IMTYPE_OPENEXR;
1550     if (custom_flags & OPENEXR_HALF) {
1551       im_format->depth = R_IMF_CHAN_DEPTH_16;
1552     }
1553     if (custom_flags & OPENEXR_COMPRESS) {
1554       im_format->exr_codec = R_IMF_EXR_CODEC_ZIP;  // Can't determine compression
1555     }
1556     if (imbuf->zbuf_float) {
1557       im_format->flag |= R_IMF_FLAG_ZBUF;
1558     }
1559   }
1560 #endif
1561
1562 #ifdef WITH_CINEON
1563   else if (ftype == IMB_FTYPE_CINEON) {
1564     im_format->imtype = R_IMF_IMTYPE_CINEON;
1565   }
1566   else if (ftype == IMB_FTYPE_DPX) {
1567     im_format->imtype = R_IMF_IMTYPE_DPX;
1568 #endif
1569   }
1570   else if (ftype == IMB_FTYPE_TGA) {
1571     if (custom_flags & RAWTGA) {
1572       im_format->imtype = R_IMF_IMTYPE_RAWTGA;
1573     }
1574     else {
1575       im_format->imtype = R_IMF_IMTYPE_TARGA;
1576     }
1577   }
1578 #ifdef WITH_OPENJPEG
1579   else if (ftype == IMB_FTYPE_JP2) {
1580     im_format->imtype = R_IMF_IMTYPE_JP2;
1581     im_format->quality = quality;
1582
1583     if (custom_flags & JP2_16BIT) {
1584       im_format->depth = R_IMF_CHAN_DEPTH_16;
1585     }
1586     else if (custom_flags & JP2_12BIT) {
1587       im_format->depth = R_IMF_CHAN_DEPTH_12;
1588     }
1589
1590     if (custom_flags & JP2_YCC) {
1591       im_format->jp2_flag |= R_IMF_JP2_FLAG_YCC;
1592     }
1593
1594     if (custom_flags & JP2_CINE) {
1595       im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_PRESET;
1596       if (custom_flags & JP2_CINE_48FPS) {
1597         im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_48;
1598       }
1599     }
1600
1601     if (custom_flags & JP2_JP2) {
1602       im_format->jp2_codec = R_IMF_JP2_CODEC_JP2;
1603     }
1604     else if (custom_flags & JP2_J2K) {
1605       im_format->jp2_codec = R_IMF_JP2_CODEC_J2K;
1606     }
1607     else {
1608       BLI_assert(!"Unsupported jp2 codec was specified in file type");
1609     }
1610   }
1611 #endif
1612
1613   else {
1614     im_format->imtype = R_IMF_IMTYPE_JPEG90;
1615     im_format->quality = quality;
1616   }
1617
1618   /* planes */
1619   im_format->planes = imbuf->planes;
1620 }
1621
1622 #define STAMP_NAME_SIZE ((MAX_ID_NAME - 2) + 16)
1623 /* could allow access externally - 512 is for long names,
1624  * STAMP_NAME_SIZE is for id names, allowing them some room for description */
1625 typedef struct StampDataCustomField {
1626   struct StampDataCustomField *next, *prev;
1627   /* TODO(sergey): Think of better size here, maybe dynamically allocated even. */
1628   char key[512];
1629   char *value;
1630   /* TODO(sergey): Support non-string values. */
1631 } StampDataCustomField;
1632
1633 typedef struct StampData {
1634   char file[512];
1635   char note[512];
1636   char date[512];
1637   char marker[512];
1638   char time[512];
1639   char frame[512];
1640   char frame_range[512];
1641   char camera[STAMP_NAME_SIZE];
1642   char cameralens[STAMP_NAME_SIZE];
1643   char scene[STAMP_NAME_SIZE];
1644   char strip[STAMP_NAME_SIZE];
1645   char rendertime[STAMP_NAME_SIZE];
1646   char memory[STAMP_NAME_SIZE];
1647   char hostname[512];
1648
1649   /* Custom fields are used to put extra meta information header from render
1650    * engine to the result image.
1651    *
1652    * NOTE: This fields are not stamped onto the image. At least for now.
1653    */
1654   ListBase custom_fields;
1655 } StampData;
1656 #undef STAMP_NAME_SIZE
1657
1658 /**
1659  * \param do_prefix: Include a label like "File ", "Date ", etc. in the stamp data strings.
1660  * \param use_dynamic: Also include data that can change on a per-frame basis.
1661  */
1662 static void stampdata(
1663     Scene *scene, Object *camera, StampData *stamp_data, int do_prefix, bool use_dynamic)
1664 {
1665   char text[256];
1666   struct tm *tl;
1667   time_t t;
1668
1669   if (scene->r.stamp & R_STAMP_FILENAME) {
1670     SNPRINTF(stamp_data->file,
1671              do_prefix ? "File %s" : "%s",
1672              G.relbase_valid ? BKE_main_blendfile_path_from_global() : "<untitled>");
1673   }
1674   else {
1675     stamp_data->file[0] = '\0';
1676   }
1677
1678   if (scene->r.stamp & R_STAMP_NOTE) {
1679     /* Never do prefix for Note */
1680     SNPRINTF(stamp_data->note, "%s", scene->r.stamp_udata);
1681   }
1682   else {
1683     stamp_data->note[0] = '\0';
1684   }
1685
1686   if (scene->r.stamp & R_STAMP_DATE) {
1687     t = time(NULL);
1688     tl = localtime(&t);
1689     SNPRINTF(text,
1690              "%04d/%02d/%02d %02d:%02d:%02d",
1691              tl->tm_year + 1900,
1692              tl->tm_mon + 1,
1693              tl->tm_mday,
1694              tl->tm_hour,
1695              tl->tm_min,
1696              tl->tm_sec);
1697     SNPRINTF(stamp_data->date, do_prefix ? "Date %s" : "%s", text);
1698   }
1699   else {
1700     stamp_data->date[0] = '\0';
1701   }
1702
1703   if (use_dynamic && scene->r.stamp & R_STAMP_MARKER) {
1704     const char *name = BKE_scene_find_last_marker_name(scene, CFRA);
1705
1706     if (name) {
1707       STRNCPY(text, name);
1708     }
1709     else {
1710       STRNCPY(text, "<none>");
1711     }
1712
1713     SNPRINTF(stamp_data->marker, do_prefix ? "Marker %s" : "%s", text);
1714   }
1715   else {
1716     stamp_data->marker[0] = '\0';
1717   }
1718
1719   if (use_dynamic && scene->r.stamp & R_STAMP_TIME) {
1720     const short timecode_style = USER_TIMECODE_SMPTE_FULL;
1721     BLI_timecode_string_from_time(
1722         text, sizeof(text), 0, FRA2TIME(scene->r.cfra), FPS, timecode_style);
1723     SNPRINTF(stamp_data->time, do_prefix ? "Timecode %s" : "%s", text);
1724   }
1725   else {
1726     stamp_data->time[0] = '\0';
1727   }
1728
1729   if (use_dynamic && scene->r.stamp & R_STAMP_FRAME) {
1730     char fmtstr[32];
1731     int digits = 1;
1732
1733     if (scene->r.efra > 9) {
1734       digits = integer_digits_i(scene->r.efra);
1735     }
1736
1737     SNPRINTF(fmtstr, do_prefix ? "Frame %%0%di" : "%%0%di", digits);
1738     SNPRINTF(stamp_data->frame, fmtstr, scene->r.cfra);
1739   }
1740   else {
1741     stamp_data->frame[0] = '\0';
1742   }
1743
1744   if (scene->r.stamp & R_STAMP_FRAME_RANGE) {
1745     SNPRINTF(stamp_data->frame_range,
1746              do_prefix ? "Frame Range %d:%d" : "%d:%d",
1747              scene->r.sfra,
1748              scene->r.efra);
1749   }
1750   else {
1751     stamp_data->frame_range[0] = '\0';
1752   }
1753
1754   if (use_dynamic && scene->r.stamp & R_STAMP_CAMERA) {
1755     SNPRINTF(stamp_data->camera,
1756              do_prefix ? "Camera %s" : "%s",
1757              camera ? camera->id.name + 2 : "<none>");
1758   }
1759   else {
1760     stamp_data->camera[0] = '\0';
1761   }
1762
1763   if (use_dynamic && scene->r.stamp & R_STAMP_CAMERALENS) {
1764     if (camera && camera->type == OB_CAMERA) {
1765       SNPRINTF(text, "%.2f", ((Camera *)camera->data)->lens);
1766     }
1767     else {
1768       STRNCPY(text, "<none>");
1769     }
1770
1771     SNPRINTF(stamp_data->cameralens, do_prefix ? "Lens %s" : "%s", text);
1772   }
1773   else {
1774     stamp_data->cameralens[0] = '\0';
1775   }
1776
1777   if (scene->r.stamp & R_STAMP_SCENE) {
1778     SNPRINTF(stamp_data->scene, do_prefix ? "Scene %s" : "%s", scene->id.name + 2);
1779   }
1780   else {
1781     stamp_data->scene[0] = '\0';
1782   }
1783
1784   if (use_dynamic && scene->r.stamp & R_STAMP_SEQSTRIP) {
1785     Sequence *seq = BKE_sequencer_foreground_frame_get(scene, scene->r.cfra);
1786
1787     if (seq) {
1788       STRNCPY(text, seq->name + 2);
1789     }
1790     else {
1791       STRNCPY(text, "<none>");
1792     }
1793
1794     SNPRINTF(stamp_data->strip, do_prefix ? "Strip %s" : "%s", text);
1795   }
1796   else {
1797     stamp_data->strip[0] = '\0';
1798   }
1799
1800   {
1801     Render *re = RE_GetSceneRender(scene);
1802     RenderStats *stats = re ? RE_GetStats(re) : NULL;
1803
1804     if (use_dynamic && stats && (scene->r.stamp & R_STAMP_RENDERTIME)) {
1805       BLI_timecode_string_from_time_simple(text, sizeof(text), stats->lastframetime);
1806
1807       SNPRINTF(stamp_data->rendertime, do_prefix ? "RenderTime %s" : "%s", text);
1808     }
1809     else {
1810       stamp_data->rendertime[0] = '\0';
1811     }
1812
1813     if (use_dynamic && stats && (scene->r.stamp & R_STAMP_MEMORY)) {
1814       SNPRINTF(stamp_data->memory, do_prefix ? "Peak Memory %.2fM" : "%.2fM", stats->mem_peak);
1815     }
1816     else {
1817       stamp_data->memory[0] = '\0';
1818     }
1819   }
1820   if (scene->r.stamp & R_STAMP_FRAME_RANGE) {
1821     SNPRINTF(stamp_data->frame_range,
1822              do_prefix ? "Frame Range %d:%d" : "%d:%d",
1823              scene->r.sfra,
1824              scene->r.efra);
1825   }
1826   else {
1827     stamp_data->frame_range[0] = '\0';
1828   }
1829
1830   if (scene->r.stamp & R_STAMP_HOSTNAME) {
1831     char hostname[500]; /* sizeof(stamp_data->hostname) minus some bytes for a label. */
1832     BLI_hostname_get(hostname, sizeof(hostname));
1833     SNPRINTF(stamp_data->hostname, do_prefix ? "Hostname %s" : "%s", hostname);
1834   }
1835   else {
1836     stamp_data->hostname[0] = '\0';
1837   }
1838 }
1839
1840 /* Will always add prefix. */
1841 static void stampdata_from_template(StampData *stamp_data,
1842                                     const Scene *scene,
1843                                     const StampData *stamp_data_template)
1844 {
1845   if (scene->r.stamp & R_STAMP_FILENAME) {
1846     SNPRINTF(stamp_data->file, "File %s", stamp_data_template->file);
1847   }
1848   else {
1849     stamp_data->file[0] = '\0';
1850   }
1851   if (scene->r.stamp & R_STAMP_NOTE) {
1852     SNPRINTF(stamp_data->note, "%s", stamp_data_template->note);
1853   }
1854   else {
1855     stamp_data->note[0] = '\0';
1856   }
1857   if (scene->r.stamp & R_STAMP_DATE) {
1858     SNPRINTF(stamp_data->date, "Date %s", stamp_data_template->date);
1859   }
1860   else {
1861     stamp_data->date[0] = '\0';
1862   }
1863   if (scene->r.stamp & R_STAMP_MARKER) {
1864     SNPRINTF(stamp_data->marker, "Marker %s", stamp_data_template->marker);
1865   }
1866   else {
1867     stamp_data->marker[0] = '\0';
1868   }
1869   if (scene->r.stamp & R_STAMP_TIME) {
1870     SNPRINTF(stamp_data->time, "Timecode %s", stamp_data_template->time);
1871   }
1872   else {
1873     stamp_data->time[0] = '\0';
1874   }
1875   if (scene->r.stamp & R_STAMP_FRAME) {
1876     SNPRINTF(stamp_data->frame, "Frame %s", stamp_data_template->frame);
1877   }
1878   else {
1879     stamp_data->frame[0] = '\0';
1880   }
1881   if (scene->r.stamp & R_STAMP_CAMERA) {
1882     SNPRINTF(stamp_data->camera, "Camera %s", stamp_data_template->camera);
1883   }
1884   else {
1885     stamp_data->camera[0] = '\0';
1886   }
1887   if (scene->r.stamp & R_STAMP_CAMERALENS) {
1888     SNPRINTF(stamp_data->cameralens, "Lens %s", stamp_data_template->cameralens);
1889   }
1890   else {
1891     stamp_data->cameralens[0] = '\0';
1892   }
1893   if (scene->r.stamp & R_STAMP_SCENE) {
1894     SNPRINTF(stamp_data->scene, "Scene %s", stamp_data_template->scene);
1895   }
1896   else {
1897     stamp_data->scene[0] = '\0';
1898   }
1899   if (scene->r.stamp & R_STAMP_SEQSTRIP) {
1900     SNPRINTF(stamp_data->strip, "Strip %s", stamp_data_template->strip);
1901   }
1902   else {
1903     stamp_data->strip[0] = '\0';
1904   }
1905   if (scene->r.stamp & R_STAMP_RENDERTIME) {
1906     SNPRINTF(stamp_data->rendertime, "RenderTime %s", stamp_data_template->rendertime);
1907   }
1908   else {
1909     stamp_data->rendertime[0] = '\0';
1910   }
1911   if (scene->r.stamp & R_STAMP_MEMORY) {
1912     SNPRINTF(stamp_data->memory, "Peak Memory %s", stamp_data_template->memory);
1913   }
1914   else {
1915     stamp_data->memory[0] = '\0';
1916   }
1917   if (scene->r.stamp & R_STAMP_HOSTNAME) {
1918     SNPRINTF(stamp_data->hostname, "Hostname %s", stamp_data_template->hostname);
1919   }
1920   else {
1921     stamp_data->hostname[0] = '\0';
1922   }
1923 }
1924
1925 void BKE_image_stamp_buf(Scene *scene,
1926                          Object *camera,
1927                          const StampData *stamp_data_template,
1928                          unsigned char *rect,
1929                          float *rectf,
1930                          int width,
1931                          int height,
1932                          int channels)
1933 {
1934   struct StampData stamp_data;
1935   float w, h, pad;
1936   int x, y, y_ofs;
1937   float h_fixed;
1938   const int mono = blf_mono_font_render;  // XXX
1939   struct ColorManagedDisplay *display;
1940   const char *display_device;
1941
1942   /* vars for calculating wordwrap */
1943   struct {
1944     struct ResultBLF info;
1945     rctf rect;
1946   } wrap;
1947
1948   /* this could be an argument if we want to operate on non linear float imbuf's
1949    * for now though this is only used for renders which use scene settings */
1950
1951 #define TEXT_SIZE_CHECK(str, w, h) \
1952   ((str[0]) && ((void)(h = h_fixed), (w = BLF_width(mono, str, sizeof(str)))))
1953
1954   /* must enable BLF_WORD_WRAP before using */
1955 #define TEXT_SIZE_CHECK_WORD_WRAP(str, w, h) \
1956   ((str[0]) && (BLF_boundbox_ex(mono, str, sizeof(str), &wrap.rect, &wrap.info), \
1957                 (void)(h = h_fixed * wrap.info.lines), \
1958                 (w = BLI_rctf_size_x(&wrap.rect))))
1959
1960 #define BUFF_MARGIN_X 2
1961 #define BUFF_MARGIN_Y 1
1962
1963   if (!rect && !rectf) {
1964     return;
1965   }
1966
1967   display_device = scene->display_settings.display_device;
1968   display = IMB_colormanagement_display_get_named(display_device);
1969
1970   if (stamp_data_template == NULL) {
1971     stampdata(scene, camera, &stamp_data, (scene->r.stamp & R_STAMP_HIDE_LABELS) == 0, true);
1972   }
1973   else {
1974     stampdata_from_template(&stamp_data, scene, stamp_data_template);
1975   }
1976
1977   /* TODO, do_versions */
1978   if (scene->r.stamp_font_id < 8) {
1979     scene->r.stamp_font_id = 12;
1980   }
1981
1982   /* set before return */
1983   BLF_size(mono, scene->r.stamp_font_id, 72);
1984   BLF_wordwrap(mono, width - (BUFF_MARGIN_X * 2));
1985
1986   BLF_buffer(mono, rectf, rect, width, height, channels, display);
1987   BLF_buffer_col(mono, scene->r.fg_stamp);
1988   pad = BLF_width_max(mono);
1989
1990   /* use 'h_fixed' rather than 'h', aligns better */
1991   h_fixed = BLF_height_max(mono);
1992   y_ofs = -BLF_descender(mono);
1993
1994   x = 0;
1995   y = height;
1996
1997   if (TEXT_SIZE_CHECK(stamp_data.file, w, h)) {
1998     /* Top left corner */
1999     y -= h;
2000
2001     /* also a little of space to the background. */
2002     buf_rectfill_area(rect,
2003                       rectf,
2004                       width,
2005                       height,
2006                       scene->r.bg_stamp,
2007                       display,
2008                       x - BUFF_MARGIN_X,
2009                       y - BUFF_MARGIN_Y,
2010                       w + BUFF_MARGIN_X,
2011                       y + h + BUFF_MARGIN_Y);
2012
2013     /* and draw the text. */
2014     BLF_position(mono, x, y + y_ofs, 0.0);
2015     BLF_draw_buffer(mono, stamp_data.file, BLF_DRAW_STR_DUMMY_MAX);
2016
2017     /* the extra pixel for background. */
2018     y -= BUFF_MARGIN_Y * 2;
2019   }
2020
2021   /* Top left corner, below File */
2022   if (TEXT_SIZE_CHECK(stamp_data.date, w, h)) {
2023     y -= h;
2024
2025     /* and space for background. */
2026     buf_rectfill_area(rect,
2027                       rectf,
2028                       width,
2029                       height,
2030                       scene->r.bg_stamp,
2031                       display,
2032                       0,
2033                       y - BUFF_MARGIN_Y,
2034                       w + BUFF_MARGIN_X,
2035                       y + h + BUFF_MARGIN_Y);
2036
2037     BLF_position(mono, x, y + y_ofs, 0.0);
2038     BLF_draw_buffer(mono, stamp_data.date, BLF_DRAW_STR_DUMMY_MAX);
2039
2040     /* the extra pixel for background. */
2041     y -= BUFF_MARGIN_Y * 2;
2042   }
2043
2044   /* Top left corner, below File, Date */
2045   if (TEXT_SIZE_CHECK(stamp_data.rendertime, w, h)) {
2046     y -= h;
2047
2048     /* and space for background. */
2049     buf_rectfill_area(rect,
2050                       rectf,
2051                       width,
2052                       height,
2053                       scene->r.bg_stamp,
2054                       display,
2055                       0,
2056                       y - BUFF_MARGIN_Y,
2057                       w + BUFF_MARGIN_X,
2058                       y + h + BUFF_MARGIN_Y);
2059
2060     BLF_position(mono, x, y + y_ofs, 0.0);
2061     BLF_draw_buffer(mono, stamp_data.rendertime, BLF_DRAW_STR_DUMMY_MAX);
2062
2063     /* the extra pixel for background. */
2064     y -= BUFF_MARGIN_Y * 2;
2065   }
2066
2067   /* Top left corner, below File, Date, Rendertime */
2068   if (TEXT_SIZE_CHECK(stamp_data.memory, w, h)) {
2069     y -= h;
2070
2071     /* and space for background. */
2072     buf_rectfill_area(rect,
2073                       rectf,
2074                       width,
2075                       height,
2076                       scene->r.bg_stamp,
2077                       display,
2078                       0,
2079                       y - BUFF_MARGIN_Y,
2080                       w + BUFF_MARGIN_X,
2081                       y + h + BUFF_MARGIN_Y);
2082
2083     BLF_position(mono, x, y + y_ofs, 0.0);
2084     BLF_draw_buffer(mono, stamp_data.memory, BLF_DRAW_STR_DUMMY_MAX);
2085
2086     /* the extra pixel for background. */
2087     y -= BUFF_MARGIN_Y * 2;
2088   }
2089
2090   /* Top left corner, below File, Date, Rendertime, Memory */
2091   if (TEXT_SIZE_CHECK(stamp_data.hostname, w, h)) {
2092     y -= h;
2093
2094     /* and space for background. */
2095     buf_rectfill_area(rect,
2096                       rectf,
2097                       width,
2098                       height,
2099                       scene->r.bg_stamp,
2100                       display,
2101                       0,
2102                       y - BUFF_MARGIN_Y,
2103                       w + BUFF_MARGIN_X,
2104                       y + h + BUFF_MARGIN_Y);
2105
2106     BLF_position(mono, x, y + y_ofs, 0.0);
2107     BLF_draw_buffer(mono, stamp_data.hostname, BLF_DRAW_STR_DUMMY_MAX);
2108
2109     /* the extra pixel for background. */
2110     y -= BUFF_MARGIN_Y * 2;
2111   }
2112
2113   /* Top left corner, below File, Date, Memory, Rendertime, Hostname */
2114   BLF_enable(mono, BLF_WORD_WRAP);
2115   if (TEXT_SIZE_CHECK_WORD_WRAP(stamp_data.note, w, h)) {
2116     y -= h;
2117
2118     /* and space for background. */
2119     buf_rectfill_area(rect,
2120                       rectf,
2121                       width,
2122                       height,
2123                       scene->r.bg_stamp,
2124                       display,
2125                       0,
2126                       y - BUFF_MARGIN_Y,
2127                       w + BUFF_MARGIN_X,
2128                       y + h + BUFF_MARGIN_Y);
2129
2130     BLF_position(mono, x, y + y_ofs + (h - h_fixed), 0.0);
2131     BLF_draw_buffer(mono, stamp_data.note, BLF_DRAW_STR_DUMMY_MAX);
2132   }
2133   BLF_disable(mono, BLF_WORD_WRAP);
2134
2135   x = 0;
2136   y = 0;
2137
2138   /* Bottom left corner, leaving space for timing */
2139   if (TEXT_SIZE_CHECK(stamp_data.marker, w, h)) {
2140
2141     /* extra space for background. */
2142     buf_rectfill_area(rect,
2143                       rectf,
2144                       width,
2145                       height,
2146                       scene->r.bg_stamp,
2147                       display,
2148                       x - BUFF_MARGIN_X,
2149                       y - BUFF_MARGIN_Y,
2150                       w + BUFF_MARGIN_X,
2151                       y + h + BUFF_MARGIN_Y);
2152
2153     /* and pad the text. */
2154     BLF_position(mono, x, y + y_ofs, 0.0);
2155     BLF_draw_buffer(mono, stamp_data.marker, BLF_DRAW_STR_DUMMY_MAX);
2156
2157     /* space width. */
2158     x += w + pad;
2159   }
2160
2161   /* Left bottom corner */
2162   if (TEXT_SIZE_CHECK(stamp_data.time, w, h)) {
2163
2164     /* extra space for background */
2165     buf_rectfill_area(rect,
2166                       rectf,
2167                       width,
2168                       height,
2169                       scene->r.bg_stamp,
2170                       display,
2171                       x - BUFF_MARGIN_X,
2172                       y,
2173                       x + w + BUFF_MARGIN_X,
2174                       y + h + BUFF_MARGIN_Y);
2175
2176     /* and pad the text. */
2177     BLF_position(mono, x, y + y_ofs, 0.0);
2178     BLF_draw_buffer(mono, stamp_data.time, BLF_DRAW_STR_DUMMY_MAX);
2179
2180     /* space width. */
2181     x += w + pad;
2182   }
2183
2184   if (TEXT_SIZE_CHECK(stamp_data.frame, w, h)) {
2185
2186     /* extra space for background. */
2187     buf_rectfill_area(rect,
2188                       rectf,
2189                       width,
2190                       height,
2191                       scene->r.bg_stamp,
2192                       display,
2193                       x - BUFF_MARGIN_X,
2194                       y - BUFF_MARGIN_Y,
2195                       x + w + BUFF_MARGIN_X,
2196                       y + h + BUFF_MARGIN_Y);
2197
2198     /* and pad the text. */
2199     BLF_position(mono, x, y + y_ofs, 0.0);
2200     BLF_draw_buffer(mono, stamp_data.frame, BLF_DRAW_STR_DUMMY_MAX);
2201
2202     /* space width. */
2203     x += w + pad;
2204   }
2205
2206   if (TEXT_SIZE_CHECK(stamp_data.camera, w, h)) {
2207
2208     /* extra space for background. */
2209     buf_rectfill_area(rect,
2210                       rectf,
2211                       width,
2212                       height,
2213                       scene->r.bg_stamp,
2214                       display,
2215                       x - BUFF_MARGIN_X,
2216                       y - BUFF_MARGIN_Y,
2217                       x + w + BUFF_MARGIN_X,
2218                       y + h + BUFF_MARGIN_Y);
2219     BLF_position(mono, x, y + y_ofs, 0.0);
2220     BLF_draw_buffer(mono, stamp_data.camera, BLF_DRAW_STR_DUMMY_MAX);
2221
2222     /* space width. */
2223     x += w + pad;
2224   }
2225
2226   if (TEXT_SIZE_CHECK(stamp_data.cameralens, w, h)) {
2227
2228     /* extra space for background. */
2229     buf_rectfill_area(rect,
2230                       rectf,
2231                       width,
2232                       height,
2233                       scene->r.bg_stamp,
2234                       display,
2235                       x - BUFF_MARGIN_X,
2236                       y - BUFF_MARGIN_Y,
2237                       x + w + BUFF_MARGIN_X,
2238                       y + h + BUFF_MARGIN_Y);
2239     BLF_position(mono, x, y + y_ofs, 0.0);
2240     BLF_draw_buffer(mono, stamp_data.cameralens, BLF_DRAW_STR_DUMMY_MAX);
2241   }
2242
2243   if (TEXT_SIZE_CHECK(stamp_data.scene, w, h)) {
2244
2245     /* Bottom right corner, with an extra space because blenfont is too strict! */
2246     x = width - w - 2;
2247
2248     /* extra space for background. */
2249     buf_rectfill_area(rect,
2250                       rectf,
2251                       width,
2252                       height,
2253                       scene->r.bg_stamp,
2254                       display,
2255                       x - BUFF_MARGIN_X,
2256                       y - BUFF_MARGIN_Y,
2257                       x + w + BUFF_MARGIN_X,
2258                       y + h + BUFF_MARGIN_Y);
2259
2260     /* and pad the text. */
2261     BLF_position(mono, x, y + y_ofs, 0.0);
2262     BLF_draw_buffer(mono, stamp_data.scene, BLF_DRAW_STR_DUMMY_MAX);
2263   }
2264
2265   if (TEXT_SIZE_CHECK(stamp_data.strip, w, h)) {
2266
2267     /* Top right corner, with an extra space because blenfont is too strict! */
2268     x = width - w - pad;
2269     y = height - h;
2270
2271     /* extra space for background. */
2272     buf_rectfill_area(rect,
2273                       rectf,
2274                       width,
2275                       height,
2276                       scene->r.bg_stamp,
2277                       display,
2278                       x - BUFF_MARGIN_X,
2279                       y - BUFF_MARGIN_Y,
2280                       x + w + BUFF_MARGIN_X,
2281                       y + h + BUFF_MARGIN_Y);
2282
2283     BLF_position(mono, x, y + y_ofs, 0.0);
2284     BLF_draw_buffer(mono, stamp_data.strip, BLF_DRAW_STR_DUMMY_MAX);
2285   }
2286
2287   /* cleanup the buffer. */
2288   BLF_buffer(mono, NULL, NULL, 0, 0, 0, NULL);
2289   BLF_wordwrap(mono, 0);
2290
2291 #undef TEXT_SIZE_CHECK
2292 #undef TEXT_SIZE_CHECK_WORD_WRAP
2293 #undef BUFF_MARGIN_X
2294 #undef BUFF_MARGIN_Y
2295 }
2296
2297 void BKE_render_result_stamp_info(Scene *scene,
2298                                   Object *camera,
2299                                   struct RenderResult *rr,
2300                                   bool allocate_only)
2301 {
2302   struct StampData *stamp_data;
2303
2304   if (!(scene && (scene->r.stamp & R_STAMP_ALL)) && !allocate_only) {
2305     return;
2306   }
2307
2308   if (!rr->stamp_data) {
2309     stamp_data = MEM_callocN(sizeof(StampData), "RenderResult.stamp_data");
2310   }
2311   else {
2312     stamp_data = rr->stamp_data;
2313   }
2314
2315   if (!allocate_only) {
2316     stampdata(scene, camera, stamp_data, 0, true);
2317   }
2318
2319   if (!rr->stamp_data) {
2320     rr->stamp_data = stamp_data;
2321   }
2322 }
2323
2324 struct StampData *BKE_stamp_info_from_scene_static(Scene *scene)
2325 {
2326   struct StampData *stamp_data;
2327
2328   if (!(scene && (scene->r.stamp & R_STAMP_ALL))) {
2329     return NULL;
2330   }
2331
2332   /* Memory is allocated here (instead of by the caller) so that the caller
2333    * doesn't have to know the size of the StampData struct. */
2334   stamp_data = MEM_callocN(sizeof(StampData), __func__);
2335   stampdata(scene, NULL, stamp_data, 0, false);
2336
2337   return stamp_data;
2338 }
2339
2340 static const char *stamp_metadata_fields[] = {
2341     "File",
2342     "Note",
2343     "Date",
2344     "Marker",
2345     "Time",
2346     "Frame",
2347     "FrameRange",
2348     "Camera",
2349     "Lens",
2350     "Scene",
2351     "Strip",
2352     "RenderTime",
2353     "Memory",
2354     "Hostname",
2355     NULL,
2356 };
2357
2358 /* Check whether the given metadata field name translates to a known field of
2359  * a stamp. */
2360 bool BKE_stamp_is_known_field(const char *field_name)
2361 {
2362   int i = 0;
2363   while (stamp_metadata_fields[i] != NULL) {
2364     if (STREQ(field_name, stamp_metadata_fields[i])) {
2365       return true;
2366     }
2367     i++;
2368   }
2369   return false;
2370 }
2371
2372 void BKE_stamp_info_callback(void *data,
2373                              struct StampData *stamp_data,
2374                              StampCallback callback,
2375                              bool noskip)
2376 {
2377   if ((callback == NULL) || (stamp_data == NULL)) {
2378     return;
2379   }
2380
2381 #define CALL(member, value_str) \
2382   if (noskip || stamp_data->member[0]) { \
2383     callback(data, value_str, stamp_data->member, sizeof(stamp_data->member)); \
2384   } \
2385   ((void)0)
2386
2387   /* TODO(sergey): Use stamp_metadata_fields somehow, or make it more generic
2388    * meta information to avoid duplication. */
2389   CALL(file, "File");
2390   CALL(note, "Note");
2391   CALL(date, "Date");
2392   CALL(marker, "Marker");
2393   CALL(time, "Time");
2394   CALL(frame, "Frame");
2395   CALL(frame_range, "FrameRange");
2396   CALL(camera, "Camera");
2397   CALL(cameralens, "Lens");
2398   CALL(scene, "Scene");
2399   CALL(strip, "Strip");
2400   CALL(rendertime, "RenderTime");
2401   CALL(memory, "Memory");
2402   CALL(hostname, "Hostname");
2403
2404   LISTBASE_FOREACH (StampDataCustomField *, custom_field, &stamp_data->custom_fields) {
2405     if (noskip || custom_field->value[0]) {
2406       callback(data, custom_field->key, custom_field->value, strlen(custom_field->value) + 1);
2407     }
2408   }
2409
2410 #undef CALL
2411 }
2412
2413 void BKE_render_result_stamp_data(RenderResult *rr, const char *key, const char *value)
2414 {
2415   StampData *stamp_data;
2416   if (rr->stamp_data == NULL) {
2417     rr->stamp_data = MEM_callocN(sizeof(StampData), "RenderResult.stamp_data");
2418   }
2419   stamp_data = rr->stamp_data;
2420   StampDataCustomField *field = MEM_mallocN(sizeof(StampDataCustomField),
2421                                             "StampData Custom Field");
2422   STRNCPY(field->key, key);
2423   field->value = BLI_strdup(value);
2424   BLI_addtail(&stamp_data->custom_fields, field);
2425 }
2426
2427 StampData *BKE_stamp_data_copy(const StampData *stamp_data)
2428 {
2429   if (stamp_data == NULL) {
2430     return NULL;
2431   }
2432
2433   StampData *stamp_datan = MEM_dupallocN(stamp_data);
2434   BLI_duplicatelist(&stamp_datan->custom_fields, &stamp_data->custom_fields);
2435
2436   LISTBASE_FOREACH (StampDataCustomField *, custom_fieldn, &stamp_datan->custom_fields) {
2437     custom_fieldn->value = MEM_dupallocN(custom_fieldn->value);
2438   }
2439
2440   return stamp_datan;
2441 }
2442
2443 void BKE_stamp_data_free(StampData *stamp_data)
2444 {
2445   if (stamp_data == NULL) {
2446     return;
2447   }
2448   LISTBASE_FOREACH (StampDataCustomField *, custom_field, &stamp_data->custom_fields) {
2449     MEM_freeN(custom_field->value);
2450   }
2451   BLI_freelistN(&stamp_data->custom_fields);
2452   MEM_freeN(stamp_data);
2453 }
2454
2455 /* wrap for callback only */
2456 static void metadata_set_field(void *data, const char *propname, char *propvalue, int UNUSED(len))
2457 {
2458   /* We know it is an ImBuf* because that's what we pass to BKE_stamp_info_callback. */
2459   struct ImBuf *imbuf = data;
2460   IMB_metadata_set_field(imbuf->metadata, propname, propvalue);
2461 }
2462
2463 static void metadata_get_field(void *data, const char *propname, char *propvalue, int len)
2464 {
2465   /* We know it is an ImBuf* because that's what we pass to BKE_stamp_info_callback. */
2466   struct ImBuf *imbuf = data;
2467   IMB_metadata_get_field(imbuf->metadata, propname, propvalue, len);
2468 }
2469
2470 void BKE_imbuf_stamp_info(RenderResult *rr, struct ImBuf *ibuf)
2471 {
2472   struct StampData *stamp_data = rr->stamp_data;
2473   IMB_metadata_ensure(&ibuf->metadata);
2474   BKE_stamp_info_callback(ibuf, stamp_data, metadata_set_field, false);
2475 }
2476
2477 static void metadata_copy_custom_fields(const char *field, const char *value, void *rr_v)
2478 {
2479   if (BKE_stamp_is_known_field(field)) {
2480     return;
2481   }
2482   RenderResult *rr = (RenderResult *)rr_v;
2483   BKE_render_result_stamp_data(rr, field, value);
2484 }
2485
2486 void BKE_stamp_info_from_imbuf(RenderResult *rr, struct ImBuf *ibuf)
2487 {
2488   if (rr->stamp_data == NULL) {
2489     rr->stamp_data = MEM_callocN(sizeof(StampData), "RenderResult.stamp_data");
2490   }
2491   struct StampData *stamp_data = rr->stamp_data;
2492   IMB_metadata_ensure(&ibuf->metadata);
2493   BKE_stamp_info_callback(ibuf, stamp_data, metadata_get_field, true);
2494   /* Copy render engine specific settings. */
2495   IMB_metadata_foreach(ibuf, metadata_copy_custom_fields, rr);
2496 }
2497
2498 bool BKE_imbuf_alpha_test(ImBuf *ibuf)
2499 {
2500   int tot;
2501   if (ibuf->rect_float) {
2502     const float *buf = ibuf->rect_float;
2503     for (tot = ibuf->x * ibuf->y; tot--; buf += 4) {
2504       if (buf[3] < 1.0f) {
2505         return true;
2506       }
2507     }
2508   }
2509   else if (ibuf->rect) {
2510     unsigned char *buf = (unsigned char *)ibuf->rect;
2511     for (tot = ibuf->x * ibuf->y; tot--; buf += 4) {
2512       if (buf[3] != 255) {
2513         return true;
2514       }
2515     }
2516   }
2517
2518   return false;
2519 }
2520
2521 /* note: imf->planes is ignored here, its assumed the image channels
2522  * are already set */
2523 void BKE_imbuf_write_prepare(ImBuf *ibuf, const ImageFormatData *imf)
2524 {
2525   char imtype = imf->imtype;
2526   char compress = imf->compress;
2527   char quality = imf->quality;
2528
2529   /* initialize all from image format */
2530   ibuf->foptions.flag = 0;
2531
2532   if (imtype == R_IMF_IMTYPE_IRIS) {
2533     ibuf->ftype = IMB_FTYPE_IMAGIC;
2534   }
2535 #ifdef WITH_HDR
2536   else if (imtype == R_IMF_IMTYPE_RADHDR) {
2537     ibuf->ftype = IMB_FTYPE_RADHDR;
2538   }
2539 #endif
2540   else if (ELEM(imtype,
2541                 R_IMF_IMTYPE_PNG,
2542                 R_IMF_IMTYPE_FFMPEG,
2543                 R_IMF_IMTYPE_H264,
2544                 R_IMF_IMTYPE_THEORA,
2545                 R_IMF_IMTYPE_XVID)) {
2546     ibuf->ftype = IMB_FTYPE_PNG;
2547
2548     if (imtype == R_IMF_IMTYPE_PNG) {
2549       if (imf->depth == R_IMF_CHAN_DEPTH_16) {
2550         ibuf->foptions.flag |= PNG_16BIT;
2551       }
2552
2553       ibuf->foptions.quality = compress;
2554     }
2555   }
2556 #ifdef WITH_DDS
2557   else if (imtype == R_IMF_IMTYPE_DDS) {
2558     ibuf->ftype = IMB_FTYPE_DDS;
2559   }
2560 #endif
2561   else if (imtype == R_IMF_IMTYPE_BMP) {
2562     ibuf->ftype = IMB_FTYPE_BMP;
2563   }
2564 #ifdef WITH_TIFF
2565   else if (imtype == R_IMF_IMTYPE_TIFF) {
2566     ibuf->ftype = IMB_FTYPE_TIF;
2567
2568     if (imf->depth == R_IMF_CHAN_DEPTH_16) {
2569       ibuf->foptions.flag |= TIF_16BIT;
2570     }
2571     if (imf->tiff_codec == R_IMF_TIFF_CODEC_NONE) {
2572       ibuf->foptions.flag |= TIF_COMPRESS_NONE;
2573     }
2574     else if (imf->tiff_codec == R_IMF_TIFF_CODEC_DEFLATE) {
2575       ibuf->foptions.flag |= TIF_COMPRESS_DEFLATE;
2576     }
2577     else if (imf->tiff_codec == R_IMF_TIFF_CODEC_LZW) {
2578       ibuf->foptions.flag |= TIF_COMPRESS_LZW;
2579     }
2580     else if (imf->tiff_codec == R_IMF_TIFF_CODEC_PACKBITS) {
2581       ibuf->foptions.flag |= TIF_COMPRESS_PACKBITS;
2582     }
2583   }
2584 #endif
2585 #ifdef WITH_OPENEXR
2586   else if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
2587     ibuf->ftype = IMB_FTYPE_OPENEXR;
2588     if (imf->depth == R_IMF_CHAN_DEPTH_16) {
2589       ibuf->foptions.flag |= OPENEXR_HALF;
2590     }
2591     ibuf->foptions.flag |= (imf->exr_codec & OPENEXR_COMPRESS);
2592
2593     if (!(imf->flag & R_IMF_FLAG_ZBUF)) {
2594       /* Signal for exr saving. */
2595       IMB_freezbuffloatImBuf(ibuf);
2596     }
2597   }
2598 #endif
2599 #ifdef WITH_CINEON
2600   else if (imtype == R_IMF_IMTYPE_CINEON) {
2601     ibuf->ftype = IMB_FTYPE_CINEON;
2602     if (imf->cineon_flag & R_IMF_CINEON_FLAG_LOG) {
2603       ibuf->foptions.flag |= CINEON_LOG;
2604     }
2605     if (imf->depth == R_IMF_CHAN_DEPTH_16) {
2606       ibuf->foptions.flag |= CINEON_16BIT;
2607     }
2608     else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
2609       ibuf->foptions.flag |= CINEON_12BIT;
2610     }
2611     else if (imf->depth == R_IMF_CHAN_DEPTH_10) {
2612       ibuf->foptions.flag |= CINEON_10BIT;
2613     }
2614   }
2615   else if (imtype == R_IMF_IMTYPE_DPX) {
2616     ibuf->ftype = IMB_FTYPE_DPX;
2617     if (imf->cineon_flag & R_IMF_CINEON_FLAG_LOG) {
2618       ibuf->foptions.flag |= CINEON_LOG;
2619     }
2620     if (imf->depth == R_IMF_CHAN_DEPTH_16) {
2621       ibuf->foptions.flag |= CINEON_16BIT;
2622     }
2623     else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
2624       ibuf->foptions.flag |= CINEON_12BIT;
2625     }
2626     else if (imf->depth == R_IMF_CHAN_DEPTH_10) {
2627       ibuf->foptions.flag |= CINEON_10BIT;
2628     }
2629   }
2630 #endif
2631   else if (imtype == R_IMF_IMTYPE_TARGA) {
2632     ibuf->ftype = IMB_FTYPE_TGA;
2633   }
2634   else if (imtype == R_IMF_IMTYPE_RAWTGA) {
2635     ibuf->ftype = IMB_FTYPE_TGA;
2636     ibuf->foptions.flag = RAWTGA;
2637   }
2638 #ifdef WITH_OPENJPEG
2639   else if (imtype == R_IMF_IMTYPE_JP2) {
2640     if (quality < 10) {
2641       quality = 90;
2642     }
2643     ibuf->ftype = IMB_FTYPE_JP2;
2644     ibuf->foptions.quality = quality;
2645
2646     if (imf->depth == R_IMF_CHAN_DEPTH_16) {
2647       ibuf->foptions.flag |= JP2_16BIT;
2648     }
2649     else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
2650       ibuf->foptions.flag |= JP2_12BIT;
2651     }
2652
2653     if (imf->jp2_flag & R_IMF_JP2_FLAG_YCC) {
2654       ibuf->foptions.flag |= JP2_YCC;
2655     }
2656
2657     if (imf->jp2_flag & R_IMF_JP2_FLAG_CINE_PRESET) {
2658       ibuf->foptions.flag |= JP2_CINE;
2659       if (imf->jp2_flag & R_IMF_JP2_FLAG_CINE_48) {
2660         ibuf->foptions.flag |= JP2_CINE_48FPS;
2661       }
2662     }
2663
2664     if (imf->jp2_codec == R_IMF_JP2_CODEC_JP2) {
2665       ibuf->foptions.flag |= JP2_JP2;
2666     }
2667     else if (imf->jp2_codec == R_IMF_JP2_CODEC_J2K) {
2668       ibuf->foptions.flag |= JP2_J2K;
2669     }
2670     else {
2671       BLI_assert(!"Unsupported jp2 codec was specified in im_format->jp2_codec");
2672     }
2673   }
2674 #endif
2675   else {
2676     /* R_IMF_IMTYPE_JPEG90, etc. default we save jpegs */
2677     if (quality < 10) {
2678       quality = 90;
2679     }
2680     ibuf->ftype = IMB_FTYPE_JPG;
2681     ibuf->foptions.quality = quality;
2682   }
2683 }
2684
2685 int BKE_imbuf_write(ImBuf *ibuf, const char *name, const ImageFormatData *imf)
2686 {
2687   int ok;
2688
2689   BKE_imbuf_write_prepare(ibuf, imf);
2690
2691   BLI_make_existing_file(name);
2692
2693   ok = IMB_saveiff(ibuf, name, IB_rect | IB_zbuf | IB_zbuffloat);
2694   if (ok == 0) {
2695     perror(name);
2696   }
2697
2698   return (ok);
2699 }
2700
2701 /* same as BKE_imbuf_write() but crappy workaround not to permanently modify
2702  * _some_, values in the imbuf */
2703 int BKE_imbuf_write_as(ImBuf *ibuf, const char *name, ImageFormatData *imf, const bool save_copy)
2704 {
2705   ImBuf ibuf_back = *ibuf;
2706   int ok;
2707
2708   /* all data is rgba anyway,
2709    * this just controls how to save for some formats */
2710   ibuf->planes = imf->planes;
2711
2712   ok = BKE_imbuf_write(ibuf, name, imf);
2713
2714   if (save_copy) {
2715     /* note that we are not restoring _all_ settings */
2716     ibuf->planes = ibuf_back.planes;
2717     ibuf->ftype = ibuf_back.ftype;
2718     ibuf->foptions = ibuf_back.foptions;
2719   }
2720
2721   return ok;
2722 }
2723
2724 int BKE_imbuf_write_stamp(Scene *scene,
2725                           struct RenderResult *rr,
2726                           ImBuf *ibuf,
2727                           const char *name,
2728                           const struct ImageFormatData *imf)
2729 {
2730   if (scene && scene->r.stamp & R_STAMP_ALL) {
2731     BKE_imbuf_stamp_info(rr, ibuf);
2732   }
2733
2734   return BKE_imbuf_write(ibuf, name, imf);
2735 }
2736
2737 static void do_makepicstring(char *string,
2738                              const char *base,
2739                              const char *relbase,
2740                              int frame,
2741                              const char imtype,
2742                              const ImageFormatData *im_format,
2743                              const short use_ext,
2744                              const short use_frames,
2745                              const char *suffix)
2746 {
2747   if (string == NULL) {
2748     return;
2749   }
2750   BLI_strncpy(string, base, FILE_MAX - 10); /* weak assumption */
2751   BLI_path_abs(string, relbase);
2752
2753   if (use_frames) {
2754     BLI_path_frame(string, frame, 4);
2755   }
2756
2757   if (suffix) {
2758     BLI_path_suffix(string, FILE_MAX, suffix, "");
2759   }
2760
2761   if (use_ext) {
2762     do_add_image_extension(string, imtype, im_format);
2763   }
2764 }
2765
2766 void BKE_image_path_from_imformat(char *string,
2767                                   const char *base,
2768                                   const char *relbase,
2769                                   int frame,
2770                                   const ImageFormatData *im_format,
2771                                   const bool use_ext,
2772                                   const bool use_frames,
2773                                   const char *suffix)
2774 {
2775   do_makepicstring(
2776       string, base, relbase, frame, im_format->imtype, im_format, use_ext, use_frames, suffix);
2777 }
2778
2779 void BKE_image_path_from_imtype(char *string,
2780                                 const char *base,
2781                                 const char *relbase,
2782                                 int frame,
2783                                 const char imtype,
2784                                 const bool use_ext,
2785                                 const bool use_frames,
2786                                 const char *view)
2787 {
2788   do_makepicstring(string, base, relbase, frame, imtype, NULL, use_ext, use_frames, view);
2789 }
2790
2791 struct anim *openanim_noload(const char *name,
2792                              int flags,
2793                              int streamindex,
2794                              char colorspace[IMA_MAX_SPACE])
2795 {
2796   struct anim *anim;
2797
2798   anim = IMB_open_anim(name, flags, streamindex, colorspace);
2799   return anim;
2800 }
2801
2802 /* used by sequencer too */
2803 struct anim *openanim(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE])
2804 {
2805   struct anim *anim;
2806   struct ImBuf *ibuf;
2807
2808   anim = IMB_open_anim(name, flags, streamindex, colorspace);
2809   if (anim == NULL) {
2810     return NULL;
2811   }
2812
2813   ibuf = IMB_anim_absolute(anim, 0, IMB_TC_NONE, IMB_PROXY_NONE);
2814   if (ibuf == NULL) {
2815     if (BLI_exists(name)) {
2816       printf("not an anim: %s\n", name);
2817     }
2818     else {
2819       printf("anim file doesn't exist: %s\n", name);
2820     }
2821     IMB_free_anim(anim);
2822     return NULL;
2823   }
2824   IMB_freeImBuf(ibuf);
2825
2826   return (anim);
2827 }
2828
2829 /* ************************* New Image API *************** */
2830
2831 /* Notes about Image storage
2832  * - packedfile
2833  *   -> written in .blend
2834  * - filename
2835  *   -> written in .blend
2836  * - movie
2837  *   -> comes from packedfile or filename
2838  * - renderresult
2839  *   -> comes from packedfile or filename
2840  * - listbase
2841  *   -> ibufs from exrhandle
2842  * - flipbook array
2843  *   -> ibufs come from movie, temporary renderresult or sequence
2844  * - ibuf
2845  *   -> comes from packedfile or filename or generated
2846  */
2847
2848 /* forces existence of 1 Image for renderout or nodes, returns Image */
2849 /* name is only for default, when making new one */
2850 Image *BKE_image_verify_viewer(Main *bmain, int type, const char *name)
2851 {
2852   Image *ima;
2853
2854   for (ima = bmain->images.first; ima; ima = ima->id.next) {
2855     if (ima->source == IMA_SRC_VIEWER) {
2856       if (ima->type == type) {
2857         break;
2858       }
2859     }
2860   }
2861
2862   if (ima == NULL) {
2863     ima = image_alloc(bmain, name, IMA_SRC_VIEWER, type);
2864   }
2865
2866   /* happens on reload, imagewindow cannot be image user when hidden*/
2867   if (ima->id.us == 0) {
2868     id_us_plus(&ima->id);
2869   }
2870
2871   return ima;
2872 }
2873
2874 static void image_viewer_create_views(const RenderData *rd, Image *ima)
2875 {
2876   if ((rd->scemode & R_MULTIVIEW) == 0) {
2877     image_add_view(ima, "", "");
2878   }
2879   else {
2880     SceneRenderView *srv;
2881     for (srv = rd->views.first; srv; srv = srv->next) {
2882       if (BKE_scene_multiview_is_render_view_active(rd, srv) == false) {
2883         continue;
2884       }
2885       image_add_view(ima, srv->name, "");
2886     }
2887   }
2888 }
2889
2890 /* Reset the image cache and views when the Viewer Nodes views don't match the scene views */
2891 void BKE_image_verify_viewer_views(const RenderData *rd, Image *ima, ImageUser *iuser)
2892 {
2893   bool do_reset;
2894   const bool is_multiview = (rd->scemode & R_MULTIVIEW) != 0;
2895
2896   BLI_thread_lock(LOCK_DRAW_IMAGE);
2897
2898   if (!BKE_scene_multiview_is_stereo3d(rd)) {
2899     iuser->flag &= ~IMA_SHOW_STEREO;
2900   }
2901
2902   /* see if all scene render views are in the image view list */
2903   do_reset = (BKE_scene_multiview_num_views_get(rd) != BLI_listbase_count(&ima->views));
2904
2905   /* multiview also needs to be sure all the views are synced */
2906   if (is_multiview && !do_reset) {
2907     SceneRenderView *srv;
2908     ImageView *iv;
2909
2910     for (iv = ima->views.first; iv; iv = iv->next) {
2911       srv = BLI_findstring(&rd->views, iv->name, offsetof(SceneRenderView, name));
2912       if ((srv == NULL) || (BKE_scene_multiview_is_render_view_active(rd, srv) == false)) {
2913         do_reset = true;
2914         break;
2915       }
2916     }
2917   }
2918
2919   if (do_reset) {
2920     BLI_spin_lock(&image_spin);
2921
2922     image_free_cached_frames(ima);
2923     BKE_image_free_views(ima);
2924
2925     /* add new views */
2926     image_viewer_create_views(rd, ima);
2927
2928     BLI_spin_unlock(&image_spin);
2929   }
2930
2931   BLI_thread_unlock(LOCK_DRAW_IMAGE);
2932 }
2933
2934 static void image_walk_ntree_all_users(bNodeTree *ntree,
2935                                        void *customdata,
2936                                        void callback(Image *ima,
2937                                                      ImageUser *iuser,
2938                                                      void *customdata))
2939 {
2940   switch (ntree->type) {
2941     case NTREE_SHADER:
2942       for (bNode *node = ntree->nodes.first; node; node = node->next) {
2943         if (node->id) {
2944           if (node->type == SH_NODE_TEX_IMAGE) {
2945             NodeTexImage *tex = node->storage;
2946             Image *ima = (Image *)node->id;
2947             callback(ima, &tex->iuser, customdata);
2948           }
2949           if (node->type == SH_NODE_TEX_ENVIRONMENT) {
2950             NodeTexImage *tex = node->storage;
2951             Image *ima = (Image *)node->id;
2952             callback(ima, &tex->iuser, customdata);
2953           }
2954         }
2955       }
2956       break;
2957     case NTREE_TEXTURE:
2958       for (bNode *node = ntree->nodes.first; node; node = node->next) {
2959         if (node->id && node->type == TEX_NODE_IMAGE) {
2960           Image *ima = (Image *)node->id;
2961           ImageUser *iuser = node->storage;
2962           callback(ima, iuser, customdata);
2963         }
2964       }
2965       break;
2966     case NTREE_COMPOSIT:
2967       for (bNode *node = ntree->nodes.first; node; node = node->next) {
2968         if (node->id && node->type == CMP_NODE_IMAGE) {
2969           Image *ima = (Image *)node->id;
2970           ImageUser *iuser = node->storage;
2971           callback(ima, iuser, customdata);
2972         }
2973       }
2974       break;
2975   }
2976 }
2977
2978 static void image_walk_id_all_users(ID *id,
2979                                     bool skip_nested_nodes,
2980                                     void *customdata,
2981                                     void callback(Image *ima, ImageUser *iuser, void *customdata))
2982 {
2983   switch (GS(id->name)) {
2984     case ID_OB: {
2985       Object *ob = (Object *)id;
2986       if (ob->empty_drawtype == OB_EMPTY_IMAGE && ob->data) {
2987         callback(ob->data, ob->iuser, customdata);
2988       }
2989       break;
2990     }
2991     case ID_MA: {
2992       Material *ma = (Material *)id;
2993       if (ma->nodetree && ma->use_nodes && !skip_nested_nodes) {
2994         image_walk_ntree_all_users(ma->nodetree, customdata, callback);
2995       }
2996       break;
2997     }
2998     case ID_LA: {
2999       Light *light = (Light *)id;
3000       if (light->nodetree && light->use_nodes && !skip_nested_nodes) {
3001         image_walk_ntree_all_users(light->nodetree, customdata, callback);
3002       }
3003       break;
3004     }
3005     case ID_WO: {
3006       World *world = (World *)id;
3007       if (world->nodetree && world->use_nodes && !skip_nested_nodes) {
3008         image_walk_ntree_all_users(world->nodetree, customdata, callback);
3009       }
3010       break;
3011     }
3012     case ID_TE: {
3013       Tex *tex = (Tex *)id;
3014       if (tex->type == TEX_IMAGE && tex->ima) {
3015         callback(tex->ima, &tex->iuser, customdata);
3016       }
3017       if (tex->nodetree && tex->use_nodes && !skip_nested_nodes) {
3018         image_walk_ntree_all_users(tex->nodetree, customdata, callback);
3019       }
3020       break;
3021     }
3022     case ID_NT: {
3023       bNodeTree *ntree = (bNodeTree *)id;
3024       image_walk_ntree_all_users(ntree, customdata, callback);
3025       break;
3026     }
3027     case ID_CA: {
3028       Camera *cam = (Camera *)id;
3029       for (CameraBGImage *bgpic = cam->bg_images.first; bgpic; bgpic = bgpic->next) {
3030         callback(bgpic->ima, &bgpic->iuser, customdata);
3031       }
3032       break;
3033     }
3034     case ID_WM: {
3035       wmWindowManager *wm = (wmWindowManager *)id;
3036       for (wmWindow *win = wm->windows.first; win; win = win->next) {
3037         const bScreen *screen = BKE_workspace_active_screen_get(win->workspace_hook);
3038
3039         for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
3040           if (sa->spacetype == SPACE_IMAGE) {
3041             SpaceImage *sima = sa->spacedata.first;
3042             callback(sima->image, &sima->iuser, customdata);
3043           }
3044         }
3045       }
3046       break;
3047     }
3048     case ID_SCE: {
3049       Scene *scene = (Scene *)id;
3050       if (scene->nodetree && scene->use_nodes && !skip_nested_nodes) {
3051         image_walk_ntree_all_users(scene->nodetree, customdata, callback);
3052       }
3053     }
3054     default:
3055       break;
3056   }
3057 }
3058
3059 void BKE_image_walk_all_users(const Main *mainp,
3060                               void *customdata,
3061                               void callback(Image *ima, ImageUser *iuser, void *customdata))
3062 {
3063   for (Scene *scene = mainp->scenes.first; scene; scene = scene->id.next) {
3064     image_walk_id_all_users(&scene->id, false, customdata, callback);
3065   }
3066
3067   for (Object *ob = mainp->objects.first; ob; ob = ob->id.next) {
3068     image_walk_id_all_users(&ob->id, false, customdata, callback);
3069   }
3070
3071   for (bNodeTree *ntree = mainp->nodetrees.first; ntree; ntree = ntree->id.next) {
3072     image_walk_id_all_users(&ntree->id, false, customdata, callback);
3073   }
3074
3075   for (Material *ma = mainp->materials.first; ma; ma = ma->id.next) {
3076     image_walk_id_all_users(&ma->id, false, customdata, callback);
3077   }
3078
3079   for (Light *light = mainp->materials.first; light; light = light->id.next) {
3080     image_walk_id_all_users(&light->id, false, customdata, callback);
3081   }
3082
3083   for (World *world = mainp->materials.first; world; world = world->id.next) {
3084     image_walk_id_all_users(&world->id, false, customdata, callback);
3085   }
3086
3087   for (Tex *tex = mainp->textures.first; tex; tex = tex->id.next) {
3088     image_walk_id_all_users(&tex->id, false, customdata, callback);
3089   }
3090
3091   for (Camera *cam = mainp->cameras.first; cam; cam = cam->id.next) {
3092     image_walk_id_all_users(&cam->id, false, customdata, callback);
3093   }
3094
3095   for (wmWindowManager *wm = mainp->wm.first; wm; wm = wm->id.next) { /* only 1 wm */
3096     image_walk_id_all_users(&wm->id, false, customdata, callback);
3097   }
3098 }
3099
3100 static void image_tag_frame_recalc(Image *ima, ImageUser *iuser, void *customdata)
3101 {
3102   Image *changed_image = customdata;
3103
3104   if (ima == changed_image && BKE_image_is_animated(ima)) {
3105     iuser->flag |= IMA_NEED_FRAME_RECALC;
3106     iuser->ok = 1;
3107   }
3108 }
3109
3110 static void image_tag_reload(Image *ima, ImageUser *iuser, void *customdata)
3111 {
3112   Image *changed_image = customdata;
3113
3114   if (ima == changed_image) {
3115     iuser->ok = 1;
3116     if (iuser->scene) {
3117       image_update_views_format(ima, iuser);
3118     }
3119   }
3120 }
3121
3122 void BKE_imageuser_default(ImageUser *iuser)
3123 {
3124   memset(iuser, 0, sizeof(ImageUser));
3125   iuser->ok = true;
3126   iuser->frames = 100;
3127   iuser->sfra = 1;
3128 }
3129
3130 void BKE_image_init_imageuser(Image *ima, ImageUser *iuser)
3131 {
3132   RenderResult *rr = ima->rr;
3133
3134   iuser->multi_index = 0;
3135   iuser->layer = iuser->pass = iuser->view = 0;
3136
3137   if (rr) {
3138     BKE_image_multilayer_index(rr, iuser);
3139   }
3140 }
3141
3142 void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
3143 {
3144   if (ima == NULL) {
3145     return;
3146   }
3147
3148   BLI_spin_lock(&image_spin);
3149
3150   switch (signal) {
3151     case IMA_SIGNAL_FREE:
3152       BKE_image_free_buffers(ima);
3153
3154       if (iuser) {
3155         iuser->ok = 1;
3156         if (iuser->scene) {
3157           image_update_views_format(ima, iuser);
3158         }
3159       }
3160       break;
3161     case IMA_SIGNAL_SRC_CHANGE:
3162       if (ima->type == IMA_TYPE_UV_TEST) {
3163         if (ima->source != IMA_SRC_GENERATED) {
3164           ima->type = IMA_TYPE_IMAGE;
3165         }
3166       }
3167
3168       if (ima->source == IMA_SRC_GENERATED) {
3169         if (ima->gen_x == 0 || ima->gen_y == 0) {
3170           ImBuf *ibuf = image_get_cached_ibuf_for_index_frame(ima, IMA_NO_INDEX, 0);
3171           if (ibuf) {
3172             ima->gen_x = ibuf->x;
3173             ima->gen_y = ibuf->y;
3174             IMB_freeImBuf(ibuf);
3175           }
3176         }
3177
3178         /* Changing source type to generated will likely change file format
3179          * used by generated image buffer. Saving different file format to
3180          * the old name might confuse other applications.
3181          *
3182          * Here we ensure original image path wouldn't be used when saving
3183          * generated image.
3184          */
3185         ima->name[0] = '\0';
3186       }
3187
3188       /* image buffers for non-sequence multilayer will share buffers with RenderResult,
3189        * however sequence multilayer will own buffers. Such logic makes switching from
3190        * single multilayer file to sequence completely unstable
3191        * since changes in nodes seems this workaround isn't needed anymore, all sockets
3192        * are nicely detecting anyway, but freeing buffers always here makes multilayer
3193        * sequences behave stable
3194        */
3195       BKE_image_free_buffers(ima);
3196
3197       ima->ok = 1;
3198       if (iuser) {
3199         image_tag_frame_recalc(ima, iuser, ima);
3200       }
3201       BKE_image_walk_all_users(bmain, ima, image_tag_frame_recalc);
3202
3203       break;
3204
3205     case IMA_SIGNAL_RELOAD:
3206       /* try to repack file */
3207       if (BKE_image_has_packedfile(ima)) {
3208         const int totfiles = image_num_files(ima);
3209
3210         if (totfiles != BLI_listbase_count_at_most(&ima->packedfiles, totfiles + 1)) {
3211           /* in case there are new available files to be loaded */
3212           image_free_packedfiles(ima);
3213           BKE_image_packfiles(NULL, ima, ID_BLEND_PATH(bmain, &ima->id));
3214         }
3215         else {
3216           ImagePackedFile *imapf;
3217           for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
3218             PackedFile *pf;
3219             pf = newPackedFile(NULL, imapf->filepath, ID_BLEND_PATH(bmain, &ima->id));
3220             if (pf) {
3221               freePackedFile(imapf->packedfile);
3222               imapf->packedfile = pf;
3223             }
3224             else {
3225               printf("ERROR: Image \"%s\" not available. Keeping packed image\n", imapf->filepath);
3226             }
3227           }
3228         }
3229
3230         if (BKE_image_has_packedfile(ima)) {
3231           BKE_image_free_buffers(ima);
3232         }
3233       }
3234       else {
3235         BKE_image_free_buffers(ima);
3236       }
3237
3238       if (iuser) {
3239         image_tag_reload(ima, iuser, ima);
3240       }
3241       BKE_image_walk_all_users(bmain, ima, image_tag_reload);
3242       break;
3243     case IMA_SIGNAL_USER_NEW_IMAGE:
3244       if (iuser) {
3245         iuser->ok = 1;
3246         if (ima->source == IMA_SRC_FILE || ima->source == IMA_SRC_SEQUENCE) {
3247           if (ima->type == IMA_TYPE_MULTILAYER) {
3248             BKE_image_init_imageuser(ima, iuser);
3249           }
3250         }
3251       }
3252       break;
3253     case IMA_SIGNAL_COLORMANAGE:
3254       BKE_image_free_buffers(ima);
3255
3256       ima->ok = 1;
3257
3258       if (iuser) {
3259         iuser->ok = 1;
3260       }
3261
3262       break;
3263   }
3264
3265   BLI_spin_unlock(&image_spin);
3266
3267   /* don't use notifiers because they are not 100% sure to succeeded
3268    * this also makes sure all scenes are accounted for. */
3269   {
3270     Scene *scene;
3271     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
3272       if (scene->nodetree) {
3273         nodeUpdateID(scene->nodetree, &ima->id);
3274       }
3275     }
3276   }
3277 }
3278
3279 /* return renderpass for a given pass index and active view */
3280 /* fallback to available if there are missing passes for active view */
3281 static RenderPass *image_render_pass_get(RenderLayer *rl,
3282                                          const int pass,
3283                                          const int view,
3284                                          int *r_passindex)
3285 {
3286   RenderPass *rpass_ret = NULL;
3287   RenderPass *rpass;
3288
3289   int rp_index = 0;
3290   const char *rp_name = "";
3291
3292   for (rpass = rl->passes.first; rpass; rpass = rpass->next, rp_index++) {
3293     if (rp_index == pass) {
3294       rpass_ret = rpass;
3295       if (view == 0) {
3296         /* no multiview or left eye */
3297         break;
3298       }
3299       else {
3300         rp_name = rpass->name;
3301       }
3302     }
3303     /* multiview */
3304     else if (rp_name[0] && STREQ(rpass->name, rp_name) && (rpass->view_id == view)) {
3305       rpass_ret = rpass;
3306       break;
3307     }
3308   }
3309
3310   /* fallback to the first pass in the layer */
3311   if (rpass_ret == NULL) {
3312     rp_index = 0;
3313     rpass_ret = rl->passes.first;
3314   }
3315
3316   if (r_passindex) {
3317     *r_passindex = (rpass == rpass_ret ? rp_index : pass);
3318   }
3319
3320   return rpass_ret;
3321 }
3322
3323 /* if layer or pass changes, we need an index for the imbufs list */
3324 /* note it is called for rendered results, but it doesn't use the index! */
3325 /* and because rendered results use fake layer/passes, don't correct for wrong indices here */
3326 RenderPass *BKE_image_multilayer_index(RenderResult *rr, ImageUser *iuser)
3327 {
3328   RenderLayer *rl;
3329   RenderPass *rpass = NULL;
3330
3331   if (rr == NULL) {
3332     return NULL;
3333   }
3334
3335   if (iuser) {
3336     short index = 0, rv_index, rl_index = 0;
3337     bool is_stereo = (iuser->flag & IMA_SHOW_STEREO) && RE_RenderResult_is_stereo(rr);
3338
3339     rv_index = is_stereo ? iuser->multiview_eye : iuser->view;
3340     if (RE_HasCombinedLayer(rr)) {
3341       rl_index += 1;
3342     }
3343
3344     for (rl = rr->layers.first; rl; rl = rl->next, rl_index++) {
3345       if (iuser->layer == rl_index) {
3346         int rp_index;
3347         rpass = image_render_pass_get(rl, iuser->pass, rv_index, &rp_index);
3348         iuser->multi_index = index + rp_index;
3349         break;
3350       }
3351       else {
3352         index += BLI_listbase_count(&rl->passes);
3353       }
3354     }
3355   }
3356
3357   return rpass;
3358 }
3359
3360 void BKE_image_multiview_index(Image *ima, ImageUser *iuser)
3361 {
3362   if (iuser) {
3363     bool is_stereo = BKE_image_is_stereo(ima) && (iuser->flag & IMA_SHOW_STEREO);
3364     if (is_stereo) {
3365       iuser->multi_index = iuser->multiview_eye;
3366     }
3367     else {
3368       if ((iuser->view < 0) ||
3369           (iuser->view >= BLI_listbase_count_at_most(&ima->views, iuser->view + 1))) {
3370         iuser->multi_index = iuser->view = 0;
3371       }
3372       else {
3373         iuser->multi_index = iuser->view;
3374       }
3375     }
3376   }
3377 }
3378
3379 /* if layer or pass changes, we need an index for the imbufs list */
3380 /* note it is called for rendered results, but it doesn't use the index! */
3381 /* and because rendered results use fake layer/passes, don't correct for wrong indices here */
3382 bool BKE_image_is_multilayer(Image *ima)
3383 {
3384   if (ELEM(ima->source, IMA_SRC_FILE, IMA_SRC_SEQUENCE)) {
3385     if (ima->type == IMA_TYPE_MULTILAYER) {
3386       return true;
3387     }
3388   }
3389   else if (ima->source == IMA_SRC_VIEWER) {
3390     if (ima->type == IMA_TYPE_R_RESULT) {
3391       return true;
3392     }
3393   }
3394   return false;
3395 }
3396
3397 bool BKE_image_is_multiview(Image *ima)
3398 {
3399   ImageView *view = ima->views.first;
3400   return (view && (view->next || view->name[0]));
3401 }
3402
3403 bool BKE_image_is_stereo(Image *ima)
3404 {
3405   return BKE_image_is_multiview(ima) &&
3406          (BLI_findstring(&ima->views, STEREO_LEFT_NAME, offsetof(ImageView, name)) &&
3407           BLI_findstring(&ima->views, STEREO_RIGHT_NAME, offsetof(ImageView, name)));
3408 }
3409
3410 static void image_init_multilayer_multiview(Image *ima, RenderResult *rr)
3411 {
3412   /* update image views from render views, but only if they actually changed,
3413    * to avoid invalid memory access during render. ideally these should always
3414    * be acquired with a mutex along with the render result, but there are still
3415    * some places with just an image pointer that need to access views */
3416   if (rr && BLI_listbase_count(&ima->views) == BLI_listbase_count(&rr->views)) {
3417     ImageView *iv = ima->views.first;
3418     RenderView *rv = rr->views.first;
3419     bool modified = false;
3420     for (; rv; rv = rv->next, iv = iv->next) {
3421       modified |= !STREQ(rv->name, iv->name);
3422     }
3423     if (!modified) {
3424       return;
3425     }
3426   }
3427
3428   BKE_image_free_views(ima);
3429
3430   if (rr) {
3431     for (RenderView *rv = rr->views.first; rv; rv = rv->next) {
3432       ImageView *iv = MEM_callocN(sizeof(ImageView), "Viewer Image View");
3433       STRNCPY(iv->name, rv->name);
3434       BLI_addtail(&ima->views, iv);
3435     }
3436   }
3437 }
3438
3439 RenderResult *BKE_image_acquire_renderresult(Scene *scene, Image *ima)
3440 {
3441   RenderResult *rr = NULL;
3442   if (ima->rr) {
3443     rr = ima->rr;
3444   }
3445   else if (ima->type == IMA_TYPE_R_RESULT) {
3446     if (ima->render_slot == ima->last_render_slot) {
3447       rr = RE_AcquireResultRead(RE_GetSceneRender(scene));
3448     }
3449     else {
3450       rr = BKE_image_get_renderslot(ima, ima->render_slot)->render;
3451     }
3452
3453     /* set proper views */
3454     image_init_multilayer_multiview(ima, rr);
3455   }
3456
3457   return rr;
3458 }
3459
3460 void BKE_image_release_renderresult(Scene *scene, Image *ima)
3461 {
3462   if (ima->rr) {
3463     /* pass */
3464   }
3465   else if (ima->type == IMA_TYPE_R_RESULT) {
3466     if (ima->render_slot == ima->last_render_slot) {
3467       RE_ReleaseResult(RE_GetSceneRender(scene));
3468     }
3469   }
3470 }
3471
3472 bool BKE_image_is_openexr(struct Image *ima)
3473 {
3474 #ifdef WITH_OPENEXR
3475   if (ELEM(ima->source, IMA_SRC_FILE, IMA_SRC_SEQUENCE)) {
3476     return BLI_path_extension_check(ima->name, ".exr");
3477   }
3478 #else
3479   UNUSED_VARS(ima);
3480 #endif
3481   return false;
3482 }
3483
3484 void BKE_image_backup_render(Scene *scene, Image *ima, bool free_current_slot)
3485 {
3486   /* called right before rendering, ima->renderslots contains render
3487    * result pointers for everything but the current render */
3488   Render *re = RE_GetSceneRender(scene);
3489
3490   /* Ensure we always have a valid render slot. */
3491   if (!ima->renderslots.first) {
3492     BKE_image_add_renderslot(ima, NULL);
3493     ima->render_slot = 0;
3494     ima->last_render_slot = 0;
3495   }
3496   else if (ima->render_slot >= BLI_listbase_count(&ima->renderslots)) {
3497     ima->render_slot = 0;
3498     ima->last_render_slot = 0;
3499   }
3500
3501   RenderSlot *last_slot = BKE_image_get_renderslot(ima, ima->last_render_slot);
3502   RenderSlot *cur_slot = BKE_image_get_renderslot(ima, ima->render_slot);
3503
3504   if (last_slot && ima->render_slot != ima->last_render_slot) {
3505     last_slot->render = NULL;
3506     RE_SwapResult(re, &last_slot->render);
3507
3508     if (cur_slot->render) {
3509       if (free_current_slot) {
3510         BKE_image_clear_renderslot(ima, NULL, ima->render_slot);
3511       }
3512       else {
3513         RE_SwapResult(re, &cur_slot->render);
3514       }
3515     }
3516   }
3517
3518   ima->last_render_slot = ima->render_slot;
3519 }
3520
3521 /**************************** multiview load openexr *********************************/
3522
3523 static void image_add_view(Image *ima, const char *viewname, const char *filepath)
3524 {
3525   ImageView *iv;
3526
3527   iv = MEM_mallocN(sizeof(ImageView), "Viewer Image View");
3528   STRNCPY(iv->name, viewname);
3529   STRNCPY(iv->filepath, filepath);
3530
3531   /* For stereo drawing we need to ensure:
3532    * STEREO_LEFT_NAME  == STEREO_LEFT_ID and
3533    * STEREO_RIGHT_NAME == STEREO_RIGHT_ID */
3534
3535   if (STREQ(viewname, STEREO_LEFT_NAME)) {
3536     BLI_addhead(&ima->views, iv);
3537   }
3538   else if (STREQ(viewname, STEREO_RIGHT_NAME)) {
3539     ImageView *left_iv = BLI_findstring(&ima->views, STEREO_LEFT_NAME, offsetof(ImageView, name));
3540
3541     if (left_iv == NULL) {
3542       BLI_addhead(&ima->views, iv);
3543     }
3544     else {
3545       BLI_insertlinkafter(&ima->views, left_iv, iv);
3546     }
3547   }
3548   else {
3549     BLI_addtail(&ima->views, iv);
3550   }
3551 }
3552
3553 /* after imbuf load, openexr type can return with a exrhandle open */
3554 /* in that case we have to build a render-result */
3555 #ifdef WITH_OPENEXR
3556 static void image_create_multilayer(Image *ima, ImBuf *ibuf, int framenr)
3557 {
3558   const char *colorspace = ima->colorspace_settings.name;
3559   bool predivide = (ima->alpha_mode == IMA_ALPHA_PREMUL);
3560
3561   /* only load rr once for multiview */
3562   if (!ima->rr) {
3563     ima->rr = RE_MultilayerConvert(ibuf->userdata, colorspace, predivide, ibuf->x, ibuf->y);
3564   }
3565
3566   IMB_exr_close(ibuf->userdata);
3567
3568   ibuf->userdata = NULL;
3569   if (ima->rr != NULL) {
3570     ima->rr->framenr = framenr;
3571     BKE_stamp_info_from_imbuf(ima->rr, ibuf);
3572   }
3573
3574   /* set proper views */
3575   image_init_multilayer_multiview(ima, ima->rr);
3576 }
3577 #endif /* WITH_OPENEXR */
3578
3579 /* common stuff to do with images after loading */
3580 static void image_initialize_after_load(Image *ima, ImBuf *UNUSED(ibuf))
3581 {
3582   /* Preview is NULL when it has never been used as an icon before.
3583    * Never handle previews/icons outside of main thread. */
3584   if (G.background == 0 && ima->preview == NULL && BLI_thread_is_main()) {
3585     BKE_icon_changed(BKE_icon_id_ensure(&ima->id));
3586   }
3587
3588   /* timer */
3589   BKE_image_tag_time(ima);
3590
3591   ima->ok = IMA_OK_LOADED;
3592 }
3593
3594 static int imbuf_alpha_flags_for_image(Image *ima)
3595 {
3596   int flag = 0;
3597
3598   if (ima->flag & IMA_IGNORE_ALPHA) {
3599     flag |= IB_ignore_alpha;
3600   }
3601   else if (ima->alpha_mode == IMA_ALPHA_PREMUL) {
3602     flag |= IB_alphamode_premul;
3603   }
3604
3605   return flag;
3606 }
3607
3608 /* the number of files will vary according to the stereo format */
3609 static int image_num_files(Image *ima)
3610 {
3611   const bool is_multiview = BKE_image_is_multiview(ima);
3612
3613   if (!is_multiview) {
3614     return 1;
3615   }
3616   else if (ima->views_format == R_IMF_VIEWS_STEREO_3D) {
3617     return 1;
3618   }
3619   /* R_IMF_VIEWS_INDIVIDUAL */
3620   else {
3621     return BLI_listbase_count(&ima->views);
3622   }
3623 }
3624
3625 static ImBuf *load_sequence_single(
3626     Image *ima, ImageUser *iuser, int frame, const int view_id, bool *r_assign)
3627 {
3628   struct ImBuf *ibuf;
3629   char name[FILE_MAX];
3630   int flag;
3631   ImageUser iuser_t = {0};
3632
3633   ima->lastframe = frame;
3634
3635   if (iuser) {
3636     iuser_t = *iuser;
3637   }
3638   else {
3639     /* TODO(sergey): Do we need to initialize something here? */
3640   }
3641
3642   iuser_t.view = view_id;
3643   BKE_image_user_file_path(&iuser_t, ima, name);
3644
3645   flag = IB_rect | IB_multilayer | IB_metadata;
3646   flag |= imbuf_alpha_flags_for_image(ima);
3647
3648   /* read ibuf */
3649   ibuf = IMB_loadiffname(name, flag, ima->colorspace_settings.name);
3650
3651 #if 0
3652   if (ibuf) {
3653     printf(AT " loaded %s\n", name);
3654   }
3655   else {
3656     printf(AT " missed %s\n", name);
3657   }
3658 #endif
3659
3660   if (ibuf) {
3661 #ifdef WITH_OPENEXR
3662     if (ibuf->ftype == IMB_FTYPE_OPENEXR && ibuf->userdata) {
3663       /* Handle multilayer and multiview cases, don't assign ibuf here.
3664        * will be set layer in BKE_image_acquire_ibuf from ima->rr. */
3665       if (IMB_exr_has_multilayer(ibuf->userdata)) {
3666         image_create_multilayer(ima, ibuf, frame);
3667         ima->type = IMA_TYPE_MULTILAYER;
3668         IMB_freeImBuf(ibuf);
3669         ibuf = NULL;
3670       }
3671     }
3672     else {
3673       image_initialize_after_load(ima, ibuf);
3674       *r_assign = true;
3675     }
3676 #else
3677     image_initialize_after_load(ima, ibuf);
3678     *r_assign = true;
3679 #endif
3680   }
3681
3682   return ibuf;
3683 }
3684
3685 static ImBuf *image_load_sequence_file(Image *ima, ImageUser *iuser, int frame)
3686 {
3687   struct ImBuf *ibuf = NULL;
3688   const bool is_multiview = BKE_image_is_multiview(ima);
3689   const int totfiles = image_num_files(ima);
3690   bool assign = false;
3691
3692   if (!is_multiview) {
3693     ibuf = load_sequence_single(ima, iuser, frame, 0, &assign);
3694     if (assign) {
3695       image_assign_ibuf(ima, ibuf, 0, frame);
3696     }
3697   }
3698   else {
3699     const int totviews = BLI_listbase_count(&ima->views);
3700     int i;
3701     struct ImBuf **ibuf_arr;
3702
3703     ibuf_arr = MEM_mallocN(sizeof(ImBuf *) * totviews, "Image Views Imbufs");
3704
3705     for (i = 0; i < totfiles; i++) {
3706       ibuf_arr[i] = load_sequence_single(ima, iuser, frame, i, &assign);
3707     }
3708
3709     if (BKE_image_is_stereo(ima) && ima->views_format == R_IMF_VIEWS_STEREO_3D) {
3710       IMB_ImBufFromStereo3d(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
3711     }
3712
3713     /* return the original requested ImBuf */
3714     ibuf = ibuf_arr[(iuser ? iuser->multi_index : 0)];
3715
3716     if (assign) {
3717       for (i = 0; i < totviews; i++) {
3718         image_assign_ibuf(ima, ibuf_arr[i], i, frame);
3719       }
3720     }
3721
3722     /* "remove" the others (decrease their refcount) */
3723     for (i = 0; i < totviews; i++) {
3724       if (ibuf_arr[i] != ibuf) {
3725         IMB_freeImBuf(ibuf_arr[i]);
3726       }
3727     }
3728
3729     /* cleanup */
3730     MEM_freeN(ibuf_arr);
3731   }
3732
3733   return ibuf;
3734 }
3735
3736 static ImBuf *image_load_sequence_multilayer(Image *ima, ImageUser *iuser, int frame)
3737 {
3738   struct ImBuf *ibuf = NULL;
3739
3740   /* either we load from RenderResult, or we have to load a new one */
3741
3742   /* check for new RenderResult */
3743   if (ima->rr == NULL || frame != ima->rr->framenr) {
3744     if (ima->rr) {
3745       /* Cached image buffers shares pointers with render result,
3746        * need to ensure there's no image buffers are hanging around
3747        * with dead links after freeing the render result.
3748        */
3749       image_free_cached_frames(ima);
3750       RE_FreeRenderResult(ima->rr);
3751       ima->rr = NULL;
3752     }
3753
3754     ibuf = image_load_sequence_file(ima, iuser, frame);
3755
3756     if (ibuf) { /* actually an error */
3757       ima->type = IMA_TYPE_IMAGE;
3758       printf("error, multi is normal image\n");
3759     }
3760   }
3761   if (ima->rr) {
3762     RenderPass *rpass = BKE_image_multilayer_index(ima->rr, iuser);
3763
3764     if (rpass) {
3765       // printf("load from pass %s\n", rpass->name);
3766       /* since we free  render results, we copy the rect */
3767       ibuf = IMB_allocImBuf(ima->rr->rectx, ima->rr->recty, 32, 0);
3768       ibuf->rect_float = MEM_dupallocN(rpass->rect);
3769       ibuf->flags |= IB_rectfloat;
3770       ibuf->mall = IB_rectfloat;
3771       ibuf->channels = rpass->channels;
3772
3773       BKE_imbuf_stamp_info(ima->rr, ibuf);
3774
3775       image_initialize_after_load(ima, ibuf);
3776       image_assign_ibuf(ima, ibuf, iuser ? iuser->multi_index : 0, frame);
3777     }
3778     // else printf("pass not found\n");
3779   }
3780   else {
3781     ima->ok = 0;
3782   }
3783
3784   if (iuser) {
3785     iuser->ok = ima->ok;
3786   }
3787
3788   return ibuf;
3789 }
3790
3791 static ImBuf *load_movie_single(Image *ima, ImageUser *iuser, int frame, const int view_id)
3792 {
3793   struct ImBuf *ibuf = NULL;
3794   ImageAnim *ia;
3795
3796   ia = BLI_findlink(&ima->anims, view_id);
3797
3798   if (ia->anim == NULL) {
3799     char str[FILE_MAX];
3800     int flags = IB_rect;
3801     ImageUser iuser_t;
3802
3803     if (ima->flag & IMA_DEINTERLACE) {
3804       flags |= IB_animdeinterlace;
3805     }
3806
3807     if (iuser) {
3808       iuser_t = *iuser;
3809     }
3810
3811     iuser_t.view = view_id;
3812
3813     BKE_image_user_file_path(&iuser_t, ima, str);
3814
3815     /* FIXME: make several stream accessible in image editor, too*/
3816     ia->anim = openanim(str, flags, 0, ima->colorspace_settings.name);
3817
3818     /* let's initialize this user */
3819   &