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