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