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