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