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